<!-- SOLID CITY · part 34 -->
onst listeners = new Set();
    const queues = new Map();
    const timers = new Map();
    let sequence = 0;

    function emit(type, detail = {}) {
      const event = Object.freeze({ sequence: ++sequence, type, at: wall(), mono: now(), ...clone(detail) });
      listeners.forEach(listener => listener(event));
      return event;
    }

    function registerOperator(input) {
      if (!input || !input.id || !['HUMAN','AI','SERVICE'].includes(input.kind)) throw new Error('Operator requires id and valid kind');
      const operator = { id: input.id, label: input.label || input.id, kind: input.kind, connected: true, lastHeartbeat: now() };
      operators.set(operator.id, operator);
      emit('operator_registered', { operator: operator.id, kind: operator.kind });
      return clone(operator);
    }

    function registerTask(input) {
      if (!input || !input.id || !operators.has(input.ownerId)) throw new Error('Task requires id and registered owner');
      if (tasks.has(input.id)) throw new Error('Task already registered');
      const task = {
        id: input.id, label: input.label || input.id, ownerId: input.ownerId,
        epoch: 1, status: 'ACTIVE', pendingOwnerId: null,
        safeBehavior: input.safeBehavior || 'HOLD_LAST_SAFE_STATE',
        lastSafeState: input.initialSafeState ?? null, lastCommand: null
      };
      tasks.set(task.id, task); queues.set(task.id, []);
      emit('task_registered', { task: task.id, owner: task.ownerId, epoch: task.epoch });
      return clone(task);
    }

    function claim(taskId, operatorId, presentedEpoch) {
      const task = tasks.get(taskId); const claimant = operators.get(operatorId);
      if (!task || !claimant) return reject('claim_rejected', taskId, operatorId, 'UNKNOWN_TASK_OR_OPERATOR');
      if (!claimant.connected) return reject('claim_rejected', taskId, operatorId, 'OPERATOR_DISCONNECTED', task.epoch);
      if (presentedEpoch != null && presentedEpoch < task.epoch) return reject('stale_claim', taskId, operatorId, 'STALE_OWNERSHIP_EPOCH', task.epoch, presentedEpoch);
      const current = operators.get(task.ownerId);
      const isHumanPriority = claimant.kind === 'HUMAN' && current && current.kind !== 'HUMAN';
      const reclaimDuringGrace = task.status === 'HANDOFF' && task.ownerId === operatorId;
      if (task.ownerId === operatorId && !reclaimDuringGrace) return { ok: true, unchanged: true, task: clone(task) };
      if (!isHumanPriority && !reclaimDuringGrace) return reject('control_conflict', taskId, operatorId, `OWNED_BY_${task.ownerId}`, task.epoch);
      cancelHandoff(taskId);
      const previous = task.ownerId;
      task.ownerId = operatorId; task.pendingOwnerId = null; task.status = 'ACTIVE'; task.epoch += 1;
      emit('ownership_changed', { task: taskId, from: previous, to: operatorId, epoch: task.epoch, cause: reclaimDuringGrace ? 'HANDOFF_INTERRUPTED' : 'HUMAN_PRIORITY_CLAIM' });
      return { ok: true, task: clone(task) };
    }

    function release(taskId, operatorId, nextOwnerId) {
      const task = tasks.get(taskId); const next = operators.get(nextOwnerId);
      if (!task || !next) return reject('release_rejected', taskId, operatorId, 'UNKNOWN_TASK_OR_NEXT_OWNER');
      if (task.ownerId !== operatorId) return reject('release_rejected', taskId, operatorId, `NOT_OWNER_CURRENT_${task.ownerId}`, task.epoch);
      if (next.kind === 'HUMAN') return reject('release_rejected', taskId, operatorId, 'GRACE_HANDOFF_REQUIRES_NON_HUMAN_TARGET', task.epoch);
      cancelHandoff(taskId);
      const started = now(); task.status = 'HANDOFF'; task.pendingOwnerId = nextOwnerId;
      emit('handoff_started', { task: taskId, from: operatorId, to: nextOwnerId, epoch: task.epoch, graceMs: config.releaseGraceMs });
      const timer = setTimeout(() => {
        timers.delete(taskId);
        if (task.status !== 'HANDOFF' || task.pendingOwnerId !== nextOwnerId || !next.connected) {
          emit('handoff_interrupted', { task: taskId, from: operatorId, to: nextOwnerId, epoch: task.epoch, cause: !next.connected ? 'TARGET_DISCONNECTED' : 'AUTHORITY_CHANGED' });
          if (!next.connected) degradeTask(task, 'HANDOFF_TARGET_DISCONNECTED');
          return;
        }
        task.ownerId = nextOwnerId; task.pendingOwnerId = null; task.status = 'ACTIVE'; task.epoch += 1;
        emit('handoff_completed', { task: taskId, from: operatorId, to: nextOwnerId, epoch: task.epoch, latencyMs: Math.round(now() - started) });
      }, config.releaseGraceMs);
      timers.set(taskId, timer);
      return { ok: true, task: clone(task) };
    }

    function cancelHandoff(taskId) {
      const timer = timers.get(taskId);
      if (timer) clearTimeout(timer);
      timers.delete(taskId);
    }

    function command(message) {
      const task = tasks.get(message.taskId); const operator = operators.get(message.operatorId);
      if (!task || !operator) return reject('command_rejected', message.taskId, message.operatorId,