chatroom-cli 1.65.7 → 1.65.9

package/dist/index.js

@@ -36196,6 +36196,21 @@ var init_terminal_provider_error = __esm(() => {
   PROVIDER_ERROR_NAMES = ["ai_apicallerror", "ai_retryerror"];
 });
 
+// src/infrastructure/services/remote-agents/opencode-sdk/opencode-session-status.ts
+function isOpenCodeSessionStatus(value) {
+  return typeof value === "string" && OPENCODE_SESSION_STATUSES.includes(value);
+}
+function parseOpenCodeSessionStatus(raw) {
+  return isOpenCodeSessionStatus(raw) ? raw : null;
+}
+function assertNeverOpenCodeSessionStatus(value, context5) {
+  throw new Error(`Unhandled OpenCode session status in ${context5}: ${String(value)}`);
+}
+var OPENCODE_SESSION_STATUSES;
+var init_opencode_session_status = __esm(() => {
+  OPENCODE_SESSION_STATUSES = ["idle", "busy", "retry"];
+});
+
 // src/infrastructure/services/remote-agents/opencode-sdk/session-event-forwarder.ts
 function formatLogLine(options, kind, payload) {
   return formatTimestampedLogLine(options.role, kind, payload, options.now);
@@ -36304,6 +36319,15 @@ function startSessionEventForwarder(client4, options) {
     cancelled = true;
     emitAgentEnd("provider_rate_limit");
   }
+  function armTurnEnd() {
+    if (terminalAbortRequested) {
+      logLine(target, "status", "turn_arm_blocked_terminal");
+      return;
+    }
+    clearRetryIdleTimeout();
+    agentEndEmitted = false;
+    lastStatus = undefined;
+  }
   function resolvePartContent(delta, text) {
     return delta !== undefined && delta !== "" ? delta : text;
   }
@@ -36386,11 +36410,22 @@ function startSessionEventForwarder(client4, options) {
     logLine(target, "compacted");
   }
   async function handleSessionStatus(props) {
-    const currentStatus = props?.status?.type;
-    if (currentStatus !== lastStatus) {
-      lastStatus = currentStatus;
-      logLine(target, "status", currentStatus);
-      if (currentStatus === "retry") {
+    const raw = props?.status?.type;
+    const parsed = parseOpenCodeSessionStatus(raw);
+    if (parsed === null) {
+      const unknownKey = raw === undefined ? "undefined" : String(raw);
+      if (unknownKey !== lastStatus) {
+        lastStatus = unknownKey;
+        logLine(target, "status", `unknown_session_status:${unknownKey}`);
+      }
+      return;
+    }
+    if (parsed === lastStatus)
+      return;
+    lastStatus = parsed;
+    logLine(target, "status", parsed);
+    switch (parsed) {
+      case "retry": {
         if (terminalAbortRequested) {
           abortTerminalProviderError();
           return;
@@ -36398,7 +36433,18 @@ function startSessionEventForwarder(client4, options) {
         scheduleRetryIdleTimeout();
         return;
       }
-      clearRetryIdleTimeout();
+      case "idle": {
+        clearRetryIdleTimeout();
+        await handleSessionIdle();
+        return;
+      }
+      case "busy": {
+        clearRetryIdleTimeout();
+        return;
+      }
+      default: {
+        assertNeverOpenCodeSessionStatus(parsed, "handleSessionStatus");
+      }
     }
   }
   async function handleSessionError(props) {
@@ -36489,12 +36535,14 @@ function startSessionEventForwarder(client4, options) {
     onAgentEnd: (cb) => {
       agentEndCallbacks.push(cb);
     },
-    abortTerminalProviderError
+    abortTerminalProviderError,
+    armTurnEnd
   };
 }
 var RECENT_LOG_LINE_CAP = 20, DEFAULT_SESSION_RETRY_IDLE_TIMEOUT_MS;
 var init_session_event_forwarder = __esm(() => {
   init_terminal_provider_error();
+  init_opencode_session_status();
   DEFAULT_SESSION_RETRY_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
@@ -37010,6 +37058,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
 `);
         return;
       }
+      this.forwarders.get(pid)?.armTurnEnd();
       const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
       const deferredSystem = meta.deferredSystemPrompt;
       const context5 = {
@@ -84676,7 +84725,7 @@ var init_featureFlags = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS;
+var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS;
 var init_reliability = __esm(() => {
   DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
   DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
@@ -84731,6 +84780,780 @@ var init_daemon_services = __esm(() => {
   };
 });
 
+// ../../services/backend/src/domain/entities/participant.ts
+var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", NATIVE_HANDOFF_REMINDER = "Reminder: Use the handoff command to send your response to the team.", ONLINE_OR_STARTING_STATUSES;
+var init_participant = __esm(() => {
+  ONLINE_OR_STARTING_STATUSES = new Set([
+    "agent.waiting",
+    "agent.requestStart",
+    "agent.started",
+    "task.acknowledged",
+    "task.inProgress",
+    "task.completed",
+    "agent.requestStop",
+    "agent.awaitingHandoff"
+  ]);
+});
+
+// src/commands/machine/daemon-start/native-ready-invariant.ts
+function isAgentReadyForNativeDelivery(task, slot) {
+  return explainAgentReadyForNativeDeliveryBlock(task, slot) === null;
+}
+function explainAgentReadyForNativeDeliveryBlock(task, slot) {
+  const { agentConfig } = task;
+  if (!isNativeHarness(agentConfig.agentHarness)) {
+    return `not_native_harness (harness=${agentConfig.agentHarness})`;
+  }
+  if (agentConfig.desiredState !== "running") {
+    return `desired_state_not_running (desiredState=${agentConfig.desiredState})`;
+  }
+  if (agentConfig.spawnedAgentPid == null) {
+    return "spawned_pid_missing";
+  }
+  if (!slot) {
+    return `slot_missing (expectedPid=${agentConfig.spawnedAgentPid})`;
+  }
+  if (slot.state !== "running") {
+    return `slot_not_running (slotState=${slot.state}, expectedPid=${agentConfig.spawnedAgentPid})`;
+  }
+  if (slot.pid !== agentConfig.spawnedAgentPid) {
+    return `pid_mismatch (slotPid=${slot.pid ?? "none"}, snapshotPid=${agentConfig.spawnedAgentPid})`;
+  }
+  if (typeof slot.harnessSessionId !== "string" || slot.harnessSessionId.length === 0) {
+    return "harness_session_missing";
+  }
+  const turnPhase = slot.nativeTurnPhase ?? "idle";
+  if (turnPhase !== "idle") {
+    return `turn_not_idle (nativeTurnPhase=${turnPhase})`;
+  }
+  return null;
+}
+function isDeliverableNativeTaskStatus(status3) {
+  return status3 === "pending" || status3 === "acknowledged";
+}
+var init_native_ready_invariant = __esm(() => {
+  init_types();
+});
+
+// src/commands/machine/daemon-start/assigned-task-snapshot-store.ts
+function replaceAssignedTaskSnapshots(next4) {
+  rows = [...next4];
+  hasSnapshot = true;
+}
+function clearAssignedTaskSnapshots() {
+  rows = [];
+  hasSnapshot = false;
+}
+function hasAssignedTaskSnapshot() {
+  return hasSnapshot;
+}
+function listAssignedTaskSnapshots() {
+  return [...rows];
+}
+function listAssignedTaskSnapshotsForRole(chatroomId, role) {
+  const roleLower = role.toLowerCase();
+  return rows.filter((row) => row.chatroomId === chatroomId && row.agentConfig.role.toLowerCase() === roleLower);
+}
+var rows, hasSnapshot = false;
+var init_assigned_task_snapshot_store = __esm(() => {
+  rows = [];
+});
+
+// src/commands/machine/daemon-start/native-delivery-log.ts
+function logNativeDeliveryPrimary(role, chatroomId) {
+  console.log(`[NativeDelivery:primary] turn idle ${role}@${chatroomId} — trying inject`);
+}
+function logNativeDeliveryFallback(reason, role, chatroomId, taskId) {
+  const taskSuffix = taskId ? ` task ${taskId}` : "";
+  console.log(`[NativeDelivery:fallback] ${reason} ${role}@${chatroomId}${taskSuffix} — reconcile`);
+}
+function logNativeDeliverySkip(role, chatroomId, taskId, reason) {
+  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — ${reason}`);
+}
+function logNativeDeliveryMutexSkip(role, chatroomId, taskId) {
+  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — delivery_mutex_busy (another inject in flight)`);
+}
+function logNativeDeliveryInjecting(role, chatroomId, taskId) {
+  console.log(`[NativeDelivery:inject] ${role}@${chatroomId} task ${taskId} — starting injection`);
+}
+function logNativeDeliveryNoTasks(role, chatroomId) {
+  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} — no pending tasks for role`);
+}
+
+// src/commands/machine/daemon-start/native-delivery-session-registry.ts
+function registerNativeDeliverySession(ctx) {
+  registered = ctx;
+}
+function unregisterNativeDeliverySession() {
+  registered = null;
+}
+function getNativeDeliverySession() {
+  return registered;
+}
+var registered = null;
+
+// src/domain/native-integration/predicates.ts
+function isStaleCliGetNextTaskWaiting(task) {
+  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
+  return task.participant?.lastSeenAction === "get-next-task:started" && task.createdAt > lastSeenAt;
+}
+function isCliIdleNotListening(task, now, thresholdMs) {
+  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
+  if (lastSeenAt === 0)
+    return now - task.createdAt > thresholdMs;
+  return now - lastSeenAt > thresholdMs;
+}
+
+// src/infrastructure/services/remote-agents/spawn-prompt.ts
+function createSpawnPrompt(raw, opts) {
+  if (opts?.nativeBootstrap) {
+    return NATIVE_BOOTSTRAP_PROMPT;
+  }
+  const trimmed = raw?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_TRIGGER_PROMPT;
+}
+var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.", NATIVE_BOOTSTRAP_PROMPT = "Focus on your role responsibilities. Complete each task via handoff.";
+
+// src/domain/native-integration/spawn-policy.ts
+function shouldDeferInitialTurn(harness) {
+  return isNativeHarness(harness);
+}
+function resolveNativeSpawnPolicy(harness, initMessage) {
+  const deferInitialTurn = shouldDeferInitialTurn(harness);
+  return {
+    deferInitialTurn,
+    prompt: createSpawnPrompt(initMessage, { nativeBootstrap: deferInitialTurn })
+  };
+}
+var init_spawn_policy = __esm(() => {
+  init_types();
+});
+
+// src/domain/native-integration/index.ts
+var init_native_integration = __esm(() => {
+  init_types();
+  init_spawn_policy();
+});
+
+// src/commands/machine/daemon-start/native-task-injector-logic.ts
+function explainNativeDeliveryBlock(task, opts) {
+  if (!isDeliverableNativeTaskStatus(task.status)) {
+    return `task_status_not_deliverable (status=${task.status})`;
+  }
+  if (task.status === "acknowledged") {
+    const assignedTo = task.assignedTo?.toLowerCase();
+    const role = task.agentConfig.role.toLowerCase();
+    if (assignedTo !== role) {
+      return `acknowledged_wrong_role (assignedTo=${assignedTo ?? "none"}, role=${role})`;
+    }
+  }
+  return explainAgentReadyForNativeDeliveryBlock(task, opts.slot);
+}
+function buildNativeInjectionPrompt(params) {
+  const { taskDeliveryOutput, augmentationMode } = params;
+  if (augmentationMode === "compact") {
+    return [
+      "⚠️ Context was compacted. Run `chatroom get-system-prompt` only if role instructions are missing.",
+      "",
+      taskDeliveryOutput
+    ].join(`
+`);
+  }
+  if (augmentationMode === "new_session") {
+    return [
+      "⚠️ Starting a new agent session. Run `chatroom get-system-prompt` to reload role instructions if needed.",
+      "",
+      taskDeliveryOutput
+    ].join(`
+`);
+  }
+  return taskDeliveryOutput;
+}
+var init_native_task_injector_logic = __esm(() => {
+  init_native_ready_invariant();
+  init_native_integration();
+});
+
+// ../../services/backend/src/domain/entities/team-agent-settings.ts
+function roleSupportsSessionAugmentation(role) {
+  const normalized = role.toLowerCase();
+  return SESSION_AUGMENTATION_ROLES.some((r) => r === normalized);
+}
+var SESSION_AUGMENTATION_ROLES;
+var init_team_agent_settings = __esm(() => {
+  SESSION_AUGMENTATION_ROLES = ["builder"];
+});
+
+// ../../services/backend/src/domain/handoff/parse-session-augmentation.ts
+function findSectionIndex(content, headings) {
+  const indices = headings.map((heading) => content.indexOf(heading)).filter((idx) => idx !== -1);
+  return indices.length === 0 ? -1 : Math.min(...indices);
+}
+function normalizeMode(raw) {
+  return MODE_ALIASES[raw.toLowerCase()] ?? DEFAULT_MODE;
+}
+function extractSectionBody(content, sectionIdx) {
+  const matchedHeading = SECTION_HEADINGS.find((h) => content.indexOf(h, sectionIdx) === sectionIdx) ?? SECTION_HEADINGS[0];
+  const afterSection = content.slice(sectionIdx);
+  const nextHeading = afterSection.slice(matchedHeading.length).search(/\n## /);
+  return nextHeading === -1 ? afterSection : afterSection.slice(0, matchedHeading.length + nextHeading);
+}
+function parseSessionAugmentation(handoffContent) {
+  const sectionIdx = findSectionIndex(handoffContent, SECTION_HEADINGS);
+  if (sectionIdx === -1)
+    return DEFAULT_MODE;
+  const match17 = extractSectionBody(handoffContent, sectionIdx).match(DATA_TAG);
+  if (!match17)
+    return DEFAULT_MODE;
+  return normalizeMode(match17[1]);
+}
+function resolveSessionAugmentationForRole(handoffContent, role) {
+  if (!roleSupportsSessionAugmentation(role)) {
+    return "none";
+  }
+  return parseSessionAugmentation(handoffContent);
+}
+function sessionAugmentationToWantResume(mode) {
+  return mode === "none" || mode === "compact";
+}
+function sessionAugmentationNewSessionStarted(mode) {
+  return mode === "new_session";
+}
+var SECTION_HEADINGS, DATA_TAG, DEFAULT_MODE = "new_session", MODE_ALIASES;
+var init_parse_session_augmentation = __esm(() => {
+  init_team_agent_settings();
+  SECTION_HEADINGS = [
+    "## Session Augmentation",
+    "## Session Management",
+    "## Restart new context"
+  ];
+  DATA_TAG = /\/\/\s*data:agent\.(?:session_augmentation|compress_context)=(none|compact|new_session|reset)\b/i;
+  MODE_ALIASES = {
+    reset: "new_session",
+    none: "none",
+    compact: "compact",
+    new_session: "new_session"
+  };
+});
+
+// src/commands/machine/daemon-start/native-task-injector.ts
+async function emitTaskDeliveryFailed(deps, args2) {
+  try {
+    await deps.backend.mutation(api.machines.emitTaskDeliveryFailed, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      chatroomId: args2.chatroomId,
+      role: args2.role,
+      taskId: args2.taskId,
+      error: args2.error
+    });
+  } catch {}
+}
+function runNativeInjectionEffect(task, harnessSessionId, deps) {
+  return exports_Effect.gen(function* () {
+    const { chatroomId, taskId, taskContent, agentConfig, status: status3 } = task;
+    const { role } = agentConfig;
+    if (status3 === "pending") {
+      const claimResult = yield* exports_Effect.tryPromise({
+        try: () => deps.backend.mutation(api.tasks.claimTask, {
+          sessionId: deps.sessionId,
+          chatroomId,
+          role,
+          taskId
+        }),
+        catch: (err) => err
+      }).pipe(exports_Effect.either);
+      if (claimResult._tag === "Left") {
+        yield* exports_Effect.tryPromise({
+          try: () => emitTaskDeliveryFailed(deps, {
+            chatroomId,
+            role,
+            taskId,
+            error: getErrorMessage2(claimResult.left)
+          }),
+          catch: () => {
+            return;
+          }
+        }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+        return yield* exports_Effect.fail(claimResult.left);
+      }
+    }
+    const deliveryResult = yield* exports_Effect.tryPromise({
+      try: () => deps.backend.query(api.messages.getTaskDeliveryPrompt, {
+        sessionId: deps.sessionId,
+        chatroomId,
+        role,
+        taskId,
+        convexUrl: deps.convexUrl
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (deliveryResult._tag === "Left") {
+      yield* exports_Effect.tryPromise({
+        try: () => emitTaskDeliveryFailed(deps, {
+          chatroomId,
+          role,
+          taskId,
+          error: getErrorMessage2(deliveryResult.left)
+        }),
+        catch: () => {
+          return;
+        }
+      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+      return yield* exports_Effect.fail(deliveryResult.left);
+    }
+    const delivery = deliveryResult.right;
+    const augmentationMode = resolveSessionAugmentationForRole(taskContent, role);
+    const prompt = buildNativeInjectionPrompt({
+      taskDeliveryOutput: delivery.fullCliOutput,
+      augmentationMode
+    });
+    yield* exports_Effect.tryPromise({
+      try: () => deps.backend.mutation(api.participants.join, {
+        sessionId: deps.sessionId,
+        chatroomId,
+        role,
+        action: NATIVE_TASK_INJECTED_ACTION,
+        taskId
+      }),
+      catch: (err) => err
+    });
+    if (roleSupportsSessionAugmentation(role)) {
+      yield* exports_Effect.tryPromise({
+        try: () => deps.backend.mutation(api.machines.emitSessionAugmented, {
+          sessionId: deps.sessionId,
+          machineId: deps.machineId,
+          chatroomId,
+          role,
+          taskId,
+          mode: augmentationMode,
+          newSessionStarted: sessionAugmentationNewSessionStarted(augmentationMode),
+          harnessSessionId
+        }),
+        catch: (err) => err
+      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    }
+    const resumeResult = yield* exports_Effect.tryPromise({
+      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (resumeResult._tag === "Left") {
+      const error = getErrorMessage2(resumeResult.left);
+      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${error}`);
+      yield* exports_Effect.tryPromise({
+        try: () => emitTaskDeliveryFailed(deps, {
+          chatroomId,
+          role,
+          taskId,
+          error
+        }),
+        catch: () => {
+          return;
+        }
+      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+      return;
+    }
+    yield* exports_Effect.tryPromise({
+      try: () => deps.backend.mutation(api.machines.emitTaskDelivered, {
+        sessionId: deps.sessionId,
+        machineId: deps.machineId,
+        chatroomId,
+        role,
+        taskId
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    deps.onTaskDelivered?.({ chatroomId, role, taskId });
+  });
+}
+var init_native_task_injector = __esm(() => {
+  init_participant();
+  init_team_agent_settings();
+  init_parse_session_augmentation();
+  init_esm();
+  init_native_task_injector_logic();
+  init_api3();
+  init_convex_error();
+});
+
+// src/commands/machine/daemon-start/role-delivery-state.ts
+function roleKey(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+
+class RoleDeliveryState {
+  generation = new Map;
+  inFlight = new Set;
+  nativeNudgeFailures = new Map;
+  getGeneration(chatroomId, role) {
+    return this.generation.get(roleKey(chatroomId, role)) ?? 0;
+  }
+  resetDeliveryState(chatroomId, role) {
+    const key = roleKey(chatroomId, role);
+    const next4 = (this.generation.get(key) ?? 0) + 1;
+    this.generation.set(key, next4);
+    this.inFlight.delete(key);
+    this.nativeNudgeFailures.delete(key);
+    return next4;
+  }
+  tryAcquireDelivery(chatroomId, role) {
+    const key = roleKey(chatroomId, role);
+    if (this.inFlight.has(key))
+      return false;
+    this.inFlight.add(key);
+    return true;
+  }
+  releaseDelivery(chatroomId, role) {
+    this.inFlight.delete(roleKey(chatroomId, role));
+  }
+  recordNativeNudgeFailure(chatroomId, role) {
+    const key = roleKey(chatroomId, role);
+    const count3 = (this.nativeNudgeFailures.get(key) ?? 0) + 1;
+    this.nativeNudgeFailures.set(key, count3);
+    return count3;
+  }
+  clearNativeNudgeFailures(chatroomId, role) {
+    this.nativeNudgeFailures.delete(roleKey(chatroomId, role));
+  }
+  getNativeNudgeFailures(chatroomId, role) {
+    return this.nativeNudgeFailures.get(roleKey(chatroomId, role)) ?? 0;
+  }
+}
+function getRoleDeliveryState() {
+  shared ??= new RoleDeliveryState;
+  return shared;
+}
+var shared;
+
+// src/commands/machine/daemon-start/native-task-delivery-coordinator.ts
+class NativeTaskDeliveryCoordinator {
+  onSessionLost(params) {
+    getRoleDeliveryState().resetDeliveryState(params.chatroomId, params.role);
+  }
+  resetRoleDeliveryState(chatroomId, role) {
+    getRoleDeliveryState().resetDeliveryState(chatroomId, role);
+  }
+  tryInjectNextForRole(chatroomId, role) {
+    const session2 = getNativeDeliverySession();
+    if (!session2)
+      return;
+    const { runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = session2;
+    const tasks = listAssignedTaskSnapshotsForRole(chatroomId, role);
+    if (tasks.length === 0) {
+      logNativeDeliveryNoTasks(role, chatroomId);
+      return;
+    }
+    this.reconcileAssignedTasks({
+      tasks,
+      runtime: runtime4,
+      effectContext: effectContext2,
+      agentMgr,
+      sessionDeps,
+      machineId
+    });
+  }
+  reconcileAssignedTasks(params) {
+    const { tasks, runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = params;
+    const deliveryState = getRoleDeliveryState();
+    const pendingFirst = [...tasks].sort((a, b) => {
+      if (a.status === "pending" && b.status !== "pending")
+        return -1;
+      if (b.status === "pending" && a.status !== "pending")
+        return 1;
+      return a.createdAt - b.createdAt;
+    });
+    for (const row of pendingFirst) {
+      const { role } = row.agentConfig;
+      const slot = agentMgr.getSlot(row.chatroomId, role);
+      const blockReason = explainNativeDeliveryBlock(row, { slot });
+      if (blockReason) {
+        if (row.status === "pending" || row.status === "acknowledged") {
+          logNativeDeliverySkip(role, row.chatroomId, row.taskId, blockReason);
+        }
+        continue;
+      }
+      if (!deliveryState.tryAcquireDelivery(row.chatroomId, role)) {
+        logNativeDeliveryMutexSkip(role, row.chatroomId, row.taskId);
+        continue;
+      }
+      logNativeDeliveryInjecting(role, row.chatroomId, row.taskId);
+      exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
+        const full = yield* exports_Effect.tryPromise(() => sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
+          sessionId: sessionDeps.sessionId,
+          machineId,
+          taskId: row.taskId,
+          role: row.agentConfig.role
+        }));
+        if (!full) {
+          console.warn(`[NativeDelivery:skip] ${role}@${row.chatroomId} task ${row.taskId} — task_hydrate_missing (deleted or not assigned)`);
+          return;
+        }
+        const harnessSessionId = slot?.harnessSessionId;
+        if (!harnessSessionId) {
+          console.warn(`[NativeDelivery:skip] ${role}@${row.chatroomId} task ${row.taskId} — harness_session_missing (post-gate)`);
+          return;
+        }
+        yield* runNativeInjectionEffect(full, harnessSessionId, {
+          sessionId: sessionDeps.sessionId,
+          machineId: sessionDeps.machineId,
+          backend: sessionDeps.backend,
+          agentMgr: {
+            resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
+          },
+          convexUrl: sessionDeps.convexUrl,
+          onTaskDelivered: ({ chatroomId, role: role2, taskId }) => {
+            exports_Effect.runSync(agentMgr.setLastInFlightTask(chatroomId, role2, taskId));
+            deliveryState.clearNativeNudgeFailures(chatroomId, role2);
+          }
+        });
+      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${row.agentConfig.role}@${row.chatroomId}: ${getErrorMessage2(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => deliveryState.releaseDelivery(row.chatroomId, row.agentConfig.role)))));
+      break;
+    }
+  }
+}
+function getNativeTaskDeliveryCoordinator() {
+  coordinator ??= new NativeTaskDeliveryCoordinator;
+  return coordinator;
+}
+function notifyNativeSessionLost(params) {
+  getNativeTaskDeliveryCoordinator().onSessionLost(params);
+}
+function resetRoleDeliveryState(chatroomId, role) {
+  getRoleDeliveryState().resetDeliveryState(chatroomId, role);
+}
+function notifyNativeTurnIdle(params) {
+  logNativeDeliveryPrimary(params.role, params.chatroomId);
+  getNativeTaskDeliveryCoordinator().tryInjectNextForRole(params.chatroomId, params.role);
+}
+var coordinator;
+var init_native_task_delivery_coordinator = __esm(() => {
+  init_esm();
+  init_assigned_task_snapshot_store();
+  init_native_task_injector_logic();
+  init_native_task_injector();
+  init_api3();
+  init_convex_error();
+});
+
+// src/commands/machine/daemon-start/restart-orchestrator.ts
+async function emitPhase(deps, event, phase, detail) {
+  await deps.session.backend.mutation(api.machines.emitRestartPhase, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId,
+    chatroomId: event.chatroomId,
+    role: event.role,
+    correlationId: event.correlationId,
+    phase,
+    detail
+  });
+}
+function sleep5(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function waitForHarnessSessionId(deps, event, pid) {
+  const initial = deps.agentMgr.getSlot(event.chatroomId, event.role);
+  if (initial?.harnessSessionId) {
+    return initial.harnessSessionId;
+  }
+  await deps.session.backend.mutation(api.machines.emitHarnessSessionAwaiting, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId,
+    chatroomId: event.chatroomId,
+    role: event.role,
+    pid,
+    timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS
+  });
+  const deadline = Date.now() + HARNESS_SESSION_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
+    if (slot?.harnessSessionId) {
+      return slot.harnessSessionId;
+    }
+    await sleep5(100);
+  }
+  await deps.session.backend.mutation(api.machines.emitHarnessSessionTimeout, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId,
+    chatroomId: event.chatroomId,
+    role: event.role,
+    pid,
+    timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS
+  });
+  await deps.agentMgr.stop({
+    chatroomId: event.chatroomId,
+    role: event.role,
+    reason: "user.restart",
+    pid
+  });
+  return null;
+}
+async function forceNativeWaiting(deps, event) {
+  await deps.session.backend.mutation(api.participants.join, {
+    sessionId: deps.session.sessionId,
+    chatroomId: event.chatroomId,
+    role: event.role,
+    action: NATIVE_WAITING_ACTION
+  });
+}
+async function listDeliverableSnapshots(deps, event) {
+  await deps.session.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId
+  });
+  const result = await deps.session.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId
+  });
+  const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
+  return (result.tasks ?? []).filter((t) => t.chatroomId === event.chatroomId && t.agentConfig.role.toLowerCase() === event.role.toLowerCase() && (t.status === "pending" || t.status === "acknowledged") && isAgentReadyForNativeDelivery(t, slot)).sort((a, b) => a.createdAt - b.createdAt);
+}
+async function deliverOneTask(deps, event, snapshot) {
+  const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
+  const harnessSessionId = slot?.harnessSessionId;
+  if (!harnessSessionId)
+    return false;
+  const full = await deps.session.backend.query(api.machines.getAssignedTaskForAction, {
+    sessionId: deps.session.sessionId,
+    machineId: deps.session.machineId,
+    taskId: snapshot.taskId,
+    role: event.role
+  });
+  if (!full)
+    return false;
+  try {
+    await exports_Effect.runPromise(runNativeInjectionEffect(full, harnessSessionId, {
+      sessionId: deps.session.sessionId,
+      machineId: deps.session.machineId,
+      backend: deps.session.backend,
+      convexUrl: deps.session.convexUrl,
+      agentMgr: {
+        resumeTurnForSlot: async (args2) => {
+          await exports_Effect.runPromise(deps.agentMgr.resumeTurnForSlot(args2));
+        }
+      },
+      onTaskDelivered: ({ chatroomId, role, taskId }) => {
+        deps.agentMgr.setLastInFlightTask(chatroomId, role, taskId);
+      }
+    }));
+    return true;
+  } catch (err) {
+    console.warn(`[RestartOrchestrator] deliver failed for task ${snapshot.taskId}: ${getErrorMessage2(err)}`);
+    return false;
+  }
+}
+async function deliverPendingTasks(deps, event) {
+  const delivered = [];
+  const snapshots = await listDeliverableSnapshots(deps, event);
+  for (const snapshot of snapshots) {
+    if (snapshot.status !== "pending")
+      continue;
+    const ok = await deliverOneTask(deps, event, snapshot);
+    if (ok) {
+      delivered.push(snapshot.taskId);
+    }
+  }
+  return delivered;
+}
+async function runRestartOrchestrator(deps, event) {
+  const { chatroomId, role } = event;
+  try {
+    await emitPhase(deps, event, "reset");
+    resetRoleDeliveryState(chatroomId, role);
+    await deps.agentMgr.stop({
+      chatroomId,
+      role,
+      reason: "user.restart"
+    });
+    await emitPhase(deps, event, "spawn");
+    const spawnResult = await exports_Effect.runPromise(deps.agentMgr.ensureRunning({
+      chatroomId,
+      role,
+      agentHarness: event.agentHarness,
+      model: event.model,
+      workingDir: event.workingDir,
+      reason: "user.restart",
+      wantResume: event.wantResume ?? true
+    }));
+    if (!spawnResult.success || !spawnResult.pid) {
+      await emitPhase(deps, event, "failed", spawnResult.error ?? "spawn failed");
+      return;
+    }
+    await emitPhase(deps, event, "await_session");
+    const harnessSessionId = await waitForHarnessSessionId(deps, event, spawnResult.pid);
+    if (!harnessSessionId) {
+      await emitPhase(deps, event, "failed", "harnessSessionId timeout");
+      return;
+    }
+    await deps.session.backend.mutation(api.machines.emitHarnessSessionReady, {
+      sessionId: deps.session.sessionId,
+      machineId: deps.session.machineId,
+      chatroomId,
+      role,
+      harnessSessionId,
+      pid: spawnResult.pid
+    });
+    await forceNativeWaiting(deps, event);
+    await emitPhase(deps, event, "ready");
+    await emitPhase(deps, event, "deliver");
+    const deliveredTaskIds = await deliverPendingTasks(deps, event);
+    await deps.session.backend.mutation(api.machines.emitRestartCompleted, {
+      sessionId: deps.session.sessionId,
+      machineId: deps.session.machineId,
+      chatroomId,
+      role,
+      correlationId: event.correlationId,
+      deliveredTaskIds
+    });
+    await emitPhase(deps, event, "completed");
+  } catch (err) {
+    console.warn(`[RestartOrchestrator] failed for ${role}@${chatroomId}: ${getErrorMessage2(err)}`);
+    await emitPhase(deps, event, "failed", getErrorMessage2(err));
+  }
+}
+var init_restart_orchestrator = __esm(() => {
+  init_reliability();
+  init_participant();
+  init_esm();
+  init_native_ready_invariant();
+  init_native_task_delivery_coordinator();
+  init_native_task_injector();
+  init_api3();
+  init_convex_error();
+});
+
+// src/events/daemon/agent/on-request-restart-agent.ts
+var onRequestRestartAgentEffect = (event) => exports_Effect.gen(function* () {
+  if (Date.now() > event.deadline) {
+    console.log(`[daemon] ⏰ Skipping expired agent.restart for role=${event.role} (deadline passed)`);
+    return;
+  }
+  console.log(`[daemon] Processing agent.restart (correlationId=${event.correlationId}) for role=${event.role}`);
+  const agentMgr = yield* DaemonAgentProcessManagerService;
+  const session2 = yield* DaemonSessionService;
+  yield* exports_Effect.tryPromise(() => runRestartOrchestrator({
+    session: {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      convexUrl: session2.convexUrl,
+      backend: session2.backend
+    },
+    agentMgr
+  }, {
+    chatroomId: event.chatroomId,
+    role: event.role,
+    agentHarness: event.agentHarness,
+    model: event.model,
+    workingDir: event.workingDir,
+    correlationId: event.correlationId,
+    wantResume: event.wantResume
+  })).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+});
+var init_on_request_restart_agent = __esm(() => {
+  init_esm();
+  init_daemon_services();
+  init_restart_orchestrator();
+});
+
 // src/events/daemon/agent/on-request-start-agent.ts
 function notifyAgentStartFailed(backend2, opts) {
   backend2.mutation(api.machines.emitAgentStartFailed, opts).catch((err) => {
@@ -85758,7 +86581,7 @@ var init_git = __esm(() => {
 });
 
 // src/infrastructure/local-actions/execute-local-action.ts
-import { exec as exec2 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { access as access3 } from "node:fs/promises";
 function escapeShellArg(arg) {
   return `"${arg.replace(/"/g, "\\\"")}"`;
@@ -85768,17 +86591,18 @@ function resolveWhichCommand(name) {
 }
 function isCliAvailable(cliName) {
   return new Promise((resolve4) => {
-    exec2(resolveWhichCommand(cliName), (err) => {
-      resolve4(!err);
-    });
+    const child = spawn5(resolveWhichCommand(cliName), [], DETACHED_SHELL_SPAWN_OPTIONS);
+    child.on("error", () => resolve4(false));
+    child.on("close", (code2) => resolve4(code2 === 0));
+    child.unref();
   });
 }
 function execFireAndForget(command, logTag) {
-  exec2(command, (err) => {
-    if (err) {
-      console.warn(`[${logTag}] exec failed: ${err.message}`);
-    }
+  const child = spawn5(command, [], DETACHED_SHELL_SPAWN_OPTIONS);
+  child.on("error", (err) => {
+    console.warn(`[${logTag}] spawn failed: ${err.message}`);
   });
+  child.unref();
 }
 function resolveOpenCommand(platform) {
   switch (platform) {
@@ -85869,9 +86693,14 @@ async function executeLocalAction(action, workingDir) {
     return handler(workingDir);
   return { success: false, error: `Unknown action: ${action}` };
 }
-var actionHandlers;
+var DETACHED_SHELL_SPAWN_OPTIONS, actionHandlers;
 var init_execute_local_action = __esm(() => {
   init_git();
+  DETACHED_SHELL_SPAWN_OPTIONS = {
+    stdio: "ignore",
+    detached: true,
+    shell: true
+  };
   actionHandlers = {
     "open-vscode": openVscode,
     "open-finder": openFinder,
@@ -86019,7 +86848,7 @@ function logWaitingForShutdown(pid) {
 function logDaemonAlreadyRunning(pid) {
   console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
 }
-async function waitForLockOrTimeout(deadline, intervalMs, sleep5) {
+async function waitForLockOrTimeout(deadline, intervalMs, sleep6) {
   let loggedWait = false;
   while (Date.now() < deadline) {
     if (tryAcquireLock()) {
@@ -86030,16 +86859,16 @@ async function waitForLockOrTimeout(deadline, intervalMs, sleep5) {
       logWaitingForShutdown(pid);
       loggedWait = true;
     }
-    await sleep5(intervalMs);
+    await sleep6(intervalMs);
   }
   return false;
 }
 async function acquireLockWithRetry(options) {
   const intervalMs = options?.intervalMs ?? LOCK_RETRY_INTERVAL_MS;
   const maxWaitMs = options?.maxWaitMs ?? LOCK_RETRY_MAX_WAIT_MS;
-  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+  const sleep6 = options?.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
   const deadline = Date.now() + maxWaitMs;
-  if (await waitForLockOrTimeout(deadline, intervalMs, sleep5)) {
+  if (await waitForLockOrTimeout(deadline, intervalMs, sleep6)) {
     return true;
   }
   const { pid } = isDaemonRunning();
@@ -86890,7 +87719,7 @@ var init_opencode_session = __esm(() => {
 });
 
 // src/infrastructure/harnesses/opencode-sdk/opencode-harness.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 function harnessEventSessionId(event) {
   const p = event.properties;
   if (!p)
@@ -87164,7 +87993,7 @@ class OpencodeSdkHarness {
   }
 }
 var OPENCODE_COMMAND3 = "opencode", SERVE_STARTUP_TIMEOUT_MS2 = 1e4, startOpencodeSdkHarness = async (config3) => {
-  const childProcess = spawn5(OPENCODE_COMMAND3, ["serve", "--print-logs", "--log-level", "WARN"], {
+  const childProcess = spawn6(OPENCODE_COMMAND3, ["serve", "--print-logs", "--log-level", "WARN"], {
     cwd: config3.workingDir,
     stdio: ["pipe", "pipe", "pipe"],
     shell: false,
@@ -88955,9 +89784,9 @@ var init_file_content_fulfillment = __esm(() => {
     for (const request2 of requests) {
       const startTime = Date.now();
       const { workingDir, filePath } = request2;
-      const registered = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => assertRegisteredWorkingDir(session2, workingDir)), () => exports_Effect.succeed({ ok: false, error: "Workspace check failed" }));
-      if (!registered.ok) {
-        console.warn(`[${formatTimestamp()}] ⚠️  Rejected unregistered workspace: ${workingDir} (${registered.error})`);
+      const registered2 = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => assertRegisteredWorkingDir(session2, workingDir)), () => exports_Effect.succeed({ ok: false, error: "Workspace check failed" }));
+      if (!registered2.ok) {
+        console.warn(`[${formatTimestamp()}] ⚠️  Rejected unregistered workspace: ${workingDir} (${registered2.error})`);
         yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Error: workspace not registered]", false);
         continue;
       }
@@ -91795,17 +92624,17 @@ var startFileTreeSubscriptionEffect = (wsClient2) => exports_Effect.gen(function
       });
       coordinators.set(normalized, coordinatorPromise);
     }
-    return coordinatorPromise.then(async (coordinator) => {
+    return coordinatorPromise.then(async (coordinator2) => {
       const checkpoint = await session2.backend.query(api.workspaceFiles.getFileTreeCheckpoint, {
         sessionId: session2.sessionId,
         machineId: session2.machineId,
         workingDir: normalized
       });
       if (checkpoint === null)
-        await coordinator.checkpoint();
+        await coordinator2.checkpoint();
       if (forceReconcile)
-        await coordinator.reconcile();
-      return coordinator;
+        await coordinator2.reconcile();
+      return coordinator2;
     });
   };
   const unsubscribe = wsClient2.onUpdate(api.workspaceFiles.getPendingFileTreeRequests, { sessionId: session2.sessionId, machineId: session2.machineId }, (requests) => {
@@ -91835,7 +92664,7 @@ var startFileTreeSubscriptionEffect = (wsClient2) => exports_Effect.gen(function
   return {
     stop: () => {
       unsubscribe();
-      Promise.all([...coordinators.values()].map((coordinator) => coordinator.then((handle) => handle.stop()).catch(() => {
+      Promise.all([...coordinators.values()].map((coordinator2) => coordinator2.then((handle) => handle.stop()).catch(() => {
         return;
       })));
       coordinators.clear();
@@ -91920,11 +92749,11 @@ async function writePayloadToDisk(absolutePath, operation, content) {
 async function fulfillOneFileWriteRequest(session2, request2) {
   const startTime = Date.now();
   const { workingDir, filePath, operation } = request2;
-  const registered = await assertRegisteredWorkingDir(session2, workingDir);
-  if (!registered.ok) {
+  const registered2 = await assertRegisteredWorkingDir(session2, workingDir);
+  if (!registered2.ok) {
     await completeWriteRequest(session2, request2._id, {
       status: "error",
-      errorMessage: registered.error
+      errorMessage: registered2.error
     });
     return;
   }
@@ -93095,21 +93924,6 @@ var init_crash_loop_tracker = __esm(() => {
   ];
 });
 
-// ../../services/backend/src/domain/entities/participant.ts
-var PARTICIPANT_EXITED_ACTION = "exited", NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", NATIVE_HANDOFF_REMINDER = "Reminder: Use the handoff command to send your response to the team.", ONLINE_OR_STARTING_STATUSES;
-var init_participant = __esm(() => {
-  ONLINE_OR_STARTING_STATUSES = new Set([
-    "agent.waiting",
-    "agent.requestStart",
-    "agent.started",
-    "task.acknowledged",
-    "task.inProgress",
-    "task.completed",
-    "agent.requestStop",
-    "agent.awaitingHandoff"
-  ]);
-});
-
 // src/infrastructure/services/agent-process-manager/turn-completed-backend.ts
 function createTurnCompletedBackend(deps) {
   return {
@@ -93142,386 +93956,6 @@ class TurnEndQueue {
   }
 }
 
-// src/commands/machine/daemon-start/native-delivery-ledger.ts
-class NativeDeliveryLedger {
-  delivered = new Set;
-  inFlight = new Set;
-  deliveryKey(taskId, harnessSessionId) {
-    return `${taskId}\x00${harnessSessionId}`;
-  }
-  isDelivered(taskId, harnessSessionId) {
-    return this.delivered.has(this.deliveryKey(taskId, harnessSessionId));
-  }
-  tryAcquire(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    if (this.delivered.has(key) || this.inFlight.has(key)) {
-      return false;
-    }
-    this.inFlight.add(key);
-    return true;
-  }
-  markDelivered(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    this.inFlight.delete(key);
-    this.delivered.add(key);
-  }
-  clearDelivery(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    this.inFlight.delete(key);
-    this.delivered.delete(key);
-  }
-  clearSession(harnessSessionId) {
-    const suffix = `\x00${harnessSessionId}`;
-    for (const key of [...this.delivered, ...this.inFlight]) {
-      if (key.endsWith(suffix)) {
-        this.delivered.delete(key);
-        this.inFlight.delete(key);
-      }
-    }
-  }
-}
-
-// src/domain/native-integration/predicates.ts
-function isNativeInjectableAliveRunning(task) {
-  const { agentConfig, status: status3 } = task;
-  if (!isNativeHarness(agentConfig.agentHarness))
-    return false;
-  if (agentConfig.spawnedAgentPid == null || agentConfig.desiredState !== "running") {
-    return false;
-  }
-  if (status3 === "pending")
-    return true;
-  if (status3 === "acknowledged") {
-    const assignedTo = task.assignedTo?.toLowerCase();
-    return assignedTo === agentConfig.role.toLowerCase();
-  }
-  return false;
-}
-function isInjectableNativeAction(action) {
-  if (action == null)
-    return true;
-  return action === NATIVE_WAITING_ACTION || action === PARTICIPANT_EXITED_ACTION;
-}
-function isNativePendingRedeliveryAfterRelease(task) {
-  return task.status === "pending" && task.participant?.lastSeenAction === NATIVE_TASK_INJECTED_ACTION;
-}
-function isNativeIdleAfterTaskComplete(participant) {
-  return participant.lastSeenAction === NATIVE_TASK_INJECTED_ACTION && participant.lastStatus === "task.completed";
-}
-function isNativeAcknowledgedInjectionRetry(task) {
-  if (task.status !== "acknowledged")
-    return false;
-  const assignedTo = task.assignedTo?.toLowerCase();
-  if (assignedTo !== task.agentConfig.role.toLowerCase())
-    return false;
-  return task.participant?.lastSeenAction === NATIVE_TASK_INJECTED_ACTION;
-}
-function isStaleCliGetNextTaskWaiting(task) {
-  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
-  return task.participant?.lastSeenAction === "get-next-task:started" && task.createdAt > lastSeenAt;
-}
-function isCliIdleNotListening(task, now, thresholdMs) {
-  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
-  if (lastSeenAt === 0)
-    return now - task.createdAt > thresholdMs;
-  return now - lastSeenAt > thresholdMs;
-}
-var init_predicates = __esm(() => {
-  init_types();
-  init_participant();
-});
-
-// src/infrastructure/services/remote-agents/spawn-prompt.ts
-function createSpawnPrompt(raw, opts) {
-  if (opts?.nativeBootstrap) {
-    return NATIVE_BOOTSTRAP_PROMPT;
-  }
-  const trimmed = raw?.trim();
-  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_TRIGGER_PROMPT;
-}
-var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.", NATIVE_BOOTSTRAP_PROMPT = "Focus on your role responsibilities. Complete each task via handoff.";
-
-// src/domain/native-integration/spawn-policy.ts
-function shouldDeferInitialTurn(harness) {
-  return isNativeHarness(harness);
-}
-function resolveNativeSpawnPolicy(harness, initMessage) {
-  const deferInitialTurn = shouldDeferInitialTurn(harness);
-  return {
-    deferInitialTurn,
-    prompt: createSpawnPrompt(initMessage, { nativeBootstrap: deferInitialTurn })
-  };
-}
-var init_spawn_policy = __esm(() => {
-  init_types();
-});
-
-// src/domain/native-integration/index.ts
-var init_native_integration = __esm(() => {
-  init_types();
-  init_predicates();
-  init_spawn_policy();
-});
-
-// src/commands/machine/daemon-start/native-task-injector-logic.ts
-function shouldDeliverNativeTask(task, opts) {
-  if (!isNativeInjectableAliveRunning(task))
-    return false;
-  if (!opts.harnessSessionId)
-    return false;
-  if (opts.ledger.isDelivered(task.taskId, opts.harnessSessionId) && task.status !== "pending") {
-    return false;
-  }
-  return isInjectableNativeAction(task.participant?.lastSeenAction) || isNativeIdleAfterTaskComplete(task.participant ?? {}) || isNativeAcknowledgedInjectionRetry(task) || isNativePendingRedeliveryAfterRelease(task);
-}
-function buildNativeInjectionPrompt(params) {
-  const { taskDeliveryOutput, augmentationMode } = params;
-  if (augmentationMode === "compact") {
-    return [
-      "⚠️ Context was compacted. Run `chatroom get-system-prompt` only if role instructions are missing.",
-      "",
-      taskDeliveryOutput
-    ].join(`
-`);
-  }
-  if (augmentationMode === "new_session") {
-    return [
-      "⚠️ Starting a new agent session. Run `chatroom get-system-prompt` to reload role instructions if needed.",
-      "",
-      taskDeliveryOutput
-    ].join(`
-`);
-  }
-  return taskDeliveryOutput;
-}
-var init_native_task_injector_logic = __esm(() => {
-  init_predicates();
-  init_native_integration();
-});
-
-// ../../services/backend/src/domain/entities/team-agent-settings.ts
-function roleSupportsSessionAugmentation(role) {
-  const normalized = role.toLowerCase();
-  return SESSION_AUGMENTATION_ROLES.some((r) => r === normalized);
-}
-var SESSION_AUGMENTATION_ROLES;
-var init_team_agent_settings = __esm(() => {
-  SESSION_AUGMENTATION_ROLES = ["builder"];
-});
-
-// ../../services/backend/src/domain/handoff/parse-session-augmentation.ts
-function findSectionIndex(content, headings) {
-  const indices = headings.map((heading) => content.indexOf(heading)).filter((idx) => idx !== -1);
-  return indices.length === 0 ? -1 : Math.min(...indices);
-}
-function normalizeMode(raw) {
-  return MODE_ALIASES[raw.toLowerCase()] ?? DEFAULT_MODE;
-}
-function extractSectionBody(content, sectionIdx) {
-  const matchedHeading = SECTION_HEADINGS.find((h) => content.indexOf(h, sectionIdx) === sectionIdx) ?? SECTION_HEADINGS[0];
-  const afterSection = content.slice(sectionIdx);
-  const nextHeading = afterSection.slice(matchedHeading.length).search(/\n## /);
-  return nextHeading === -1 ? afterSection : afterSection.slice(0, matchedHeading.length + nextHeading);
-}
-function parseSessionAugmentation(handoffContent) {
-  const sectionIdx = findSectionIndex(handoffContent, SECTION_HEADINGS);
-  if (sectionIdx === -1)
-    return DEFAULT_MODE;
-  const match17 = extractSectionBody(handoffContent, sectionIdx).match(DATA_TAG);
-  if (!match17)
-    return DEFAULT_MODE;
-  return normalizeMode(match17[1]);
-}
-function resolveSessionAugmentationForRole(handoffContent, role) {
-  if (!roleSupportsSessionAugmentation(role)) {
-    return "none";
-  }
-  return parseSessionAugmentation(handoffContent);
-}
-function sessionAugmentationToWantResume(mode) {
-  return mode === "none" || mode === "compact";
-}
-function sessionAugmentationNewSessionStarted(mode) {
-  return mode === "new_session";
-}
-var SECTION_HEADINGS, DATA_TAG, DEFAULT_MODE = "new_session", MODE_ALIASES;
-var init_parse_session_augmentation = __esm(() => {
-  init_team_agent_settings();
-  SECTION_HEADINGS = [
-    "## Session Augmentation",
-    "## Session Management",
-    "## Restart new context"
-  ];
-  DATA_TAG = /\/\/\s*data:agent\.(?:session_augmentation|compress_context)=(none|compact|new_session|reset)\b/i;
-  MODE_ALIASES = {
-    reset: "new_session",
-    none: "none",
-    compact: "compact",
-    new_session: "new_session"
-  };
-});
-
-// src/commands/machine/daemon-start/native-task-injector.ts
-function runNativeInjectionEffect(task, harnessSessionId, deps, ledger) {
-  return exports_Effect.gen(function* () {
-    if (!shouldDeliverNativeTask(task, { ledger, harnessSessionId })) {
-      return;
-    }
-    const { chatroomId, taskId, taskContent, agentConfig, status: status3 } = task;
-    const { role } = agentConfig;
-    if (!ledger.tryAcquire(taskId, harnessSessionId)) {
-      return;
-    }
-    if (status3 === "pending") {
-      const claimResult = yield* exports_Effect.tryPromise({
-        try: () => deps.backend.mutation(api.tasks.claimTask, {
-          sessionId: deps.sessionId,
-          chatroomId,
-          role,
-          taskId
-        }),
-        catch: (err) => err
-      }).pipe(exports_Effect.either);
-      if (claimResult._tag === "Left") {
-        ledger.clearDelivery(taskId, harnessSessionId);
-        return yield* exports_Effect.fail(claimResult.left);
-      }
-    }
-    const deliveryResult = yield* exports_Effect.tryPromise({
-      try: () => deps.backend.query(api.messages.getTaskDeliveryPrompt, {
-        sessionId: deps.sessionId,
-        chatroomId,
-        role,
-        taskId,
-        convexUrl: deps.convexUrl
-      }),
-      catch: (err) => err
-    }).pipe(exports_Effect.either);
-    if (deliveryResult._tag === "Left") {
-      ledger.clearDelivery(taskId, harnessSessionId);
-      return yield* exports_Effect.fail(deliveryResult.left);
-    }
-    const delivery = deliveryResult.right;
-    const augmentationMode = resolveSessionAugmentationForRole(taskContent, role);
-    const prompt = buildNativeInjectionPrompt({
-      taskDeliveryOutput: delivery.fullCliOutput,
-      augmentationMode
-    });
-    yield* exports_Effect.tryPromise({
-      try: () => deps.backend.mutation(api.participants.join, {
-        sessionId: deps.sessionId,
-        chatroomId,
-        role,
-        action: NATIVE_TASK_INJECTED_ACTION,
-        taskId
-      }),
-      catch: (err) => err
-    }).pipe(exports_Effect.tapError(() => exports_Effect.sync(() => ledger.clearDelivery(taskId, harnessSessionId))));
-    if (roleSupportsSessionAugmentation(role)) {
-      yield* exports_Effect.tryPromise({
-        try: () => deps.backend.mutation(api.machines.emitSessionAugmented, {
-          sessionId: deps.sessionId,
-          machineId: deps.machineId,
-          chatroomId,
-          role,
-          taskId,
-          mode: augmentationMode,
-          newSessionStarted: sessionAugmentationNewSessionStarted(augmentationMode),
-          harnessSessionId
-        }),
-        catch: (err) => err
-      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    }
-    const resumeResult = yield* exports_Effect.tryPromise({
-      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
-      catch: (err) => err
-    }).pipe(exports_Effect.either);
-    if (resumeResult._tag === "Left") {
-      ledger.clearDelivery(taskId, harnessSessionId);
-      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${getErrorMessage2(resumeResult.left)}`);
-      return;
-    }
-    ledger.markDelivered(taskId, harnessSessionId);
-    deps.onTaskDelivered?.({ chatroomId, role, taskId });
-  });
-}
-var init_native_task_injector = __esm(() => {
-  init_participant();
-  init_team_agent_settings();
-  init_parse_session_augmentation();
-  init_esm();
-  init_native_task_injector_logic();
-  init_api3();
-  init_convex_error();
-});
-
-// src/commands/machine/daemon-start/native-task-delivery-coordinator.ts
-class NativeTaskDeliveryCoordinator {
-  ledger;
-  constructor(ledger = new NativeDeliveryLedger) {
-    this.ledger = ledger;
-  }
-  onSessionLost(params) {
-    if (params.harnessSessionId) {
-      this.ledger.clearSession(params.harnessSessionId);
-    }
-  }
-  reconcileAssignedTasks(params) {
-    const { tasks, runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = params;
-    const ledger = this.ledger;
-    for (const row of tasks) {
-      const slot = agentMgr.getSlot(row.chatroomId, row.agentConfig.role);
-      const harnessSessionId = slot?.harnessSessionId;
-      if (!shouldDeliverNativeTask(row, {
-        ledger,
-        harnessSessionId
-      })) {
-        continue;
-      }
-      if (!harnessSessionId) {
-        continue;
-      }
-      exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
-        const full = yield* exports_Effect.tryPromise(() => sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
-          sessionId: sessionDeps.sessionId,
-          machineId,
-          taskId: row.taskId,
-          role: row.agentConfig.role
-        }));
-        if (!full)
-          return;
-        yield* runNativeInjectionEffect(full, harnessSessionId, {
-          sessionId: sessionDeps.sessionId,
-          machineId: sessionDeps.machineId,
-          backend: sessionDeps.backend,
-          agentMgr: {
-            resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
-          },
-          convexUrl: sessionDeps.convexUrl,
-          onTaskDelivered: ({ chatroomId, role, taskId }) => {
-            exports_Effect.runSync(agentMgr.setLastInFlightTask(chatroomId, role, taskId));
-          }
-        }, ledger);
-      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${row.agentConfig.role}@${row.chatroomId}: ${getErrorMessage2(err)}`)))));
-    }
-  }
-}
-function getNativeTaskDeliveryCoordinator() {
-  coordinator ??= new NativeTaskDeliveryCoordinator;
-  return coordinator;
-}
-function notifyNativeSessionLost(params) {
-  getNativeTaskDeliveryCoordinator().onSessionLost(params);
-}
-var coordinator;
-var init_native_task_delivery_coordinator = __esm(() => {
-  init_esm();
-  init_native_task_injector_logic();
-  init_native_task_injector();
-  init_api3();
-  init_convex_error();
-});
-
 // src/domain/agent-lifecycle/resolve-resumable-harness-session-id.ts
 function resolveResumableHarnessSessionId(snapshot) {
   return snapshot.resumableHarnessSessionId ?? snapshot.harnessSessionId;
@@ -93726,6 +94160,14 @@ var init_native_harness_session_exit = __esm(() => {
   init_agent_lifecycle();
 });
 
+// src/commands/machine/daemon-start/native-turn-phase.ts
+function defaultNativeTurnPhase() {
+  return "idle";
+}
+function setNativeTurnPhase(slot, phase) {
+  slot.nativeTurnPhase = phase;
+}
+
 // src/domain/agent-lifecycle/policies/classify-resume-storm-reason.ts
 function classifyResumeStormReason(logLines) {
   const blob = logLines.join(`
@@ -94284,6 +94726,7 @@ class AgentProcessManager {
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
     slot.stoppingSince = undefined;
+    slot.nativeTurnPhase = undefined;
   }
   bumpStopGeneration(slot) {
     slot.stopGeneration = (slot.stopGeneration ?? 0) + 1;
@@ -94319,7 +94762,14 @@ class AgentProcessManager {
     if (!service3?.resumeTurn) {
       throw new Error(`Harness ${slot.harness} does not support resumeTurn`);
     }
-    await service3.resumeTurn(slot.pid, args2.prompt);
+    setNativeTurnPhase(slot, "injecting");
+    try {
+      await service3.resumeTurn(slot.pid, args2.prompt);
+      setNativeTurnPhase(slot, "turn_in_flight");
+    } catch (err) {
+      setNativeTurnPhase(slot, defaultNativeTurnPhase());
+      throw err;
+    }
   }
   async injectHarnessReminder(chatroomId, role, prompt) {
     const key = agentKey3(chatroomId, role);
@@ -94329,7 +94779,13 @@ class AgentProcessManager {
     const service3 = this.deps.agentServices.get(slot.harness);
     if (!service3?.resumeTurn)
       return;
-    await service3.resumeTurn(slot.pid, prompt);
+    setNativeTurnPhase(slot, "injecting");
+    try {
+      await service3.resumeTurn(slot.pid, prompt);
+      setNativeTurnPhase(slot, "turn_in_flight");
+    } catch {
+      setNativeTurnPhase(slot, defaultNativeTurnPhase());
+    }
   }
   async stop(opts) {
     const key = agentKey3(opts.chatroomId, opts.role);
@@ -94457,6 +94913,10 @@ class AgentProcessManager {
         console.log(`[AgentProcessManager] ⏩ Handoff reminder injected for ${opts.role}`);
         return;
       }
+      if (slot) {
+        setNativeTurnPhase(slot, defaultNativeTurnPhase());
+      }
+      notifyNativeTurnIdle({ chatroomId: opts.chatroomId, role: opts.role });
       console.log(`[AgentProcessManager] ✅ Native agent_end handled for ${opts.role}`);
     } catch (err) {
       console.log(`   ⚠️  Failed native agent_end for ${opts.role}: ${err.message}`);
@@ -94542,6 +95002,7 @@ class AgentProcessManager {
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
+    slot.nativeTurnPhase = undefined;
   }
   async emitExitEvent(slot, opts, ctx) {
     const stopReason = ctx.stopReason;
@@ -95322,6 +95783,9 @@ class AgentProcessManager {
       await this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness);
     } catch {}
     this.registerSpawnCallbacks(slot, opts, spawnResult, pid);
+    if (getHarnessCapabilities(opts.agentHarness).supportsNativeIntegration) {
+      setNativeTurnPhase(slot, defaultNativeTurnPhase());
+    }
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
   }
   async emitNativeWaiting(chatroomId, role, harness) {
@@ -95357,11 +95821,11 @@ class AgentProcessManager {
       const initPrompt = await this.fetchInitPromptResult(opts, slot);
       if (!initPrompt.ok)
         return initPrompt.result;
-      const spawn6 = await this.spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume);
-      if (!spawn6.ok)
-        return spawn6.result;
-      await this.finalizeRunningSlot(key, slot, opts, spawn6.spawnResult, wantResume);
-      return { success: true, pid: spawn6.spawnResult.pid };
+      const spawn7 = await this.spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume);
+      if (!spawn7.ok)
+        return spawn7.result;
+      await this.finalizeRunningSlot(key, slot, opts, spawn7.spawnResult, wantResume);
+      return { success: true, pid: spawn7.spawnResult.pid };
     } catch (e) {
       this.resetSlotIdle(slot);
       return { success: false, error: `Unexpected error: ${e.message}` };
@@ -109109,10 +109573,22 @@ function shouldNudgeCliPendingTask(task, now, pendingIdleThresholdMs) {
 }
 function shouldNudgePendingTask(task, now, pendingIdleThresholdMs = PENDING_IDLE_NUDGE_MS) {
   if (isNativeHarness(task.agentConfig.agentHarness)) {
-    return false;
+    return shouldNudgeNativePendingTask(task, now, pendingIdleThresholdMs);
   }
   return shouldNudgeCliPendingTask(task, now, pendingIdleThresholdMs);
 }
+function shouldNudgeNativePendingTask(task, now, pendingIdleThresholdMs, slot) {
+  if (!isPendingAliveRunningTask(task))
+    return false;
+  if (!isAgentReadyForNativeDelivery(task, slot))
+    return false;
+  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
+  const idleSince = lastSeenAt > 0 ? now - lastSeenAt : now - task.createdAt;
+  return idleSince > pendingIdleThresholdMs;
+}
+function shouldEscalateNativeNudgeToRestart(chatroomId, role, failures3) {
+  return failures3 >= NATIVE_NUDGE_ESCALATION_THRESHOLD;
+}
 
 class NudgeCooldown {
   cooldownMs;
@@ -109129,9 +109605,14 @@ class NudgeCooldown {
     this.lastNudgedAt.set(`${chatroomId}:${role}`, now);
   }
 }
-function isTaskReadyForNudge(task, now, cooldown) {
-  if (!shouldNudgePendingTask(task, now))
+function isTaskReadyForNudge(task, now, cooldown, getSlot) {
+  if (isNativeHarness(task.agentConfig.agentHarness)) {
+    const slot = getSlot?.(task.chatroomId, task.agentConfig.role);
+    if (!shouldNudgeNativePendingTask(task, now, PENDING_IDLE_NUDGE_MS, slot))
+      return false;
+  } else if (!shouldNudgePendingTask(task, now)) {
     return false;
+  }
   const { chatroomId, agentConfig } = task;
   if (!cooldown.canNudge(chatroomId, agentConfig.role, now))
     return false;
@@ -109139,18 +109620,18 @@ function isTaskReadyForNudge(task, now, cooldown) {
     return false;
   return true;
 }
-function listTasksReadyForNudge(tasks, now, cooldown) {
+function listTasksReadyForNudge(tasks, now, cooldown, getSlot) {
   return tasks.filter((task) => {
-    if (!isTaskReadyForNudge(task, now, cooldown))
+    if (!isTaskReadyForNudge(task, now, cooldown, getSlot))
       return false;
     cooldown.recordNudge(task.chatroomId, task.agentConfig.role, now);
     return true;
   });
 }
-var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000;
+var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000, NATIVE_NUDGE_ESCALATION_THRESHOLD = 2;
 var init_task_monitor_logic = __esm(() => {
+  init_native_ready_invariant();
   init_native_task_injector_logic();
-  init_predicates();
   init_agent_process_manager();
 });
 // ../../services/backend/src/domain/usecase/machine/assigned-task-monitor-row.ts
@@ -109220,9 +109701,9 @@ class WorkingSnapshot {
   constructor(opts) {
     this.opts = opts;
   }
-  replaceAll(rows) {
+  replaceAll(rows2) {
     this.rows.clear();
-    for (const row of rows) {
+    for (const row of rows2) {
       this.rows.set(this.opts.rowKey(row), row);
     }
   }
@@ -109566,10 +110047,10 @@ var runIncrementalSubscribeLive = (opts) => exports_Effect.gen(function* () {
 }), runReconcilePollLive = (opts) => runReconcilePoll(opts).pipe(exports_Effect.provide(IntervalClockLive)), runDualChannelFeedLive = (opts) => exports_Effect.gen(function* () {
   const initial = yield* exports_Effect.tryPromise(() => opts.fetchReconcile()).pipe(exports_Effect.orElseSucceed(() => null));
   if (initial !== null) {
-    const rows = opts.extractReconcileRows(initial);
-    opts.snapshot.replaceAll(rows);
-    if (rows.length > 0) {
-      yield* opts.onReconcileRows(rows).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    const rows2 = opts.extractReconcileRows(initial);
+    opts.snapshot.replaceAll(rows2);
+    if (rows2.length > 0) {
+      yield* opts.onReconcileRows(rows2).pipe(exports_Effect.catchAll(() => exports_Effect.void));
     }
   }
   const seedKey = yield* exports_Effect.tryPromise(() => opts.seedCursor()).pipe(exports_Effect.orElseSucceed(() => null));
@@ -109602,9 +110083,9 @@ var runIncrementalSubscribeLive = (opts) => exports_Effect.gen(function* () {
     args: undefined,
     intervalMs: opts.reconcileIntervalMs,
     onResult: (result) => exports_Effect.gen(function* () {
-      const rows = opts.extractReconcileRows(result);
-      opts.snapshot.replaceAll(rows);
-      yield* opts.onReconcileRows(rows).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+      const rows2 = opts.extractReconcileRows(result);
+      opts.snapshot.replaceAll(rows2);
+      yield* opts.onReconcileRows(rows2).pipe(exports_Effect.catchAll(() => exports_Effect.void));
     })
   });
   return {
@@ -109801,8 +110282,42 @@ async function clearStuckStoppingSlotIfNeeded(agentMgr, chatroomId, role) {
   }
 }
 async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
-  for (const row of listTasksReadyForNudge(tasks, now, cooldown)) {
+  const getSlot = (chatroomId, role) => agentMgr.getSlot(chatroomId, role);
+  for (const row of listTasksReadyForNudge(tasks, now, cooldown, getSlot)) {
     await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
+    if (isNativeHarness(row.agentConfig.agentHarness)) {
+      const { chatroomId, agentConfig } = row;
+      const { role } = agentConfig;
+      const deliveryState = getRoleDeliveryState();
+      const failures3 = deliveryState.recordNativeNudgeFailure(chatroomId, role);
+      if (shouldEscalateNativeNudgeToRestart(chatroomId, role, failures3)) {
+        const full2 = await fetchTaskForAction(sessionDeps, machineId, row);
+        if (!full2)
+          continue;
+        console.log(`[TaskMonitor] native nudge escalate restart ${role}@${chatroomId} — pending task ${row.taskId}`);
+        runCliNudgeEffect(full2, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
+        deliveryState.clearNativeNudgeFailures(chatroomId, role);
+        continue;
+      }
+      resetRoleDeliveryState(chatroomId, role);
+      await sessionDeps.backend.mutation(api.participants.join, {
+        sessionId: sessionDeps.sessionId,
+        chatroomId,
+        role,
+        action: NATIVE_WAITING_ACTION
+      });
+      console.log(`[TaskMonitor] native light nudge ${role}@${chatroomId} — redeliver pending task ${row.taskId}`);
+      logNativeDeliveryFallback("native-light-nudge", role, chatroomId, row.taskId);
+      getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
+        tasks: [row],
+        runtime: runtime4,
+        effectContext: effectContext2,
+        agentMgr,
+        sessionDeps,
+        machineId
+      });
+      continue;
+    }
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -109827,6 +110342,10 @@ async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, age
     isPidAlive: (pid) => isProcessAlive((p) => process.kill(p, 0), pid)
   };
   await reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
+  if (tasks.length > 0) {
+    const first2 = tasks[0];
+    logNativeDeliveryFallback("signal-presence", first2.agentConfig.role, first2.chatroomId, first2.taskId);
+  }
   getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
     tasks,
     runtime: runtime4,
@@ -109837,6 +110356,44 @@ async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, age
   });
   await nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
 }
+function listDeliverablePendingFromStore(agentMgr) {
+  if (!hasAssignedTaskSnapshot())
+    return [];
+  return listAssignedTaskSnapshots().filter((row) => {
+    if (row.status !== "pending")
+      return false;
+    const slot = agentMgr.getSlot(row.chatroomId, row.agentConfig.role);
+    return isAgentReadyForNativeDelivery(row, slot);
+  });
+}
+function runLocalStoreReconcilePass(params) {
+  const { stopped, monitorPassInFlight, agentMgr, runtime: runtime4, effectContext: effectContext2, sessionDeps, machineId } = params;
+  if (stopped || monitorPassInFlight)
+    return;
+  const deliverable = listDeliverablePendingFromStore(agentMgr);
+  if (deliverable.length === 0)
+    return;
+  const first2 = deliverable[0];
+  logNativeDeliveryFallback("periodic-reconcile", first2.agentConfig.role, first2.chatroomId, first2.taskId);
+  getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
+    tasks: deliverable,
+    runtime: runtime4,
+    effectContext: effectContext2,
+    agentMgr,
+    sessionDeps,
+    machineId
+  });
+}
+function subscribeAssignedTaskSnapshotStore(wsClient2, args2, isStopped) {
+  return wsClient2.onUpdate(api.machines.listMachineAssignedTaskSnapshots, args2, (result) => {
+    if (isStopped())
+      return;
+    const tasks = parseAssignedTaskMonitorRows(result?.tasks ?? []);
+    replaceAssignedTaskSnapshots(tasks);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️  Assigned-task snapshot subscription error: ${getErrorMessage2(err)}`);
+  });
+}
 var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
@@ -109856,6 +110413,14 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
       query: (fn2, args2) => session2.backend.query(fn2, args2)
     }
   };
+  registerNativeDeliverySession({
+    runtime: runtime4,
+    effectContext: effectContext2,
+    agentMgr,
+    sessionDeps,
+    machineId: session2.machineId
+  });
+  const unsubscribeSnapshotStore = subscribeAssignedTaskSnapshotStore(wsClient2, { sessionId: session2.sessionId, machineId: session2.machineId }, () => stopped);
   const runMonitorPass = (tasks, pass) => {
     if (stopped || monitorPassInFlight || tasks.length === 0)
       return;
@@ -109864,6 +110429,17 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
       monitorPassInFlight = false;
     });
   };
+  const reconcileTimer = setInterval(() => {
+    runLocalStoreReconcilePass({
+      stopped,
+      monitorPassInFlight,
+      agentMgr,
+      runtime: runtime4,
+      effectContext: effectContext2,
+      sessionDeps,
+      machineId: session2.machineId
+    });
+  }, NATIVE_DELIVERY_RECONCILE_MS);
   yield* exports_Effect.tryPromise(() => session2.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
     sessionId: session2.sessionId,
     machineId: session2.machineId
@@ -109918,6 +110494,10 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
   return {
     stop() {
       stopped = true;
+      unsubscribeSnapshotStore();
+      clearAssignedTaskSnapshots();
+      unregisterNativeDeliverySession();
+      clearInterval(reconcileTimer);
       exports_Effect.runPromise(signalHandle.stop());
       exports_Effect.runPromise(presenceHandle.stop());
       console.log(`[${formatTimestamp()}] \uD83D\uDCCB Task-monitor stopped`);
@@ -109925,12 +110505,17 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
   };
 });
 var init_task_monitor = __esm(() => {
+  init_reliability();
+  init_participant();
   init_team_agent_settings();
   init_parse_session_augmentation();
   init_assigned_task_monitor_contract();
   init_esm();
+  init_assigned_task_snapshot_store();
   init_daemon_services();
+  init_native_ready_invariant();
   init_native_task_delivery_coordinator();
+  init_native_task_injector_logic();
   init_task_monitor_logic();
   init_task_monitor_snapshot();
   init_api3();
@@ -110027,6 +110612,15 @@ function handleRequestStartEffect(event, tracker) {
     tracker.commandIds.set(eventId, Date.now());
   });
 }
+function handleRequestRestartEffect(event, tracker) {
+  return exports_Effect.gen(function* () {
+    const eventId = event._id.toString();
+    if (tracker.commandIds.has(eventId))
+      return;
+    yield* onRequestRestartAgentEffect(event);
+    tracker.commandIds.set(eventId, Date.now());
+  });
+}
 function handleRequestStopEffect(event, tracker) {
   return exports_Effect.gen(function* () {
     const eventId = event._id.toString();
@@ -110178,6 +110772,7 @@ var init_command_loop = __esm(() => {
   init_reliability();
   init_esm();
   init_api3();
+  init_on_request_restart_agent();
   init_on_request_start_agent();
   init_on_request_stop_agent();
   init_on_daemon_shutdown();
@@ -110205,6 +110800,7 @@ var init_command_loop = __esm(() => {
   GIT_PUSH_ACTIONS = new Set(["git-pull", "git-push", "git-sync", "git-discard-all"]);
   commandEventHandlers = {
     "agent.requestStart": handleRequestStartEffect,
+    "agent.restart": handleRequestRestartEffect,
     "agent.requestStop": handleRequestStopEffect,
     "daemon.ping": handlePingCommandEffect,
     "daemon.gitRefresh": handleGitRefreshCommandEffect,
@@ -110478,7 +111074,7 @@ async function harnessStatus() {
   };
   const program2 = exports_Effect.forEach(services, detectOne, { concurrency: "unbounded" });
   const results = await exports_Effect.runPromise(program2);
-  const rows = results.map(({ id: id3, displayName, result }) => {
+  const rows2 = results.map(({ id: id3, displayName, result }) => {
     if (isInstalled(result)) {
       return { id: id3, displayName, status: "installed" };
     } else if (isNotInstalled(result)) {
@@ -110488,13 +111084,13 @@ async function harnessStatus() {
     }
     return { id: id3, displayName, status: "not-installed" };
   });
-  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
-  const nameWidth = Math.max(11, ...rows.map((r) => r.displayName.length));
+  const idWidth = Math.max(4, ...rows2.map((r) => r.id.length));
+  const nameWidth = Math.max(11, ...rows2.map((r) => r.displayName.length));
   const header = `${"ID".padEnd(idWidth)}  ${"DISPLAY NAME".padEnd(nameWidth)}  STATUS`;
   const divider = `${"-".repeat(idWidth)}  ${"-".repeat(nameWidth)}  ------`;
   console.log(header);
   console.log(divider);
-  for (const row of rows) {
+  for (const row of rows2) {
     const statusIcon = row.status === "installed" ? "✅ installed" : row.status === "error" ? "⚠️  error" : "❌ not installed";
     const line = `${row.id.padEnd(idWidth)}  ${row.displayName.padEnd(nameWidth)}  ${statusIcon}`;
     console.log(line);
@@ -110503,8 +111099,8 @@ async function harnessStatus() {
     }
   }
   console.log("");
-  const installedCount = rows.filter((r) => r.status === "installed").length;
-  const totalCount = rows.length;
+  const installedCount = rows2.filter((r) => r.status === "installed").length;
+  const totalCount = rows2.length;
   console.log(`${installedCount}/${totalCount} harnesses available on this machine.`);
 }
 var init_harness_status = __esm(() => {
@@ -111471,4 +112067,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=8E7C236B7CEE28C564756E2164756E21
+//# debugId=A68932632BD7E62C64756E2164756E21