chatroom-cli 1.58.0 → 1.58.2

package/dist/index.js

@@ -31677,7 +31677,7 @@ function isClassifiableHarnessLogLine(line) {
     return true;
   if (line.includes(" error]"))
     return true;
-  if (!HARNESS_LOG_PREFIX.test(line))
+  if (line.includes(" run-error]"))
     return true;
   return false;
 }
@@ -31716,7 +31716,7 @@ function formatTerminalProviderFailureMessage(logLines) {
 `).trim();
   return blob ? `Provider rate limit or quota error (non-retryable): ${blob.slice(-500)}` : "Provider rate limit or quota error (non-retryable)";
 }
-var QUOTA_PHRASES, PROVIDER_ERROR_NAMES, HARNESS_LOG_PREFIX;
+var QUOTA_PHRASES, PROVIDER_ERROR_NAMES;
 var init_terminal_provider_error = __esm(() => {
   QUOTA_PHRASES = [
     "usagelimit",
@@ -31730,7 +31730,6 @@ var init_terminal_provider_error = __esm(() => {
     "exceeded your weekly"
   ];
   PROVIDER_ERROR_NAMES = ["ai_apicallerror", "ai_retryerror"];
-  HARNESS_LOG_PREFIX = /^\[[^\]]+\] role:/;
 });
 
 // src/infrastructure/services/remote-agents/opencode-sdk/session-event-forwarder.ts
@@ -75562,6 +75561,12 @@ Put your **complete** deliverable in the handoff message — not in session text
 ---`;
 }
 
