<!-- SOLID CITY · part 35 -->
'UNKNOWN_TASK_OR_OPERATOR');
      if (!message.id) return reject('command_rejected', task.id, operator.id, 'MISSING_COMMAND_ID', task.epoch);
      if (seenCommandIds.has(message.id)) return reject('duplicate_drop', task.id, operator.id, 'DUPLICATE_COMMAND_ID', task.epoch, message.epoch, message.id);
      seenCommandIds.add(message.id);
      if (!operator.connected) return reject('command_rejected', task.id, operator.id, 'OPERATOR_DISCONNECTED', task.epoch, message.epoch, message.id);
      if (Date.now() - message.issuedAt > config.freshnessMs) return reject('delayed_drop', task.id, operator.id, 'FRESHNESS_WINDOW_EXCEEDED', task.epoch, message.epoch, message.id);
      if (message.epoch !== task.epoch) return reject('stale_command', task.id, operator.id, 'OWNERSHIP_EPOCH_MISMATCH', task.epoch, message.epoch, message.id);
      if (task.ownerId !== operator.id || task.status !== 'ACTIVE') return reject('control_conflict', task.id, operator.id, `NOT_ACTIVE_OWNER_CURRENT_${task.ownerId}`, task.epoch, message.epoch, message.id);
      const queue = queues.get(task.id);
      if (queue.length >= config.queueLimit) {
        const dropped = queue.shift();
        emit('queue_shed', { task: task.id, operator: dropped.operatorId, epoch: dropped.epoch, commandId: dropped.id, cause: 'QUEUE_LIMIT_NEWEST_AUTHORITY_WINS', droppedFor: message.id });
      }
      queue.push({ ...message }); scheduleDrain(task.id);
      emit('command_queued', { task: task.id, operator: operator.id, epoch: message.epoch, commandId: message.id, depth: queue.length });
      return { ok: true, queued: true };
    }

    function scheduleDrain(taskId) {
      const queue = queues.get(taskId);
      if (queue.draining) return;
      queue.draining = true;
      setTimeout(function drain() {
        const message = queue.shift(); const task = tasks.get(taskId); const operator = message && operators.get(message.operatorId);
        if (message) {
          if (!operator || !operator.connected) reject('command_rejected', taskId, message.operatorId, 'OPERATOR_DISCONNECTED_AT_EXECUTION', task.epoch, message.epoch, message.id);
          else if (message.epoch !== task.epoch || message.operatorId !== task.ownerId || task.status !== 'ACTIVE') reject('stale_command', taskId, message.operatorId, 'AUTHORITY_CHANGED_BEFORE_EXECUTION', task.epoch, message.epoch, message.id);
          else if (Date.now() - message.issuedAt > config.freshnessMs) reject('delayed_drop', taskId, message.operatorId, 'EXPIRED_IN_QUEUE', task.epoch, message.epoch, message.id);
          else {
            task.lastCommand = message.action; if (message.safeState !== undefined) task.lastSafeState = message.safeState;
            config.onExecute(clone(message), clone(task));
            emit('command_executed', { task: taskId, operator: message.operatorId, epoch: message.epoch, commandId: message.id, action: message.action });
          }
        }
        if (queue.length) setTimeout(drain, config.drainDelayMs); else queue.draining = false;
      }, config.drainDelayMs);
    }

    function advisory(message) {
      if (!operators.has(message.operatorId) || !tasks.has(message.taskId)) return { ok: false, reason: 'UNKNOWN_TASK_OR_OPERATOR' };
      emit('advisory', { task: message.taskId, operator: message.operatorId, severity: message.severity || 'INFO', text: String(message.text || '') });
      return { ok: true };
    }

    function heartbeat(operatorId) {
      const operator = operators.get(operatorId); if (!operator) return { ok: false };
      const restored = !operator.connected; operator.connected = true; operator.lastHeartbeat = now();
      if (restored) {
        emit('operator_reconnected', { operator: operatorId, cause: 'HEARTBEAT_VERIFIED' });
        tasks.forEach(task => { if (task.ownerId === operatorId && task.status === 'DEGRADED') task.status = 'ACTIVE'; });
      }
      return { ok: true };
    }

    function disconnect(operatorId, cause = 'EXPLICIT_DISCONNECT') {
      const operator = operators.get(operatorId); if (!operator) return { ok: false };
      operator.connected = false;
      emit('operator_disconnected', { operator: operatorId, cause });
      tasks.forEach(task => { if (task.ownerId === operatorId) degradeTask(task, cause); });
      return { ok: true };
    }

    function degradeTask(task, cause) {
      cancelHandoff(task.id); task.status = 'DEGRADED'; task.pendingOwnerId = null;
      config.onSafeBehavior(clone(task), cause);
      emit('task_degraded', { task: task.id, operator: task.ownerId, epoch: task.epoch, cause, safeBehavior: task.safeBehavior, lastSafeState: task.lastSafeState });
    }

    function checkHeartbeats() {
      const t = now();
      operators.forEach(operator => {
        if (operator.connected && t - operator.lastHeartbeat > config.heartbeatTimeoutMs) disconnect(operator.id, 'HEARTBEAT_TIMEOUT');
      });
    }

    function reject(type, task, operator, cause, currentEpoch