+// ../../services/backend/prompts/utils/code-change-verification.ts
+var CODE_CHANGE_VERIFICATION_COMMAND = "pnpm typecheck && pnpm test", CODE_CHANGE_VERIFICATION_CONFIRMATION;
+var init_code_change_verification = __esm(() => {
+  CODE_CHANGE_VERIFICATION_CONFIRMATION = `- [ ] I confirm that I have run \`${CODE_CHANGE_VERIFICATION_COMMAND}\` (only required if code changes were made)`;
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/builder-to-planner.ts
 function getBuilderToPlannerHandoffTemplate() {
   return `${getHandoffRecipientVisibilityCallout("planner")}
@@ -75586,8 +75591,8 @@ function getBuilderToPlannerHandoffTemplate() {
 - \`path/to/file.ts\` — <what changed and why>
 <evidence the goal was met — list every file you modified>
 
-## Verification
-- \`pnpm typecheck && pnpm test\` — <pass/fail + notes>
+## Code Change Verification
+${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 
 ## Blockers / questions
 <anything needing planner decision, or "Not Applicable">
@@ -75596,18 +75601,18 @@ function getBuilderToPlannerHandoffTemplate() {
 <specific areas for planner to check, or "Not Applicable">
 \`\`\``;
 }
-var init_builder_to_planner = () => {};
+var init_builder_to_planner = __esm(() => {
+  init_code_change_verification();
+});
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-builder.ts
 function getPlannerToBuilderHandoffTemplate(nativeIntegration = false) {
-  const sessionManagement = nativeIntegration ? `**Native harnesses** (\`cursor-sdk\`, \`opencode-sdk\`): in-session context compaction is supported by the SDK runtime. \`new_session\` triggers a fresh context within the same process; the session stays active and tasks continue via injection.` : `**Native harnesses** (\`cursor-sdk\`, \`opencode-sdk\`): in-session context compaction is supported by the SDK runtime. \`new_session\` triggers a fresh context within the same process; no get-next-task rejoin needed.
-
-**CLI harnesses** (all others): in-session compaction is NOT supported. \`new_session\` requires a hard restart — the daemon stops the agent, cold-starts it, and the agent must rejoin via \`get-next-task\`. \`none\` resumes the prior session (\`wantResume=true\`).`;
+  const sessionManagement = nativeIntegration ? `\`compact\` runs in-session context compaction via the SDK runtime. \`new_session\` starts a completely new session within the same process (not compaction). \`none\` continues the prior session. Tasks continue via injection.` : `\`compact\` is NOT supported — use \`none\` or \`new_session\`. \`new_session\` requires a hard restart (daemon stops agent, cold-starts, agent rejoins via \`get-next-task\`). \`none\` resumes prior session (\`wantResume=true\`).`;
   return `${getHandoffRecipientVisibilityCallout("builder")}
 
 **Delegation Brief (Planner → Builder)** — paste into the handoff message and fill in EVERY field. No field is optional: if a section does not apply, write \`Not Applicable\` (do not delete the section).
 
-**Division of labor:** You (planner) own architecture and API shape. The builder implements exactly what you specify, runs verification, and does not redesign or invent alternatives unless blocked.
+**Division of labor:** You (planner) own architecture and API shape. The builder implements exactly what you specify and does not redesign or invent alternatives unless blocked.
 
 **Detail bar:** Specify down to **every file** the builder will create or modify (full repo paths). Include code snippets — types, signatures, stubs, or target implementations — until a competent builder **cannot misinterpret** what to write. Vague layers ("update the backend", "fix the component") are not acceptable.
 
@@ -75659,7 +75664,6 @@ Cross-file types, interfaces, or patterns that apply beyond a single file. Write
 
 ## Requirements (acceptance criteria)
 - <verifiable outcome the builder can self-check>
-- Verify: \`pnpm typecheck && pnpm test\`
 
 ## What to avoid
 - <anti-patterns, recurring mistakes, or scope creep for this slice — be explicit>
@@ -75671,11 +75675,12 @@ Cross-file types, interfaces, or patterns that apply beyond a single file. Write
 ## Out of scope
 - <files or areas the builder must NOT touch in this slice, or "Not Applicable">
 
-## Session Management
-Valid values: \`new_session\` | \`none\`
-- \`new_session\` — start a fresh agent session (default)
+## Session Augmentation
+Valid values: \`none\` | \`compact\` | \`new_session\`
 - \`none\` — continue prior session context
-// data:agent.compress_context=new_session
+- \`compact\` — run in-session context compaction (native SDK harnesses only)
+- \`new_session\` — start a completely new session (default)
+// data:agent.session_augmentation=new_session
 
 ${sessionManagement}
 
@@ -75696,6 +75701,12 @@ function getPlannerToUserReportTemplate() {
 ## Template Disclosure Confirmation
 - [ ] I confirm that I have seen this template at the start of any planning, before working on or delegating any task to the team
 
+## Proof of Planning
+<!-- Demonstrate the goal was decomposed into actionable steps with clear outcomes before implementation. -->
+- <step 1: concrete artifact or outcome>
+- <step 2: concrete artifact or outcome>
+<List the planned slices/steps the planner defined (or would have defined) before delegating. Each step should name a verifiable deliverable — not vague layers like "backend work". Write \`Not Applicable\` only for trivial single-step tasks.>
+
 ## Proof of Principle
 <!-- Demonstrate adherence to:
 - Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
@@ -75733,14 +75744,16 @@ flowchart TD
     A[Component] --> B[Component]
 \`\`\`
 
-## Verification
-- \`pnpm typecheck && pnpm test\` — <result>
+## Code Change Verification
+${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 
 ## Notes / Next steps
 <anything the user should know, follow-ups, or open questions, or "Not Applicable">
 \`\`\``;
 }
-var init_planner_to_user = () => {};
+var init_planner_to_user = __esm(() => {
+  init_code_change_verification();
+});
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/index.ts
 function getDuoHandoffTemplate(query) {
@@ -75790,9 +75803,6 @@ flowchart TD
     A[Component] --> B[Component]
 \`\`\`
 
-## Verification
-- \`pnpm typecheck && pnpm test\` — <result>
-
 ## Notes / Next steps
 <anything the user should know, follow-ups, or open questions, or "Not Applicable">
 \`\`\``;
@@ -85789,6 +85799,9 @@ function isInjectableNativeAction(action) {
     return true;
   return action === NATIVE_WAITING_ACTION;
 }
+function shouldEmitNativeWaitingOnTurnEnd(lastStatus) {
+  return lastStatus !== "task.acknowledged" && lastStatus !== "task.inProgress";
+}
 function isNativeIdleAfterTaskComplete(participant) {
   return participant.lastSeenAction === NATIVE_TASK_INJECTED_ACTION && participant.lastStatus === "task.completed";
 }
@@ -85858,13 +85871,21 @@ function shouldDeliverNativeTask(task, opts) {
   return isInjectableNativeAction(task.participant?.lastSeenAction) || isNativeIdleAfterTaskComplete(task.participant ?? {}) || isNativeAcknowledgedInjectionRetry(task);
 }
 function buildNativeInjectionPrompt(params) {
-  const { taskDeliveryOutput, compressMode } = params;
-  if (compressMode === "new_session") {
+  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;
@@ -85874,18 +85895,23 @@ var init_native_task_injector_logic = __esm(() => {
   init_native_integration();
 });
 
-// ../../services/backend/src/domain/handoff/parse-compress-context.ts
+// ../../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) {
-  const value = raw.toLowerCase();
-  if (value === "reset")
-    return "new_session";
-  if (value === "none")
-    return value;
-  return DEFAULT_MODE;
+  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];
@@ -85893,7 +85919,7 @@ function extractSectionBody(content, sectionIdx) {
   const nextHeading = afterSection.slice(matchedHeading.length).search(/\n## /);
   return nextHeading === -1 ? afterSection : afterSection.slice(0, matchedHeading.length + nextHeading);
 }
-function parseCompressContext(handoffContent) {
+function parseSessionAugmentation(handoffContent) {
   const sectionIdx = findSectionIndex(handoffContent, SECTION_HEADINGS);
   if (sectionIdx === -1)
     return DEFAULT_MODE;
@@ -85902,13 +85928,33 @@ function parseCompressContext(handoffContent) {
     return DEFAULT_MODE;
   return normalizeMode(match17[1]);
 }
-function compressContextToWantResume(mode) {
-  return mode === "none";
+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";
-var init_parse_compress_context = __esm(() => {
-  SECTION_HEADINGS = ["## Session Management", "## Restart new context"];
-  DATA_TAG = /\/\/\s*data:agent\.compress_context=(new_session|reset|none)\b/i;
+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
@@ -85952,9 +85998,10 @@ function runNativeInjectionEffect(task, harnessSessionId, deps, ledger) {
       return yield* exports_Effect.fail(deliveryResult.left);
     }
     const delivery = deliveryResult.right;
+    const augmentationMode = resolveSessionAugmentationForRole(taskContent, role);
     const prompt = buildNativeInjectionPrompt({
       taskDeliveryOutput: delivery.fullCliOutput,
-      compressMode: parseCompressContext(taskContent)
+      augmentationMode
     });
     yield* exports_Effect.tryPromise({
       try: () => deps.backend.mutation(api.participants.join, {
@@ -85966,6 +86013,21 @@ function runNativeInjectionEffect(task, harnessSessionId, deps, ledger) {
       }),
       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
@@ -85980,7 +86042,8 @@ function runNativeInjectionEffect(task, harnessSessionId, deps, ledger) {
 }
 var init_native_task_injector = __esm(() => {
   init_participant();
-  init_parse_compress_context();
+  init_team_agent_settings();
+  init_parse_session_augmentation();
   init_esm();
   init_native_task_injector_logic();
   init_api3();
@@ -86024,6 +86087,7 @@ class NativeTaskDeliveryCoordinator {
           return;
         yield* runNativeInjectionEffect(full, harnessSessionId, {
           sessionId: sessionDeps.sessionId,
+          machineId: sessionDeps.machineId,
           backend: sessionDeps.backend,
           agentMgr: {
             resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
@@ -86221,24 +86285,12 @@ var init_agent_lifecycle = __esm(() => {
   init_restart_decision();
 });
 
-// src/domain/agent-lifecycle/policies/cursor-sdk-run-error.ts
-function isCursorSdkRunErrorInLogs(logLines) {
-  return logLines.some((line) => line.includes(" run-error]"));
-}
-function formatCursorSdkRunErrorMessage(logLines) {
-  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
-  return line?.trim() ?? "Cursor SDK run failed";
-}
-
 // src/commands/machine/daemon-start/native-harness-session-exit.ts
 function isNativeHarnessSessionDiscardedOnExit(ctx) {
-  const { harness, harnessSessionId, stopReason, recentLogLines, supportsDaemonMemoryResume } = ctx;
+  const { harness, harnessSessionId, stopReason, supportsDaemonMemoryResume } = ctx;
   if (!harness || !harnessSessionId) {
     return false;
   }
-  if (isCursorSdkRunErrorInLogs(recentLogLines ?? [])) {
-    return true;
-  }
   if (!supportsDaemonMemoryResume) {
     return true;
   }
@@ -86377,8 +86429,17 @@ function appendRecentLogLine(slot, line) {
 }
 var RECENT_LOG_LINE_CAP2 = 100;
 
+// src/domain/agent-lifecycle/policies/cursor-sdk-run-error.ts
+function isCursorSdkRunErrorInLogs(logLines) {
+  return logLines.some((line) => line.includes(" run-error]"));
+}
+function formatCursorSdkRunErrorMessage(logLines) {
+  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
+  return line?.trim() ?? "Cursor SDK run failed";
+}
+
 // src/domain/agent-lifecycle/policies/cursor-sdk-session-reopen-retry.ts
-var CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS = 20, CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS = 5000, CURSOR_SDK_SESSION_REOPEN_REASON = "platform.cursor_sdk_session_reopen";
+var CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS = 20, CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS = 5000, CURSOR_SDK_SESSION_REOPEN_REASON = "platform.cursor_sdk_session_reopen", CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS = 3;
 
 // src/domain/agent-lifecycle/use-cases/handle-turn-completed.ts
 async function handleTurnCompleted(deps, input, slot) {
@@ -86988,8 +87049,10 @@ class AgentProcessManager {
       console.log(`[AgentProcessManager] ⛔ Terminal provider error for ${opts.role} — emitted agent.startFailed`);
       return;
     }
-    await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.harness);
-    console.log(`[AgentProcessManager] ✅ Native harness idle for ${opts.role} (native:waiting)`);
+    const emitted = await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.harness, "turn-end");
+    if (emitted) {
+      console.log(`[AgentProcessManager] ✅ Native harness idle for ${opts.role} (native:waiting)`);
+    }
   }
   async handleExit(opts) {
     const key = agentKey3(opts.chatroomId, opts.role);
@@ -87051,14 +87114,10 @@ class AgentProcessManager {
     });
   }
   async preserveHarnessSessionOnExit(key, slot, ctx) {
-    const { harness, harnessSessionId, stopReason, recentLogLines } = ctx;
+    const { harness, harnessSessionId, stopReason } = ctx;
     if (!harness || !harnessSessionId) {
       return;
     }
-    if (isCursorSdkRunErrorInLogs(recentLogLines ?? [])) {
-      this.clearLastHarnessSession(key);
-      return;
-    }
     const service3 = this.deps.agentServices.get(harness);
     if (!service3?.resumeFromDaemonMemory) {
       return;
@@ -87108,17 +87167,15 @@ class AgentProcessManager {
     }
     this.maybeRestartAgent(opts, ctx);
   }
-  clearHarnessSessionAfterRunError(key, recentLogLines) {
+  hasCursorSdkRunErrorInContext(recentLogLines) {
     if (!isCursorSdkRunErrorInLogs(recentLogLines)) {
       return false;
     }
-    console.log(`[AgentProcessManager] cursor-sdk run-error — cold restarting ${key}: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
-    this.clearLastHarnessSession(key);
+    console.log(`[AgentProcessManager] cursor-sdk run-error detected: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
     return true;
   }
   maybeRestartAgent(opts, ctx) {
     const { harness, model, workingDir, recentLogLines } = ctx;
-    const key = agentKey3(opts.chatroomId, opts.role);
     const logs = recentLogLines ?? [];
     if (!harness || !workingDir) {
       console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
@@ -87128,9 +87185,9 @@ class AgentProcessManager {
       this.handlePermanentFailureForRestart(opts, recentLogLines, ctx.terminalProviderFailureHandled);
       return;
     }
-    const coldRestartAfterRunError = this.clearHarnessSessionAfterRunError(key, logs);
+    const hadRunError = this.hasCursorSdkRunErrorInContext(logs);
     if (harness === "cursor-sdk") {
-      this.retryCursorSdkSessionReopen(opts, ctx, coldRestartAfterRunError);
+      this.retryCursorSdkSessionReopen(opts, ctx, hadRunError);
       return;
     }
     this.ensureRunning({
@@ -87140,7 +87197,7 @@ class AgentProcessManager {
       model,
       workingDir,
       reason: "platform.crash_recovery",
-      wantResume: coldRestartAfterRunError ? false : ctx.wantResume ?? true
+      wantResume: hadRunError ? false : ctx.wantResume ?? true
     }).then((result) => {
       if (!result.success) {
         console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${opts.role}: ${result.error ?? "unknown"}`);
@@ -87150,7 +87207,27 @@ class AgentProcessManager {
       this.emitStartFailedEvent(opts.role, opts.chatroomId, err.message);
     });
   }
-  async retryCursorSdkSessionReopen(opts, ctx, coldRestartAfterRunError) {
+  clearHarnessSessionAfterResumePhaseFailure(key, opts) {
+    const stored = this.lastHarnessSessions.get(key);
+    this.clearLastHarnessSession(key);
+    if (stored?.harnessSessionId) {
+      notifyNativeSessionLost({
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        harnessSessionId: stored.harnessSessionId
+      });
+    }
+  }
+  resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx) {
+    if (hadRunError && attempt <= CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS) {
+      return true;
+    }
+    if (hadRunError) {
+      return false;
+    }
+    return ctx.wantResume ?? true;
+  }
+  async retryCursorSdkSessionReopen(opts, ctx, hadRunError) {
     const key = agentKey3(opts.chatroomId, opts.role);
     if (this.sessionReopenRetryInFlight.has(key)) {
       return;
@@ -87159,11 +87236,14 @@ class AgentProcessManager {
     const harness = ctx.harness;
     const model = ctx.model;
     const workingDir = ctx.workingDir;
-    const wantResume = coldRestartAfterRunError ? false : ctx.wantResume ?? true;
-    const storedSessionId = this.lastHarnessSessions.get(key)?.harnessSessionId;
     let lastError = "unknown";
     try {
       for (let attempt = 1;attempt <= CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS; attempt++) {
+        if (hadRunError && attempt === CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS + 1) {
+          this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
+        }
+        const wantResume = this.resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx);
+        const storedSessionId = this.lastHarnessSessions.get(key)?.harnessSessionId;
         await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, attempt > 1 ? lastError : undefined, storedSessionId);
         const result = await this.ensureRunning({
           chatroomId: opts.chatroomId,
@@ -87345,13 +87425,6 @@ class AgentProcessManager {
     try {
       await this.killExistingBeforeSpawn(opts.chatroomId, opts.role);
       const result = await this.doEnsureRunning(key, slot, opts);
-      if (!result.success && opts.reason === "platform.auto_restart_on_new_context") {
-        console.log(`[AgentProcessManager] Context auto-restart failed (${result.error ?? "unknown"}), ` + `attempting crash recovery (rate-limited)`);
-        return await this.doEnsureRunning(key, slot, {
-          ...opts,
-          reason: "platform.crash_recovery"
-        });
-      }
       return result;
     } finally {
       if (slot.pendingOperation) {
@@ -87744,9 +87817,25 @@ class AgentProcessManager {
     this.registerSpawnCallbacks(slot, opts, spawnResult, pid);
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
   }
-  async emitNativeWaiting(chatroomId, role, harness) {
+  async emitNativeWaiting(chatroomId, role, harness, reason = "spawn") {
     if (!getHarnessCapabilities(harness).supportsNativeIntegration)
-      return;
+      return false;
+    if (reason === "turn-end") {
+      try {
+        const participant = await this.deps.backend.query(api.participants.getByRole, {
+          sessionId: this.deps.sessionId,
+          chatroomId,
+          role
+        });
+        if (!shouldEmitNativeWaitingOnTurnEnd(participant?.lastStatus)) {
+          console.log(`[AgentProcessManager] Skipping native:waiting for ${role} — active work (${participant?.lastStatus})`);
+          return false;
+        }
+      } catch (err) {
+        console.log(`   ⚠️  Failed to check status before native:waiting for ${role}: ${err.message}`);
+        return false;
+      }
+    }
     try {
       await this.deps.backend.mutation(api.participants.join, {
         sessionId: this.deps.sessionId,
@@ -87754,8 +87843,10 @@ class AgentProcessManager {
         role,
         action: NATIVE_WAITING_ACTION
       });
+      return true;
     } catch (err) {
       console.log(`   ⚠️  Failed to emit native:waiting for ${role}: ${err.message}`);
+      return false;
     }
   }
   async doEnsureRunning(key, slot, opts) {
@@ -87909,11 +88000,13 @@ var init_agent_process_manager = __esm(() => {
   init_api3();
   init_orphan_tracker();
   init_native_harness_session_exit();
+  init_native_task_delivery_coordinator();
   init_agent_lifecycle();
   init_abort_resume_storm();
   init_classify_resume_storm_reason();
   init_terminal_provider_error();
   init_handle_turn_completed();
+  init_predicates();
   init_spawn_policy();
   init_agent_lifecycle_runtime();
   init_agent_lifecycle_types();
@@ -87927,7 +88020,7 @@ class SpawnRateLimiter {
     this.config = { ...DEFAULT_CONFIG2, ...config3 };
   }
   tryConsume(chatroomId, reason) {
-    if (reason.startsWith("user.") || reason === "platform.auto_restart_on_new_context" || reason === "platform.cursor_sdk_session_reopen") {
+    if (reason.startsWith("user.") || reason === "platform.cursor_sdk_session_reopen") {
       return { allowed: true };
     }
     const bucket = this._getOrCreateBucket(chatroomId);
@@ -88866,6 +88959,9 @@ class WorkingSnapshot {
   getByKey(key) {
     return this.rows.get(key);
   }
+  upsertRow(row) {
+    this.rows.set(this.opts.rowKey(row), row);
+  }
   getBySignal(signal) {
     return this.rows.get(this.opts.signalKey(signal));
   }
@@ -88903,8 +88999,32 @@ function mergeSignalIntoTaskSnapshot(existing, signal) {
     }
   };
 }
+function mergePresenceIntoTaskSnapshot(existing, presence) {
+  if (!existing) {
+    return;
+  }
+  return {
+    ...existing,
+    participant: {
+      lastSeenAction: presence.lastSeenAction ?? existing.participant?.lastSeenAction ?? null,
+      lastSeenAt: presence.lastSeenAt,
+      lastStatus: existing.participant?.lastStatus ?? null
+    }
+  };
+}
 function createTaskMonitorSnapshot() {
-  return new WorkingSnapshot(taskMonitorSnapshotOptions);
+  const base = new WorkingSnapshot(taskMonitorSnapshotOptions);
+  return Object.assign(base, {
+    mergePresence(presence) {
+      const key = taskSnapshotKey(presence.taskId, presence.role);
+      const existing = base.getByKey(key);
+      const merged = mergePresenceIntoTaskSnapshot(existing, presence);
+      if (merged) {
+        base.upsertRow(merged);
+      }
+      return merged;
+    }
+  });
 }
 var taskMonitorSnapshotOptions;
 var init_task_monitor_snapshot = __esm(() => {
@@ -89154,106 +89274,46 @@ var runIncrementalSubscribeLive = (opts) => exports_Effect.gen(function* () {
       yield* exports_Fiber.interrupt(workerFiber);
     })
   };
-}), runReconcilePoll = (opts) => exports_Effect.gen(function* () {
-  const clock4 = yield* IntervalClock;
-  const backoffCfg = opts.backoff ?? { initialMs: 1000, maxMs: 30000 };
-  let backoffMs = opts.intervalMs;
-  let stopped = false;
-  const loopFiber = yield* exports_Effect.forkDaemon(exports_Effect.gen(function* () {
-    while (!stopped) {
-      const pollOutcome = yield* exports_Effect.either(exports_Effect.tryPromise(() => opts.poll(opts.args)));
-      if (pollOutcome._tag === "Left") {
-        backoffMs = Math.min(backoffMs === opts.intervalMs ? backoffCfg.initialMs : backoffMs * 2, backoffCfg.maxMs);
-        yield* clock4.sleep(backoffMs);
-        continue;
-      }
-      yield* opts.onResult(pollOutcome.right);
-      backoffMs = opts.intervalMs;
-      yield* clock4.sleep(opts.intervalMs);
-    }
-  }));
-  return {
-    stop: () => exports_Effect.gen(function* () {
-      stopped = true;
-      yield* exports_Fiber.interrupt(loopFiber);
-    })
-  };
-}), runReconcilePollLive = (opts) => runReconcilePoll(opts).pipe(exports_Effect.provide(IntervalClockLive));
+});
 var init_feed_runtime = __esm(() => {
   init_esm();
   init_layers();
   init_subscribe_loop();
 });
 
-// src/infrastructure/incremental-sync/dual-channel-feed.ts
-var 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 seedKey = yield* exports_Effect.tryPromise(() => opts.seedCursor()).pipe(exports_Effect.orElseSucceed(() => null));
-  const hydrateFromReconcile = async () => {
-    const result = await opts.fetchReconcile();
-    opts.snapshot.replaceAll(opts.extractReconcileRows(result));
+// src/infrastructure/incremental-sync/feeds/assigned-task-presence.ts
+var assignedTaskPresenceFeedDef, assignedTaskPresenceSubscribeTarget, ASSIGNED_TASK_PRESENCE_FEED_LIMIT = 50, ASSIGNED_TASK_PRESENCE_FEED_BUFFER;
+var init_assigned_task_presence = __esm(() => {
+  init_api3();
+  assignedTaskPresenceFeedDef = {
+    name: "assigned-task-presence",
+    itemKey: (item) => `${item.presenceUpdatedAt}:${item.taskId}:${item.role}`
   };
-  const resolveRowForSignal = async (signal) => {
-    const merged = opts.snapshot.mergeSignal(signal);
-    if (merged) {
-      return merged;
+  assignedTaskPresenceSubscribeTarget = {
+    query: api.machines.subscribeAssignedTaskPresenceSince,
+    buildArgs: (args2, afterKey, limit) => ({
+      sessionId: args2.sessionId,
+      machineId: args2.machineId,
+      afterPresenceKey: afterKey ?? undefined,
+      limit
+    }),
+    parsePage: (result) => {
+      const page = result;
+      return {
+        items: page.items,
+        highKey: page.highPresenceKey,
+        hasMore: page.hasMore
+      };
     }
-    await hydrateFromReconcile();
-    return opts.snapshot.mergeSignal(signal) ?? opts.snapshot.getBySignal(signal);
   };
-  const signalHandle = yield* runIncrementalSubscribeLive({
-    wsClient: opts.wsClient,
-    def: opts.def,
-    target: opts.target,
-    args: opts.args,
-    buffer: opts.buffer,
-    subscribe: opts.subscribe,
-    initialAfterKey: seedKey,
-    onError: opts.onSubscribeError,
-    onItem: ({ item: signal, ack }) => exports_Effect.gen(function* () {
-      ack();
-      if (opts.isStopped()) {
-        return;
-      }
-      const row = yield* exports_Effect.tryPromise(() => resolveRowForSignal(signal));
-      if (!row) {
-        return;
-      }
-      yield* opts.onSignalRow(row).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    })
-  });
-  const reconcileHandle = yield* runReconcilePollLive({
-    name: `${opts.name}-reconcile`,
-    poll: () => opts.fetchReconcile(),
-    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));
-    })
-  });
-  return {
-    stop: () => exports_Effect.gen(function* () {
-      yield* signalHandle.stop();
-      yield* reconcileHandle.stop();
-    })
+  ASSIGNED_TASK_PRESENCE_FEED_BUFFER = {
+    maxSize: 200,
+    dedupe: true
   };
 });
-var init_dual_channel_feed = __esm(() => {
-  init_esm();
-  init_feed_runtime();
-});
 
 // src/infrastructure/incremental-sync/feeds/assigned-task-signals.ts
-var assignedTaskSignalsFeedDef, assignedTaskSignalsSubscribeTarget, ASSIGNED_TASK_SIGNAL_FEED_LIMIT = 50, ASSIGNED_TASK_SIGNAL_FEED_BUFFER, ASSIGNED_TASK_RECONCILE_INTERVAL_MS = 15000;
+var assignedTaskSignalsFeedDef, assignedTaskSignalsSubscribeTarget, ASSIGNED_TASK_SIGNAL_FEED_LIMIT = 50, ASSIGNED_TASK_SIGNAL_FEED_BUFFER;
 var init_assigned_task_signals = __esm(() => {
   init_api3();
   assignedTaskSignalsFeedDef = {
@@ -89277,16 +89337,32 @@ var init_assigned_task_signals = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/task-monitor.ts
+async function seedSignalCursor(session2) {
+  const seedPage = await session2.backend.query(api.machines.subscribeAssignedTaskSignalsSince, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    limit: ASSIGNED_TASK_SIGNAL_FEED_LIMIT
+  });
+  return seedPage?.highKey ?? null;
+}
+async function seedPresenceCursor(session2) {
+  const seedPage = await session2.backend.query(api.machines.subscribeAssignedTaskPresenceSince, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    limit: ASSIGNED_TASK_PRESENCE_FEED_LIMIT
+  });
+  return seedPage?.highPresenceKey ?? null;
+}
 function resolveTaskWantResume(task) {
-  return compressContextToWantResume(parseCompressContext(task.taskContent ?? ""));
+  return sessionAugmentationToWantResume(resolveSessionAugmentationForRole(task.taskContent ?? "", task.agentConfig.role));
 }
 function buildCliNudgeLogLine(task) {
   const { chatroomId, agentConfig } = task;
   const { role } = agentConfig;
   const lastSeenAction = task.participant?.lastSeenAction ?? "unknown";
-  const compressMode = parseCompressContext(task.taskContent ?? "");
+  const augmentationMode = resolveSessionAugmentationForRole(task.taskContent ?? "", role);
   const wantResume = resolveTaskWantResume(task);
-  return `[TaskMonitor] nudging ${role}@${chatroomId} — pending task ${task.taskId}, lastSeenAction=${lastSeenAction}, compress_context=${compressMode}, wantResume=${wantResume}`;
+  return `[TaskMonitor] nudging ${role}@${chatroomId} — pending task ${task.taskId}, lastSeenAction=${lastSeenAction}, session_augmentation=${augmentationMode}, wantResume=${wantResume}`;
 }
 function resolveTaskRunnerContextFromFull(task) {
   const { chatroomId, agentConfig } = task;
@@ -89302,11 +89378,12 @@ function resolveTaskRunnerContextFromFull(task) {
     wantResume: resolveTaskWantResume(task)
   };
 }
-function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
+function executeCliNudge(task, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   const ctx = resolveTaskRunnerContextFromFull(task);
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
+  const augmentationMode = resolveSessionAugmentationForRole(task.taskContent ?? "", role);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.stop({ chatroomId, role, reason: "platform.task_monitor_nudge" });
     yield* agentMgr.ensureRunning({
@@ -89318,6 +89395,20 @@ function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
       reason: "platform.task_monitor_nudge",
       wantResume
     });
+    if (roleSupportsSessionAugmentation(role)) {
+      yield* exports_Effect.tryPromise({
+        try: () => sessionDeps.backend.mutation(api.machines.emitSessionAugmented, {
+          sessionId: sessionDeps.sessionId,
+          machineId,
+          chatroomId,
+          role,
+          taskId: task.taskId,
+          mode: augmentationMode,
+          newSessionStarted: sessionAugmentationNewSessionStarted(augmentationMode)
+        }),
+        catch: (err) => err
+      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    }
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] nudge failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
 function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
@@ -89347,16 +89438,16 @@ async function fetchTaskForAction(sessionDeps, machineId, snapshotRow) {
   });
   return result;
 }
-function runCliNudgeEffect(task, runtime4, effectContext2, agentMgr) {
+function runCliNudgeEffect(task, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   console.log(buildCliNudgeLogLine(task));
-  executeCliNudge(task, runtime4, effectContext2, agentMgr);
+  executeCliNudge(task, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
 }
 async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   for (const row of listTasksReadyForNudge(tasks, now, cooldown)) {
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
-    runCliNudgeEffect(full, runtime4, effectContext2, agentMgr);
+    runCliNudgeEffect(full, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   }
 }
 async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
@@ -89384,7 +89475,7 @@ async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, age
     sessionDeps,
     machineId
   });
-  if (pass === "reconcile") {
+  if (pass === "presence") {
     await nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   }
 }
@@ -89415,12 +89506,22 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
       monitorPassInFlight = false;
     });
   };
-  const queryReconcileSnapshots = () => session2.backend.query(api.machines.listAssignedTasksForReconcile, {
+  yield* exports_Effect.tryPromise(() => session2.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
     sessionId: session2.sessionId,
     machineId: session2.machineId
-  });
-  const feedHandle = yield* runDualChannelFeedLive({
-    name: "assigned-tasks",
+  })).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+  const hydrate = yield* exports_Effect.tryPromise(() => session2.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId
+  })).pipe(exports_Effect.orElseSucceed(() => ({ tasks: [] })));
+  const hydrateTasks = hydrate.tasks ?? [];
+  snapshot.replaceAll(hydrateTasks);
+  if (hydrateTasks.length > 0) {
+    yield* exports_Effect.tryPromise(() => processTasksUpdate(hydrateTasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "presence")).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+  }
+  const signalSeedKey = yield* exports_Effect.tryPromise(() => seedSignalCursor(session2)).pipe(exports_Effect.orElseSucceed(() => null));
+  const presenceSeedKey = yield* exports_Effect.tryPromise(() => seedPresenceCursor(session2)).pipe(exports_Effect.orElseSucceed(() => null));
+  const signalHandle = yield* runIncrementalSubscribeLive({
     wsClient: wsClient2,
     def: assignedTaskSignalsFeedDef,
     target: assignedTaskSignalsSubscribeTarget,
@@ -89430,44 +89531,64 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
     },
     buffer: ASSIGNED_TASK_SIGNAL_FEED_BUFFER,
     subscribe: { limit: ASSIGNED_TASK_SIGNAL_FEED_LIMIT },
-    snapshot,
-    seedCursor: async () => {
-      const seedPage = await session2.backend.query(api.machines.subscribeAssignedTaskSignalsSince, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        limit: ASSIGNED_TASK_SIGNAL_FEED_LIMIT
+    initialAfterKey: signalSeedKey,
+    onError: (err) => console.warn(`[${formatTimestamp()}] ⚠️  Task signal subscription error: ${getErrorMessage(err)}`),
+    onItem: ({ item: signal, ack }) => exports_Effect.gen(function* () {
+      ack();
+      if (stopped)
+        return;
+      const row = snapshot.mergeSignal(signal);
+      if (!row)
+        return;
+      yield* exports_Effect.sync(() => {
+        runMonitorPass([row], "signal");
+      });
+    })
+  });
+  const presenceHandle = yield* runIncrementalSubscribeLive({
+    wsClient: wsClient2,
+    def: assignedTaskPresenceFeedDef,
+    target: assignedTaskPresenceSubscribeTarget,
+    args: {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId
+    },
+    buffer: ASSIGNED_TASK_PRESENCE_FEED_BUFFER,
+    subscribe: { limit: ASSIGNED_TASK_PRESENCE_FEED_LIMIT },
+    initialAfterKey: presenceSeedKey,
+    onError: (err) => console.warn(`[${formatTimestamp()}] ⚠️  Task presence subscription error: ${getErrorMessage(err)}`),
+    onItem: ({ item: presence, ack }) => exports_Effect.gen(function* () {
+      ack();
+      if (stopped)
+        return;
+      const row = snapshot.mergePresence(presence);
+      if (!row)
+        return;
+      yield* exports_Effect.sync(() => {
+        runMonitorPass([row], "presence");
       });
-      return seedPage?.highKey ?? null;
-    },
-    fetchReconcile: () => queryReconcileSnapshots(),
-    extractReconcileRows: (result) => result?.tasks ?? [],
-    reconcileIntervalMs: ASSIGNED_TASK_RECONCILE_INTERVAL_MS,
-    isStopped: () => stopped,
-    onSubscribeError: (err) => console.warn(`[${formatTimestamp()}] ⚠️  Task signal subscription error: ${getErrorMessage(err)}`),
-    onSignalRow: (row) => exports_Effect.sync(() => {
-      runMonitorPass([row], "signal");
-    }),
-    onReconcileRows: (tasks) => exports_Effect.sync(() => {
-      runMonitorPass([...tasks], "reconcile");
     })
   });
   return {
     stop() {
       stopped = true;
-      exports_Effect.runPromise(feedHandle.stop());
+      exports_Effect.runPromise(signalHandle.stop());
+      exports_Effect.runPromise(presenceHandle.stop());
       console.log(`[${formatTimestamp()}] \uD83D\uDCCB Task-monitor stopped`);
     }
   };
 });
 var init_task_monitor = __esm(() => {
-  init_parse_compress_context();
+  init_team_agent_settings();
+  init_parse_session_augmentation();
   init_esm();
   init_daemon_services();
   init_native_task_delivery_coordinator();
   init_task_monitor_logic();
   init_task_monitor_snapshot();
   init_api3();
-  init_dual_channel_feed();
+  init_feed_runtime();
+  init_assigned_task_presence();
   init_assigned_task_signals();
   init_convex_error();
 });
@@ -90975,4 +91096,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=00A3989CD8BAD93D64756E2164756E21
+//# debugId=9DA8A47CE355B57D64756E2164756E21