chatroom-cli 1.57.3 → 1.58.0

package/dist/index.js

@@ -28903,6 +28903,12 @@ function normalizeCursorSdkListedModels(listedModelIds) {
 var CURSOR_PROVIDER2 = "cursor", DEFAULT_AUTO_MODEL_ID = "default", UI_AUTO_MODEL_ID = "auto";
 
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-package.ts
+var exports_cursor_sdk_package = {};
+__export(exports_cursor_sdk_package, {
+  importBundledCursorSdk: () => importBundledCursorSdk,
+  getBundledCursorSdkVersion: () => getBundledCursorSdkVersion,
+  formatCursorSdkLoadError: () => formatCursorSdkLoadError
+});
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname2, join as join7 } from "node:path";
@@ -32520,6 +32526,12 @@ var init_opencode_sdk = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/pi-sdk/pi-sdk-package.ts
+var exports_pi_sdk_package = {};
+__export(exports_pi_sdk_package, {
+  importBundledPiSdk: () => importBundledPiSdk,
+  getBundledPiSdkVersion: () => getBundledPiSdkVersion,
+  formatPiSdkLoadError: () => formatPiSdkLoadError
+});
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
@@ -75554,14 +75566,25 @@ Put your **complete** deliverable in the handoff message — not in session text
 function getBuilderToPlannerHandoffTemplate() {
   return `${getHandoffRecipientVisibilityCallout("planner")}
 
-**Handoff Template (Builder → Planner)** — paste into the handoff message. Fill in EVERY section; use \`Not Applicable\` when a section does not apply.
+**Handoff Template (Builder → Planner)** — paste into the handoff message. Fill in EVERY section below. If a section does not apply, write \`Not Applicable\` (do not delete the section):
 
 \`\`\`markdown
 ## Summary
 <what was implemented or attempted, in plain terms>
 
-## Proof — files changed
+## Template Disclosure Confirmation
+- [ ] I confirm that I have seen this template at the start of this task, before implementing or modifying any code
+
+## 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.
+- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
+-->
+<how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
+
+## Proof of Completion
 - \`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>
@@ -75643,7 +75666,7 @@ Cross-file types, interfaces, or patterns that apply beyond a single file. Write
 - <e.g. "Do not add new abstractions", "Do not refactor unrelated files", "Do not change existing public APIs", or "Not Applicable">
 
 ## Skills to activate
-- <e.g. chatroom skill activate software-engineering --chatroom-id=<id> --role=builder, or "Not Applicable">
+- <e.g. chatroom skill activate code-review --chatroom-id=<id> --role=builder, or "Not Applicable">
 
 ## Out of scope
 - <files or areas the builder must NOT touch in this slice, or "Not Applicable">
@@ -75684,6 +75707,15 @@ function getPlannerToUserReportTemplate() {
 - \`path/to/file.ts\` — <what changed and why>
 <evidence the goal was met — list every file you (or the builder) modified>
 
+## Backlog Tasks Implemented
+- \`backlog-item-id\` — <backlog item title/summary and how this work addresses it>
+<List every backlog item this work implemented. Write \`Not Applicable\` if no backlog items were in scope.>
+
+## Backlog Pending User Review Confirmation
+- [ ] I confirm that every backlog item implemented in this work has been moved to \`pending_user_review\` via \`chatroom backlog mark-for-review\` because a PR has been raised for user review
+- PR URL(s): <link to PR(s), or \`Not Applicable\` if no PR was raised>
+- If no backlog items apply, write \`Not Applicable\` for the checkbox and explain in one line
+
 ## Key Technical Decisions
 - <schema design, modules, interfaces, domain entities — what you chose and why, or "Not Applicable">
 
@@ -76013,16 +76045,11 @@ var init_fromContext = __esm(() => {
   init_planner();
   init_solo();
 });
-// ../../services/backend/prompts/cli/sections/handoff-templates-preview.ts
-var init_handoff_templates_preview = __esm(() => {
-  init_handoff_templates3();
-});
 
 // ../../services/backend/prompts/native/task-started-content.ts
 var init_task_started_content = __esm(() => {
   init_new();
 });
-
 // ../../services/backend/prompts/sections/classification-guide.ts
 var init_classification_guide = __esm(() => {
   init_cli();
@@ -76050,6 +76077,8 @@ var init_current_classification = () => {};
 var init_getting_started = __esm(() => {
   init_getting_started_content();
 });
+// ../../services/backend/src/domain/usecase/skills/modules/attachments/index.ts
+var init_attachments = () => {};
 
 // ../../services/backend/prompts/cli/backlog/command.ts
 var init_command3 = __esm(() => {
@@ -76064,18 +76093,11 @@ var init_backlog = __esm(() => {
 // ../../services/backend/src/domain/usecase/skills/modules/code-review/index.ts
 var init_code_review = () => {};
 
-// ../../services/backend/src/domain/usecase/skills/modules/development-workflow/index.ts
-var init_development_workflow = () => {};
-
-// ../../services/backend/src/domain/usecase/skills/modules/software-engineering/index.ts
-var init_software_engineering = () => {};
-
 // ../../services/backend/src/domain/usecase/skills/registry.ts
 var init_registry3 = __esm(() => {
+  init_attachments();
   init_backlog();
   init_code_review();
-  init_development_workflow();
-  init_software_engineering();
 });
 
 // ../../services/backend/prompts/sections/glossary.ts
@@ -76102,20 +76124,15 @@ var init_glossary = __esm(() => {
       linkedSkillId: "backlog"
     },
     {
-      term: "software-engineering",
-      definition: "Universal software engineering standards: build from the application core outward, SOLID principles, and naming conventions.",
-      linkedSkillId: "software-engineering"
+      term: "attachments",
+      definition: "Message attachment types (task, backlog, message, snippet) and their compose, delivery, and task-read paths. " + "Use when adding or changing attachment UI, delivery XML, or agent-facing attachment formats.",
+      linkedSkillId: "attachments"
     },
     {
       term: "code-review",
       definition: "Eight-pillar code review framework: simplification, type drift, duplication, design patterns, security, test quality, ownership/observability, and dead code elimination. " + "Covers AI-generated code review with focus on maintainability and tech debt prevention.",
       linkedSkillId: "code-review"
     },
-    {
-      term: "development-workflow",
-      definition: "Manages the development and release flow: creating release branches, updating versions, raising PRs, and managing feature branches. " + "Use this skill for coordinating complex release and development processes.",
-      linkedSkillId: "development-workflow"
-    },
     {
       term: "structural-decisions",
       definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers)."
@@ -76394,7 +76411,6 @@ var init_generator = __esm(() => {
   init_command();
   init_reminder();
   init_fromContext();
-  init_handoff_templates_preview();
   init_classification_guide();
   init_commands_reference();
   init_current_classification();
@@ -77401,6 +77417,52 @@ function readFileContent(filePath, optionName) {
 }
 var init_file_content = () => {};
 
+// ../../services/backend/prompts/attachments/render-delivery-attachments.ts
+function renderSnippetAttachment(snippet) {
+  return [
+    `  <attachment reference="${snippet.reference}">`,
+    `  <snippet file-source="${snippet.fileSource}">`,
+    `    <user-selected-content>`,
+    snippet.selectedContent,
+    `    </user-selected-content>`,
+    `  </snippet>`,
+    `  </attachment>`
+  ];
+}
+function renderBacklogAttachments(items, ctx) {
+  const lines = [];
+  for (const item of items) {
+    lines.push(`  <attachment type="backlog-item">`);
+    lines.push(`    - [${item.status.toUpperCase()}] ${item.content}`);
+    lines.push(`      ID: ${item._id}`);
+    lines.push(`    <hint>Work on this item. When done: chatroom backlog mark-for-review --chatroom-id="${ctx.chatroomId}" --role="${ctx.role}" --backlog-item-id=${item._id}</hint>`);
+    lines.push(`  </attachment>`);
+  }
+  return lines;
+}
+function renderSnippetAttachments(snippets) {
+  const lines = [];
+  for (const snippet of snippets) {
+    lines.push(...renderSnippetAttachment(snippet));
+  }
+  return lines;
+}
+function renderDeliveryAttachmentsBlock(input, ctx) {
+  const backlogLines = input.attachedBacklogItems?.length ? DELIVERY_ATTACHMENT_RENDERERS.backlog(input.attachedBacklogItems, ctx) : [];
+  const snippetLines = input.attachedSnippets?.length ? DELIVERY_ATTACHMENT_RENDERERS.snippet(input.attachedSnippets, ctx) : [];
+  if (backlogLines.length === 0 && snippetLines.length === 0)
+    return [];
+  return ["", "<attachments>", ...backlogLines, ...snippetLines, "</attachments>"];
+}
+var DELIVERY_ATTACHMENT_RENDERERS;
+var init_render_delivery_attachments = __esm(() => {
+  DELIVERY_ATTACHMENT_RENDERERS = {
+    backlog: renderBacklogAttachments,
+    snippet: renderSnippetAttachments,
+    message: () => []
+  };
+});
+
 // src/commands/task/read/render.ts
 function detectBacklogDivergence(contextContent, attachedIds) {
   if (!contextContent || attachedIds.length === 0) {
@@ -77409,19 +77471,10 @@ function detectBacklogDivergence(contextContent, attachedIds) {
   return attachedIds.filter((id3) => !contextContent.includes(id3));
 }
 function renderAttachments(input, chatroomId, role) {
-  if (!input.attachedBacklogItems || input.attachedBacklogItems.length === 0)
-    return [];
-  const lines = [""];
-  lines.push("<attachments>");
-  for (const item of input.attachedBacklogItems) {
-    lines.push(`  <attachment type="backlog-item">`);
-    lines.push(`    - [${item.status.toUpperCase()}] ${item.content}`);
-    lines.push(`      ID: ${item._id}`);
-    lines.push(`    <hint>Work on this item. When done: chatroom backlog mark-for-review --chatroom-id="${chatroomId}" --role="${role}" --backlog-item-id=${item._id}</hint>`);
-    lines.push(`  </attachment>`);
-  }
-  lines.push("</attachments>");
-  return lines;
+  return renderDeliveryAttachmentsBlock({
+    attachedBacklogItems: input.attachedBacklogItems,
+    attachedSnippets: input.attachedSnippets
+  }, { chatroomId, role, mode: "task-read" });
 }
 function renderDivergenceWarnings(input) {
   const ctx = input.context;
@@ -77476,6 +77529,9 @@ ${content}`);
   return lines.join(`
 `);
 }
+var init_render = __esm(() => {
+  init_render_delivery_attachments();
+});
 
 // src/commands/task/read/index.ts
 var exports_read = {};
@@ -77503,6 +77559,18 @@ function validateTaskId(taskId) {
   }
   return exports_Effect.void;
 }
+function buildTaskPromptFromReadResult(result, chatroomId, role) {
+  return renderTaskPrompt({
+    taskId: result.taskId,
+    status: result.status,
+    content: result.content,
+    chatroomId,
+    role,
+    context: result.context && typeof result.context === "object" ? result.context : undefined,
+    attachedBacklogItems: Array.isArray(result.attachedBacklogItems) ? result.attachedBacklogItems : undefined,
+    attachedSnippets: Array.isArray(result.attachedSnippets) ? result.attachedSnippets : undefined
+  });
+}
 function handleTaskReadError(err) {
   return exports_Effect.sync(() => {
     const handler = taskReadErrorHandlers[err._tag];
@@ -77535,19 +77603,12 @@ var taskReadEffect = (chatroomId, options) => exports_Effect.gen(function* () {
     taskId
   }).pipe(exports_Effect.mapError((cause3) => ({ _tag: "MutationFailed", cause: cause3 })));
   yield* exports_Effect.sync(() => {
-    console.log(renderTaskPrompt({
-      taskId: result.taskId,
-      status: result.status,
-      content: result.content,
-      chatroomId,
-      role,
-      context: result.context && typeof result.context === "object" ? result.context : undefined,
-      attachedBacklogItems: Array.isArray(result.attachedBacklogItems) ? result.attachedBacklogItems : undefined
-    }));
+    console.log(buildTaskPromptFromReadResult(result, chatroomId, role));
   });
 }), taskReadErrorHandlers;
 var init_read = __esm(() => {
   init_esm();
+  init_render();
   init_api3();
   init_storage();
   init_client2();
@@ -82679,161 +82740,311 @@ var init_commit_detail_sync = __esm(() => {
   seenShas = new Map;
 });
 
-// src/domain/direct-harness/usecases/update-capabilities.ts
-async function updateCapabilities(deps, input) {
-  const { publisher, machineId } = deps;
-  const { harness, workspace } = input;
-  const [agents, providers] = await Promise.all([
-    harness.listAgents(),
-    harness.listProviders()
-  ]);
-  await publisher.publish({
-    machineId,
-    lastSeenAt: Date.now(),
-    workspaces: [
-      {
-        workspaceId: workspace.workspaceId,
-        cwd: workspace.cwd,
-        name: workspace.name,
-        harnesses: [
-          {
-            name: harness.type,
-            displayName: harness.displayName,
-            agents: [...agents],
-            providers: [...providers]
-          }
-        ]
-      }
-    ]
-  });
-}
+// src/infrastructure/harnesses/cursor-sdk/cursor-session.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 
-// src/commands/machine/daemon-start/direct-harness/command-subscriber.ts
-function startCommandSubscriber(session2, wsClient2, deps) {
-  const processed = new Set;
-  let processing = false;
-  let pendingDrain = false;
-  const runDrain = () => {
-    if (processing) {
-      pendingDrain = true;
+class CursorSdkSession {
+  opencodeSessionId;
+  _sessionTitle;
+  get sessionTitle() {
+    return this._sessionTitle;
+  }
+  agent;
+  onClose;
+  listeners = new Set;
+  closed = false;
+  turnCount = 0;
+  constructor(options) {
+    this.agent = options.agent;
+    this.opencodeSessionId = options.opencodeSessionId;
+    this._sessionTitle = options.sessionTitle;
+    this.onClose = options.onClose;
+  }
+  setTitle(title) {
+    this._sessionTitle = title;
+  }
+  async prompt(input) {
+    if (this.closed)
+      throw new Error("Session is closed");
+    const text = input.parts.map((p) => p.text).join(`
+`);
+    const messageId = randomUUID3();
+    const isFirstTurn = this.turnCount === 0;
+    this.turnCount += 1;
+    const modelId = input.model ? resolveModelFromPrompt(input.model.providerID, input.model.modelID) : undefined;
+    const run3 = await withTimeout(this.agent.send(text, {
+      local: { force: isFirstTurn },
+      idempotencyKey: randomUUID3(),
+      ...modelId ? { model: { id: modelId } } : {}
+    }), SEND_TIMEOUT_MS2, "agent.send");
+    for await (const message of run3.stream()) {
+      if (this.closed)
+        break;
+      this.emitFromSdkMessage(message, messageId);
+    }
+    const result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS2, "run.wait");
+    if (result.status === "error") {
+      const detail = typeof result.result === "string" && result.result.trim().length > 0 ? result.result.trim() : `run ${result.id} failed`;
+      throw new Error(detail);
+    }
+    this.emit({ type: "session.idle", payload: {}, timestamp: Date.now() });
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async close() {
+    if (this.closed)
       return;
+    this.closed = true;
+    try {
+      this.agent.close();
+    } catch {}
+    this.onClose?.(this.opencodeSessionId);
+    this.listeners.clear();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
     }
-    processing = true;
-    pendingDrain = false;
-    drain(session2, deps, processed).finally(() => {
-      processing = false;
-      if (pendingDrain)
-        runDrain();
+  }
+  emitDelta(messageId, delta, partType) {
+    if (!delta)
+      return;
+    this.emit({
+      type: "message.part.delta",
+      payload: { messageID: messageId, delta, partType },
+      timestamp: Date.now()
     });
-  };
-  const unsub = wsClient2.onUpdate(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId }, () => runDrain(), (err) => {
-    console.warn("[direct-harness] Command subscription error:", err instanceof Error ? err.message : String(err));
-  });
-  return { stop: unsub };
-}
-async function dispatchPendingCommand(session2, deps, cmd) {
-  switch (cmd.type) {
-    case "refreshCapabilities":
-      await handleRefreshCapabilities(session2, deps, cmd);
-      break;
-    case "refreshSessionTitle":
-      await handleRefreshSessionTitle(session2, deps, cmd);
-      break;
-    default:
-      await markFailed(session2, cmd._id, `Unknown command type: ${cmd.type}`);
   }
-}
-async function processPendingCommand(session2, deps, cmd, now) {
-  if (now - cmd.createdAt > DIRECT_HARNESS_COMMAND_TTL_MS) {
-    console.log(`[direct-harness] Discarding stale command ${cmd._id} (type=${cmd.type}, age=${now - cmd.createdAt}ms)`);
-    await markFailed(session2, cmd._id, "Command expired (TTL)");
-    return;
+  emitFromSdkMessage(message, messageId) {
+    switch (message.type) {
+      case "assistant":
+        for (const block of message.message.content) {
+          if (block.type === "text" && block.text) {
+            this.emitDelta(messageId, block.text, "text");
+          }
+        }
+        break;
+      case "thinking":
+        if (message.text) {
+          this.emitDelta(messageId, message.text, "reasoning");
+        }
+        break;
+      default:
+        break;
+    }
   }
-  await dispatchPendingCommand(session2, deps, cmd);
 }
-async function drain(session2, deps, processed) {
-  const pending3 = await session2.backend.query(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId });
-  if (!pending3 || pending3.length === 0)
-    return;
-  const now = Date.now();
-  for (const cmd of pending3) {
-    if (processed.has(cmd._id))
-      continue;
-    processed.add(cmd._id);
-    try {
-      await processPendingCommand(session2, deps, cmd, now);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[direct-harness] Command ${cmd._id} failed: ${message}`);
-      await markFailed(session2, cmd._id, message).catch(() => {});
-    }
+function resolveModelFromPrompt(providerID, modelID) {
+  if (providerID === "cursor")
+    return resolveCursorSdkModel(modelID);
+  return resolveCursorSdkModel(`${providerID}/${modelID}`);
+}
+var SEND_TIMEOUT_MS2 = 60000, RUN_WAIT_TIMEOUT_MS2 = 3600000;
+var init_cursor_session = () => {};
+
+// src/infrastructure/harnesses/cursor-sdk/cursor-harness.ts
+async function loadSdk3() {
+  if (_sdkCache3)
+    return _sdkCache3;
+  if (_sdkLoadError3)
+    throw _sdkLoadError3;
+  try {
+    _sdkCache3 = await importBundledCursorSdk();
+    return _sdkCache3;
+  } catch (err) {
+    _sdkLoadError3 = err;
+    throw err;
   }
 }
-async function handleRefreshCapabilities(session2, deps, cmd) {
-  const payload = cmd.refreshCapabilities;
-  console.log(`[direct-harness] Processing refreshCapabilities for workspace=${cmd.workspaceId}` + (payload ? ` (initiatedBy=${payload.initiatedBy})` : ""));
-  const harness = await deps.lifecycleManager.getOrStart(cmd.workspaceId);
-  await updateCapabilities({ publisher: deps.publisher, machineId: session2.machineId }, {
-    harness,
-    workspace: {
-      workspaceId: cmd.workspaceId,
-      cwd: harness.cwd,
-      name: harness.cwd
+
+class CursorSdkHarness {
+  type = "cursor-sdk";
+  displayName = "Cursor (SDK)";
+  cwd;
+  closed = false;
+  sessions = new Map;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async models() {
+    const providers = await this.listProviders();
+    const models = [];
+    for (const provider of providers) {
+      for (const model of provider.models) {
+        models.push({
+          id: `${provider.providerID}/${model.modelID}`,
+          name: model.name,
+          provider: provider.name
+        });
+      }
     }
-  });
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId: cmd._id,
-    status: "done"
-  });
-  console.log(`[direct-harness] Capabilities refreshed for workspace=${cmd.workspaceId}`);
-}
-async function handleRefreshSessionTitle(session2, deps, cmd) {
-  const { harnessSessionId } = cmd.refreshSessionTitle ?? {};
-  if (!harnessSessionId) {
-    await markFailed(session2, cmd._id, "refreshSessionTitle: missing harnessSessionId");
-    return;
+    return models;
   }
-  const sessionRow = await session2.backend.query(api.daemon.directHarness.sessions.getSession, {
-    harnessSessionId
-  });
-  if (!sessionRow?.opencodeSessionId) {
-    await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-      sessionId: session2.sessionId,
-      commandId: cmd._id,
-      status: "done"
+  async listAgents() {
+    return [{ name: "builder", mode: "primary" }];
+  }
+  async listProviders() {
+    const apiKey = process.env.CURSOR_API_KEY?.trim();
+    if (!apiKey)
+      return [];
+    const { Cursor } = await loadSdk3();
+    const listed = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS2, "Cursor.models.list");
+    const modelIds = normalizeCursorSdkListedModels(listed.map((m) => m.id).filter((id3) => id3.length > 0));
+    return [
+      {
+        providerID: "cursor",
+        name: "Cursor",
+        models: modelIds.map((modelID) => ({ modelID, name: modelID }))
+      }
+    ];
+  }
+  async newSession(config3) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const apiKey = process.env.CURSOR_API_KEY?.trim();
+    if (!apiKey)
+      throw new Error("CURSOR_API_KEY is not set");
+    const modelId = resolveCursorSdkModel(config3.model ?? DEFAULT_MODEL2);
+    const { Agent } = await loadSdk3();
+    const agent = await withTimeout(Agent.create({
+      apiKey,
+      model: { id: modelId },
+      local: { cwd: this.cwd, settingSources: [] }
+    }), AGENT_CREATE_TIMEOUT_MS2, "Agent.create");
+    const session2 = new CursorSdkSession({
+      agent,
+      opencodeSessionId: agent.agentId,
+      sessionTitle: config3.title ?? "",
+      onClose: (id3) => this.sessions.delete(id3)
     });
-    return;
+    this.sessions.set(agent.agentId, session2);
+    return session2;
   }
-  const harness = await deps.lifecycleManager.getOrStart(cmd.workspaceId);
-  const newTitle = await harness.fetchSessionTitle(sessionRow.opencodeSessionId);
-  if (newTitle) {
-    await session2.backend.mutation(api.daemon.directHarness.sessions.updateSessionTitle, {
-      sessionId: session2.sessionId,
-      harnessSessionId,
-      sessionTitle: newTitle
+  async resumeSession(sessionId, _options) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const existing = this.sessions.get(sessionId);
+    if (existing)
+      return existing;
+    const apiKey = process.env.CURSOR_API_KEY?.trim();
+    if (!apiKey)
+      throw new Error("CURSOR_API_KEY is not set");
+    const { Agent } = await loadSdk3();
+    const agent = await withTimeout(Agent.resume(sessionId, {
+      apiKey,
+      model: { id: DEFAULT_MODEL2 },
+      local: { cwd: this.cwd, settingSources: [] }
+    }), AGENT_CREATE_TIMEOUT_MS2, "Agent.resume");
+    const session2 = new CursorSdkSession({
+      agent,
+      opencodeSessionId: agent.agentId,
+      sessionTitle: "",
+      onClose: (id3) => this.sessions.delete(id3)
     });
-    console.log(`[direct-harness] Refreshed title for session ${harnessSessionId}: "${newTitle}"`);
+    this.sessions.set(agent.agentId, session2);
+    return session2;
+  }
+  async fetchSessionTitle(_opencodeSessionId) {
+    return;
+  }
+  isAlive() {
+    return !this.closed;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const closing = [...this.sessions.values()].map((s) => s.close().catch(() => {}));
+    await Promise.all(closing);
+    this.sessions.clear();
   }
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId: cmd._id,
-    status: "done"
-  });
 }
-async function markFailed(session2, commandId, errorMessage) {
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId,
-    status: "failed",
-    errorMessage
-  });
+var DEFAULT_MODEL2 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache3, _sdkLoadError3, startCursorSdkHarness = async (config3) => {
+  try {
+    await loadSdk3();
+  } catch (err) {
+    throw new Error(`cursor-sdk unavailable: ${formatCursorSdkLoadError(err)}`);
+  }
+  if (!process.env.CURSOR_API_KEY?.trim()) {
+    throw new Error("CURSOR_API_KEY is not set");
+  }
+  return new CursorSdkHarness(config3.workingDir);
+};
+var init_cursor_harness = __esm(() => {
+  init_cursor_session();
+  init_cursor_sdk_package();
+});
+
+// src/infrastructure/harnesses/shared-chunk-extractor.ts
+function createStandardSdkChunkExtractor() {
+  return function extract(event) {
+    if (event.type !== "message.part.delta")
+      return null;
+    const payload = event.payload;
+    const delta = payload?.delta;
+    if (!delta || delta.length === 0)
+      return null;
+    const messageId = payload?.messageID;
+    if (!messageId)
+      return null;
+    return {
+      content: delta,
+      messageId,
+      partType: payload?.partType ?? "text"
+    };
+  };
 }
-var DIRECT_HARNESS_COMMAND_TTL_MS = 60000;
-var init_command_subscriber = __esm(() => {
-  init_api3();
+
+// src/infrastructure/harnesses/cursor-sdk/event-extractor.ts
+function createCursorSdkChunkExtractor() {
+  return createStandardSdkChunkExtractor();
+}
+var init_event_extractor = () => {};
+
+// src/infrastructure/harnesses/cursor-sdk/index.ts
+var init_cursor_sdk2 = __esm(() => {
+  init_cursor_harness();
+  init_cursor_session();
+  init_event_extractor();
 });
 
+// src/infrastructure/harnesses/opencode-sdk/event-extractor.ts
+function createOpencodeSdkChunkExtractor() {
+  const partMap = new Map;
+  return function extract(event) {
+    if (event.type === "message.part.updated") {
+      const payload = event.payload;
+      const part = payload?.part;
+      if (part?.id && part?.messageID) {
+        const partType = part.type === "reasoning" ? "reasoning" : "text";
+        partMap.set(part.id, { messageId: part.messageID, partType });
+        const delta = payload?.delta;
+        if (delta && delta.length > 0) {
+          return { content: delta, messageId: part.messageID, partType };
+        }
+      }
+      return null;
+    }
+    if (event.type === "message.part.delta") {
+      const payload = event.payload;
+      const delta = payload?.delta;
+      if (!delta || delta.length === 0)
+        return null;
+      const messageId = payload?.messageID;
+      if (!messageId)
+        return null;
+      const partID = payload?.partID;
+      const partType = (partID ? partMap.get(partID)?.partType : undefined) ?? "text";
+      return { content: delta, messageId, partType };
+    }
+    return null;
+  };
+}
+
 // src/infrastructure/harnesses/opencode-sdk/sse-event-buffer.ts
 var SseEventBuffer;
 var init_sse_event_buffer = __esm(() => {
@@ -83331,44 +83542,560 @@ var init_opencode_harness = __esm(() => {
   init_spawn_env();
 });
 
-// src/infrastructure/harnesses/opencode-sdk/event-extractor.ts
-function createOpencodeSdkChunkExtractor() {
-  const partMap = new Map;
-  return function extract(event) {
-    if (event.type === "message.part.updated") {
-      const payload = event.payload;
-      const part = payload?.part;
-      if (part?.id && part?.messageID) {
-        const partType = part.type === "reasoning" ? "reasoning" : "text";
-        partMap.set(part.id, { messageId: part.messageID, partType });
-        const delta = payload?.delta;
-        if (delta && delta.length > 0) {
-          return { content: delta, messageId: part.messageID, partType };
-        }
-      }
-      return null;
+// src/infrastructure/harnesses/pi-sdk/pi-session.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+class PiSdkSession {
+  opencodeSessionId;
+  _sessionTitle;
+  get sessionTitle() {
+    return this._sessionTitle;
+  }
+  session;
+  onClose;
+  listeners = new Set;
+  closed = false;
+  unsubscribe;
+  constructor(options) {
+    this.session = options.session;
+    this.opencodeSessionId = options.opencodeSessionId;
+    this._sessionTitle = options.sessionTitle;
+    this.onClose = options.onClose;
+  }
+  setTitle(title) {
+    this._sessionTitle = title;
+  }
+  async prompt(input) {
+    if (this.closed)
+      throw new Error("Session is closed");
+    const text = input.parts.map((p) => p.text).join(`
+`);
+    const messageId = randomUUID4();
+    const onSessionEvent = (event) => {
+      if (this.closed)
+        return;
+      this.emitFromPiEvent(event, messageId);
+    };
+    this.unsubscribe?.();
+    this.unsubscribe = this.session.subscribe(onSessionEvent);
+    await withTimeout(this.session.prompt(text), PROMPT_TIMEOUT_MS2, "session.prompt");
+    this.emit({ type: "session.idle", payload: {}, timestamp: Date.now() });
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.unsubscribe?.();
+    try {
+      await this.session.abort();
+    } catch {}
+    try {
+      this.session.dispose();
+    } catch {}
+    this.onClose?.(this.opencodeSessionId);
+    this.listeners.clear();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
     }
-    if (event.type === "message.part.delta") {
-      const payload = event.payload;
-      const delta = payload?.delta;
-      if (!delta || delta.length === 0)
-        return null;
-      const messageId = payload?.messageID;
-      if (!messageId)
-        return null;
-      const partID = payload?.partID;
-      const partType = (partID ? partMap.get(partID)?.partType : undefined) ?? "text";
-      return { content: delta, messageId, partType };
+  }
+  emitDelta(messageId, delta, partType) {
+    if (!delta)
+      return;
+    this.emit({
+      type: "message.part.delta",
+      payload: { messageID: messageId, delta, partType },
+      timestamp: Date.now()
+    });
+  }
+  emitFromPiEvent(event, messageId) {
+    if (event.type !== "message_update")
+      return;
+    const assistantEvent = event.assistantMessageEvent;
+    if (assistantEvent.type === "text_delta") {
+      this.emitDelta(messageId, assistantEvent.delta, "text");
+    } else if (assistantEvent.type === "thinking_delta") {
+      this.emitDelta(messageId, assistantEvent.delta, "reasoning");
     }
-    return null;
-  };
+  }
+}
+var PROMPT_TIMEOUT_MS2 = 3600000;
+var init_pi_session = () => {};
+
+// src/infrastructure/harnesses/pi-sdk/pi-harness.ts
+async function loadSdk4() {
+  if (_sdkCache4)
+    return _sdkCache4;
+  if (_sdkLoadError4)
+    throw _sdkLoadError4;
+  try {
+    _sdkCache4 = await importBundledPiSdk();
+    return _sdkCache4;
+  } catch (err) {
+    _sdkLoadError4 = err;
+    throw err;
+  }
+}
+function resolveModel2(modelRegistry, model) {
+  if (model) {
+    const slash = model.indexOf("/");
+    if (slash === -1) {
+      return modelRegistry.getAll().find((entry) => entry.id === model);
+    }
+    const provider = model.slice(0, slash);
+    const modelId = model.slice(slash + 1);
+    return modelRegistry.find(provider, modelId);
+  }
+  return modelRegistry.getAvailable()[0];
+}
+
+class PiSdkHarness {
+  type = "pi-sdk";
+  displayName = "Pi (SDK)";
+  cwd;
+  closed = false;
+  sessions = new Map;
+  modelRegistry;
+  authStorage;
+  constructor(cwd, modelRegistry, authStorage) {
+    this.cwd = cwd;
+    this.modelRegistry = modelRegistry;
+    this.authStorage = authStorage;
+  }
+  async models() {
+    return this.modelRegistry.getAvailable().map((entry) => ({
+      id: `${entry.provider}/${entry.id}`,
+      name: entry.id,
+      provider: entry.provider
+    }));
+  }
+  async listAgents() {
+    return [{ name: "builder", mode: "primary" }];
+  }
+  async listProviders() {
+    const byProvider = new Map;
+    for (const entry of this.modelRegistry.getAvailable()) {
+      const models = byProvider.get(entry.provider) ?? [];
+      models.push({ modelID: entry.id, name: entry.id });
+      byProvider.set(entry.provider, models);
+    }
+    return [...byProvider.entries()].map(([providerID, models]) => ({
+      providerID,
+      name: providerID,
+      models
+    }));
+  }
+  async newSession(config3) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const session2 = await this.createAgentSession(config3.systemPrompt ?? "", config3.model);
+    const piSession = new PiSdkSession({
+      session: session2,
+      opencodeSessionId: session2.sessionId,
+      sessionTitle: config3.title ?? "",
+      onClose: (id3) => this.sessions.delete(id3)
+    });
+    this.sessions.set(session2.sessionId, piSession);
+    return piSession;
+  }
+  async resumeSession(sessionId, _options) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const existing = this.sessions.get(sessionId);
+    if (existing)
+      return existing;
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+    const sessions = await SessionManager.list(this.cwd, getPiSessionDir(this.cwd));
+    const match17 = sessions.find((s) => s.id === sessionId);
+    if (!match17) {
+      throw new Error(`Session ${sessionId} not found on the harness`);
+    }
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: this.cwd,
+      agentDir: getAgentDir(),
+      systemPromptOverride: () => ""
+    });
+    await resourceLoader.reload();
+    const resolvedModel = resolveModel2(this.modelRegistry);
+    if (!resolvedModel) {
+      throw new Error("No Pi model available");
+    }
+    const { session: session2 } = await withTimeout(createAgentSession({
+      cwd: this.cwd,
+      model: resolvedModel,
+      sessionManager: SessionManager.open(match17.path, getPiSessionDir(this.cwd)),
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader
+    }), SESSION_CREATE_TIMEOUT_MS3, "createAgentSession");
+    const piSession = new PiSdkSession({
+      session: session2,
+      opencodeSessionId: session2.sessionId,
+      sessionTitle: match17.name ?? "",
+      onClose: (id3) => this.sessions.delete(id3)
+    });
+    this.sessions.set(session2.sessionId, piSession);
+    return piSession;
+  }
+  async fetchSessionTitle(_opencodeSessionId) {
+    return;
+  }
+  isAlive() {
+    return !this.closed;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const closing = [...this.sessions.values()].map((s) => s.close().catch(() => {}));
+    await Promise.all(closing);
+    this.sessions.clear();
+  }
+  async createAgentSession(systemPrompt, model) {
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+    const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL3);
+    if (!resolvedModel) {
+      throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
+    }
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: this.cwd,
+      agentDir: getAgentDir(),
+      systemPromptOverride: () => systemPrompt
+    });
+    await resourceLoader.reload();
+    const { session: session2 } = await withTimeout(createAgentSession({
+      cwd: this.cwd,
+      model: resolvedModel,
+      sessionManager: SessionManager.create(getPiSessionDir(this.cwd)),
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader
+    }), SESSION_CREATE_TIMEOUT_MS3, "createAgentSession");
+    return session2;
+  }
+}
+var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle", _sdkCache4, _sdkLoadError4, startPiSdkHarness = async (config3) => {
+  try {
+    const { AuthStorage, ModelRegistry } = await loadSdk4();
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    if (modelRegistry.getAvailable().length === 0) {
+      throw new Error("No Pi models available");
+    }
+    return new PiSdkHarness(config3.workingDir, modelRegistry, authStorage);
+  } catch (err) {
+    throw new Error(`pi-sdk unavailable: ${formatPiSdkLoadError(err)}`);
+  }
+};
+var init_pi_harness = __esm(() => {
+  init_pi_session();
+  init_pi_agent_service();
+  init_pi_sdk_package();
+});
+
+// src/infrastructure/harnesses/pi-sdk/event-extractor.ts
+function createPiSdkChunkExtractor() {
+  return createStandardSdkChunkExtractor();
 }
+var init_event_extractor2 = () => {};
+
+// src/infrastructure/harnesses/pi-sdk/index.ts
+var init_pi_sdk2 = __esm(() => {
+  init_pi_harness();
+  init_pi_session();
+  init_event_extractor2();
+});
 
-// src/infrastructure/harnesses/opencode-sdk/index.ts
-var init_opencode_sdk2 = __esm(() => {
+// src/infrastructure/harnesses/registry.ts
+import { execSync as execSync2 } from "node:child_process";
+async function startBoundHarness(config3) {
+  switch (config3.harnessName) {
+    case "opencode-sdk":
+      return startOpencodeSdkHarness(config3);
+    case "cursor-sdk":
+      return startCursorSdkHarness(config3);
+    case "pi-sdk":
+      return startPiSdkHarness(config3);
+    default: {
+      const _exhaustive = config3.harnessName;
+      throw new Error(`Unsupported direct harness: ${String(_exhaustive)}`);
+    }
+  }
+}
+function createChunkExtractor(harnessName) {
+  switch (harnessName) {
+    case "opencode-sdk":
+      return createOpencodeSdkChunkExtractor();
+    case "cursor-sdk":
+      return createCursorSdkChunkExtractor();
+    case "pi-sdk":
+      return createPiSdkChunkExtractor();
+    default:
+      return createStandardSdkChunkExtractor();
+  }
+}
+function opencodeOnPath() {
+  try {
+    execSync2("opencode --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isCursorSdkInstalled() {
+  if (!process.env.CURSOR_API_KEY?.trim())
+    return false;
+  try {
+    const { importBundledCursorSdk: importBundledCursorSdk2 } = await Promise.resolve().then(() => (init_cursor_sdk_package(), exports_cursor_sdk_package));
+    await importBundledCursorSdk2();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isPiSdkInstalled() {
+  try {
+    const { importBundledPiSdk: importBundledPiSdk2 } = await Promise.resolve().then(() => (init_pi_sdk_package(), exports_pi_sdk_package));
+    const { ModelRegistry, AuthStorage } = await importBundledPiSdk2();
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    return modelRegistry.getAvailable().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function listInstalledNativeDirectHarnesses() {
+  const installed2 = [];
+  if (opencodeOnPath())
+    installed2.push("opencode-sdk");
+  if (await isCursorSdkInstalled())
+    installed2.push("cursor-sdk");
+  if (await isPiSdkInstalled())
+    installed2.push("pi-sdk");
+  return installed2;
+}
+var init_registry4 = __esm(() => {
+  init_cursor_sdk2();
   init_opencode_harness();
+  init_pi_sdk2();
+});
+
+// src/commands/machine/daemon-start/direct-harness/command-subscriber.ts
+function startCommandSubscriber(session2, wsClient2, deps) {
+  const processed = new Set;
+  let processing = false;
+  let pendingDrain = false;
+  const runDrain = () => {
+    if (processing) {
+      pendingDrain = true;
+      return;
+    }
+    processing = true;
+    pendingDrain = false;
+    drain(session2, deps, processed).finally(() => {
+      processing = false;
+      if (pendingDrain)
+        runDrain();
+    });
+  };
+  const unsub = wsClient2.onUpdate(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId }, () => runDrain(), (err) => {
+    console.warn("[direct-harness] Command subscription error:", err instanceof Error ? err.message : String(err));
+  });
+  return { stop: unsub };
+}
+async function dispatchPendingCommand(session2, deps, cmd) {
+  switch (cmd.type) {
+    case "refreshCapabilities":
+      await handleRefreshCapabilities(session2, deps, cmd);
+      break;
+    case "refreshSessionTitle":
+      await handleRefreshSessionTitle(session2, deps, cmd);
+      break;
+    case "closeSession":
+      await handleCloseSession(session2, deps, cmd);
+      break;
+    default:
+      await markFailed(session2, cmd._id, `Unknown command type: ${cmd.type}`);
+  }
+}
+async function processPendingCommand(session2, deps, cmd, now) {
+  if (now - cmd.createdAt > DIRECT_HARNESS_COMMAND_TTL_MS) {
+    console.log(`[direct-harness] Discarding stale command ${cmd._id} (type=${cmd.type}, age=${now - cmd.createdAt}ms)`);
+    await markFailed(session2, cmd._id, "Command expired (TTL)");
+    return;
+  }
+  await dispatchPendingCommand(session2, deps, cmd);
+}
+async function drain(session2, deps, processed) {
+  const pending3 = await session2.backend.query(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId });
+  if (!pending3 || pending3.length === 0)
+    return;
+  const now = Date.now();
+  for (const cmd of pending3) {
+    if (processed.has(cmd._id))
+      continue;
+    processed.add(cmd._id);
+    try {
+      await processPendingCommand(session2, deps, cmd, now);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[direct-harness] Command ${cmd._id} failed: ${message}`);
+      await markFailed(session2, cmd._id, message).catch(() => {});
+    }
+  }
+}
+async function handleRefreshCapabilities(session2, deps, cmd) {
+  const payload = cmd.refreshCapabilities;
+  console.log(`[direct-harness] Processing refreshCapabilities for workspace=${cmd.workspaceId}` + (payload ? ` (initiatedBy=${payload.initiatedBy})` : ""));
+  const installed2 = await listInstalledNativeDirectHarnesses();
+  const harnessEntries = [];
+  let cwd = "";
+  for (const harnessName of installed2) {
+    const harness = await deps.lifecycleManager.getOrStart(cmd.workspaceId, harnessName);
+    cwd = harness.cwd;
+    const [agents, providers] = await Promise.all([harness.listAgents(), harness.listProviders()]);
+    harnessEntries.push({
+      name: harness.type,
+      displayName: harness.displayName,
+      agents: [...agents],
+      providers: [...providers]
+    });
+  }
+  const existing = await session2.backend.query(api.daemon.directHarness.capabilities.getForMachine, { sessionId: session2.sessionId, machineId: session2.machineId });
+  const updatedWorkspace = {
+    workspaceId: cmd.workspaceId,
+    cwd,
+    name: cwd,
+    harnesses: harnessEntries
+  };
+  const merged = [
+    ...(existing?.workspaces ?? []).filter((ws) => ws.workspaceId !== cmd.workspaceId),
+    updatedWorkspace
+  ];
+  await deps.publisher.publish({
+    machineId: session2.machineId,
+    lastSeenAt: Date.now(),
+    workspaces: merged
+  });
+  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
+    sessionId: session2.sessionId,
+    commandId: cmd._id,
+    status: "done"
+  });
+  console.log(`[direct-harness] Capabilities refreshed for workspace=${cmd.workspaceId}`);
+}
+async function handleRefreshSessionTitle(session2, deps, cmd) {
+  const { harnessSessionId } = cmd.refreshSessionTitle ?? {};
+  if (!harnessSessionId) {
+    await markFailed(session2, cmd._id, "refreshSessionTitle: missing harnessSessionId");
+    return;
+  }
+  const sessionRow = await session2.backend.query(api.daemon.directHarness.sessions.getSession, {
+    harnessSessionId
+  });
+  if (!sessionRow?.opencodeSessionId) {
+    await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
+      sessionId: session2.sessionId,
+      commandId: cmd._id,
+      status: "done"
+    });
+    return;
+  }
+  const harnessName = sessionRow.harnessName ?? "opencode-sdk";
+  const harness = await deps.lifecycleManager.getOrStart(sessionRow.workspaceId ?? cmd.workspaceId, harnessName);
+  const newTitle = await harness.fetchSessionTitle(sessionRow.opencodeSessionId);
+  if (newTitle) {
+    await session2.backend.mutation(api.daemon.directHarness.sessions.updateSessionTitle, {
+      sessionId: session2.sessionId,
+      harnessSessionId,
+      sessionTitle: newTitle
+    });
+    console.log(`[direct-harness] Refreshed title for session ${harnessSessionId}: "${newTitle}"`);
+  }
+  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
+    sessionId: session2.sessionId,
+    commandId: cmd._id,
+    status: "done"
+  });
+}
+async function closeDisconnectedHarnessSession(deps, sessionRow, harnessSessionId) {
+  if (!sessionRow.opencodeSessionId) {
+    await deps.sessionRepository.markClosed(harnessSessionId);
+    return;
+  }
+  const harnessName = sessionRow.harnessName ?? "opencode-sdk";
+  const harness = await deps.lifecycleManager.getOrStart(sessionRow.workspaceId ?? "", harnessName);
+  const liveSession = await harness.resumeSession(sessionRow.opencodeSessionId, {
+    harnessSessionId
+  });
+  await liveSession.close();
+  await deps.sessionRepository.markClosed(harnessSessionId);
+}
+async function closeHarnessSession(session2, deps, harnessSessionId) {
+  const sessionRow = await session2.backend.query(api.daemon.directHarness.sessions.getSession, {
+    harnessSessionId
+  });
+  if (!sessionRow) {
+    throw new Error(`Harness session ${harnessSessionId} not found`);
+  }
+  if (sessionRow.status === "closed" || sessionRow.status === "failed") {
+    return;
+  }
+  const handle = deps.activeSessions.get(harnessSessionId);
+  if (handle) {
+    await handle.close();
+    deps.activeSessions.delete(harnessSessionId);
+    return;
+  }
+  await closeDisconnectedHarnessSession(deps, sessionRow, harnessSessionId);
+}
+async function handleCloseSession(session2, deps, cmd) {
+  const { harnessSessionId } = cmd.closeSession ?? {};
+  if (!harnessSessionId) {
+    await markFailed(session2, cmd._id, "closeSession: missing harnessSessionId");
+    return;
+  }
+  console.log(`[direct-harness] Processing closeSession for harnessSessionId=${harnessSessionId}`);
+  await closeHarnessSession(session2, deps, harnessSessionId);
+  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
+    sessionId: session2.sessionId,
+    commandId: cmd._id,
+    status: "done"
+  });
+  console.log(`[direct-harness] Closed session ${harnessSessionId}`);
+}
+async function markFailed(session2, commandId, errorMessage) {
+  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
+    sessionId: session2.sessionId,
+    commandId,
+    status: "failed",
+    errorMessage
+  });
+}
+var DIRECT_HARNESS_COMMAND_TTL_MS = 60000;
+var init_command_subscriber = __esm(() => {
+  init_api3();
+  init_registry4();
 });
 
+// src/infrastructure/harnesses/harness-key.ts
+function makeHarnessKey(workspaceId, harnessName) {
+  return `${workspaceId}:${harnessName}`;
+}
+function parseHarnessKey(key) {
+  const idx = key.indexOf(":");
+  if (idx === -1)
+    throw new Error(`Invalid harness key: ${key}`);
+  return { workspaceId: key.slice(0, idx), harnessName: key.slice(idx + 1) };
+}
+
 // src/commands/machine/daemon-start/direct-harness/harness-lifecycle-manager.ts
 class HarnessLifecycleManager {
   harnesses;
@@ -83383,10 +84110,15 @@ class HarnessLifecycleManager {
     this.resolveWorkspace = resolveWorkspace;
     this.resolvedConvexUrl = resolvedConvexUrl;
   }
-  getOrStartHarnessEffect(workspaceId) {
-    const existing = this.harnesses.get(workspaceId);
-    if (existing)
+  getOrStartHarnessEffect(workspaceId, harnessName) {
+    const key = makeHarnessKey(workspaceId, harnessName);
+    const existing = this.harnesses.get(key);
+    if (existing?.isAlive())
       return exports_Effect.succeed(existing);
+    if (existing) {
+      existing.close().catch(() => {});
+      this.harnesses.delete(key);
+    }
     return exports_Effect.gen(this, function* () {
       const workspace = yield* exports_Effect.tryPromise({
         try: () => this.resolveWorkspace(workspaceId),
@@ -83395,23 +84127,23 @@ class HarnessLifecycleManager {
       if (!workspace) {
         return yield* exports_Effect.fail(new Error(`Workspace ${workspaceId} not found — cannot start harness`));
       }
-      console.log(`[${formatTimestamp()}] \uD83D\uDD27 Auto-starting harness for workspace=${workspaceId} (${workspace.workingDir})`);
+      console.log(`[${formatTimestamp()}] \uD83D\uDD27 Auto-starting ${harnessName} for workspace=${workspaceId} (${workspace.workingDir})`);
       const harness = yield* exports_Effect.tryPromise({
-        try: () => startOpencodeSdkHarness({
-          type: "opencode",
+        try: () => startBoundHarness({
+          harnessName,
           workingDir: workspace.workingDir,
           workspaceId,
           resolvedConvexUrl: this.resolvedConvexUrl
         }),
         catch: (e) => e instanceof Error ? e : new Error(String(e))
       });
-      this.harnesses.set(workspaceId, harness);
-      this.idleSince.set(workspaceId, Date.now());
+      this.harnesses.set(key, harness);
+      this.idleSince.set(key, Date.now());
       return harness;
     });
   }
-  async getOrStart(workspaceId) {
-    return exports_Effect.runPromise(this.getOrStartHarnessEffect(workspaceId));
+  async getOrStart(workspaceId, harnessName) {
+    return exports_Effect.runPromise(this.getOrStartHarnessEffect(workspaceId, harnessName));
   }
   startMonitoring() {
     if (this.monitorTimer)
@@ -83427,28 +84159,30 @@ class HarnessLifecycleManager {
   }
   checkInactivity() {
     const now = Date.now();
-    for (const workspaceId of this.harnesses.keys()) {
-      const hasActiveSessions = this.hasSessionsForWorkspace(workspaceId);
+    for (const key of this.harnesses.keys()) {
+      const { workspaceId, harnessName } = parseHarnessKey(key);
+      const hasActiveSessions = this.hasSessionsForHarnessKey(workspaceId, harnessName);
       if (hasActiveSessions) {
-        this.idleSince.delete(workspaceId);
+        this.idleSince.delete(key);
       } else {
-        const idleStart = this.idleSince.get(workspaceId);
+        const idleStart = this.idleSince.get(key);
         if (idleStart === undefined) {
-          this.idleSince.set(workspaceId, now);
+          this.idleSince.set(key, now);
         } else if (now - idleStart >= INACTIVITY_TTL_MS) {
           const idleMinutes = Math.round((now - idleStart) / 60000);
-          console.log(`[${formatTimestamp()}] \uD83D\uDD2A Killing idle harness for workspace=${workspaceId} (idle ${idleMinutes}min)`);
-          this.harnesses.get(workspaceId)?.close().catch(() => {});
-          this.harnesses.delete(workspaceId);
-          this.idleSince.delete(workspaceId);
+          console.log(`[${formatTimestamp()}] \uD83D\uDD2A Killing idle harness ${harnessName} for workspace=${workspaceId} (idle ${idleMinutes}min)`);
+          this.harnesses.get(key)?.close().catch(() => {});
+          this.harnesses.delete(key);
+          this.idleSince.delete(key);
         }
       }
     }
   }
-  hasSessionsForWorkspace(workspaceId) {
+  hasSessionsForHarnessKey(workspaceId, harnessName) {
     for (const handle of this.activeSessions.values()) {
-      if (handle.workspaceId === workspaceId)
+      if (handle.workspaceId === workspaceId && handle.harnessName === harnessName) {
         return true;
+      }
     }
     return false;
   }
@@ -83456,7 +84190,7 @@ class HarnessLifecycleManager {
 var INACTIVITY_TTL_MS, CHECK_INTERVAL_MS;
 var init_harness_lifecycle_manager = __esm(() => {
   init_esm();
-  init_opencode_sdk2();
+  init_registry4();
   INACTIVITY_TTL_MS = 15 * 60 * 1000;
   CHECK_INTERVAL_MS = 60 * 1000;
 });
@@ -83551,6 +84285,7 @@ async function resumeSession(deps, input) {
   let closed = false;
   const handle = {
     harnessSessionId,
+    harnessName: input.harnessName,
     opencodeSessionId,
     workspaceId: input.workspaceId ?? "",
     session: session2,
@@ -83615,14 +84350,16 @@ async function resumeSessionHandle(session2, deps, rowId, info) {
     return null;
   }
   const workspaceId = info.workspaceId;
+  const harnessName = info.harnessName;
   if (!workspaceId) {
     console.warn(`[direct-harness] Cannot resume session ${rowId}: no workspace info`);
     return null;
   }
-  let harness = deps.harnesses.get(workspaceId);
+  const key = makeHarnessKey(workspaceId, harnessName);
+  let harness = deps.harnesses.get(key);
   if (harness && !harness.isAlive()) {
     harness.close().catch(() => {});
-    deps.harnesses.delete(workspaceId);
+    deps.harnesses.delete(key);
     harness = undefined;
   }
   if (!harness) {
@@ -83634,20 +84371,20 @@ async function resumeSessionHandle(session2, deps, rowId, info) {
       console.warn(`[direct-harness] Cannot resume session ${rowId}: workspace not found`);
       return null;
     }
-    harness = await startOpencodeSdkHarness({
-      type: "opencode",
+    harness = await startBoundHarness({
+      harnessName,
       workingDir: workspace.workingDir,
       workspaceId,
       resolvedConvexUrl: session2.convexUrl
     });
-    deps.harnesses.set(workspaceId, harness);
+    deps.harnesses.set(key, harness);
   }
   try {
     return await resumeSession({
       harness,
       journalFactory: deps.journalFactory,
-      chunkExtractor: createOpencodeSdkChunkExtractor()
-    }, { harnessSessionId: rowId, opencodeSessionId, workspaceId });
+      chunkExtractor: createChunkExtractor(harness.type)
+    }, { harnessSessionId: rowId, opencodeSessionId, workspaceId, harnessName });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.warn(`[direct-harness] Cannot resume session ${rowId}: ${message}`);
@@ -83693,8 +84430,9 @@ async function deliverPendingMessages(handle, deps, rowId, messages, info) {
       console.warn(`[direct-harness] Prompt failed for session ${rowId} seq=${msg.seq}: ${message}`);
       await deps.sessionRepository.markIdle(rowId).catch(() => {});
       deps.activeSessions.delete(rowId);
-      if (info?.workspaceId)
-        deps.harnesses.delete(info.workspaceId);
+      if (info?.workspaceId && info.harnessName) {
+        deps.harnesses.delete(makeHarnessKey(info.workspaceId, info.harnessName));
+      }
       return;
     }
   }
@@ -83721,7 +84459,7 @@ var init_prompt_subscriber = __esm(() => {
   init_idle_handler();
   init_api3();
   init_resume_session();
-  init_opencode_sdk2();
+  init_registry4();
 });
 
 // src/commands/machine/daemon-start/direct-harness/session-subscriber.ts
@@ -83746,21 +84484,23 @@ function startSessionSubscriber(daemonSession, wsClient2, deps) {
   return { stop: unsub };
 }
 async function getOrCreateHarness(daemonSession, deps, session2, workspace) {
-  let harness = deps.harnesses.get(session2.workspaceId);
+  const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
+  const key = makeHarnessKey(session2.workspaceId, harnessName);
+  let harness = deps.harnesses.get(key);
   if (harness && !harness.isAlive()) {
-    console.warn(`[direct-harness] Harness for workspace ${session2.workspaceId} is no longer alive — restarting`);
+    console.warn(`[direct-harness] Harness ${harnessName} for workspace ${session2.workspaceId} is no longer alive — restarting`);
     harness.close().catch(() => {});
-    deps.harnesses.delete(session2.workspaceId);
+    deps.harnesses.delete(key);
     harness = undefined;
   }
   if (!harness) {
-    harness = await startOpencodeSdkHarness({
-      type: "opencode",
+    harness = await startBoundHarness({
+      harnessName,
       workingDir: workspace.workingDir,
       workspaceId: session2.workspaceId,
       resolvedConvexUrl: daemonSession.convexUrl
     });
-    deps.harnesses.set(session2.workspaceId, harness);
+    deps.harnesses.set(key, harness);
   }
   return harness;
 }
@@ -83812,13 +84552,17 @@ async function processOne(daemonSession, deps, session2) {
       await deps.sessionRepository.markFailed(rowId);
       return;
     }
+    const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
     const harness = await getOrCreateHarness(daemonSession, deps, session2, workspace);
+    const modelConfig = session2.opencode?.lastUsedConfig.model;
+    const model = modelConfig ? `${modelConfig.providerID}/${modelConfig.modelID}` : undefined;
     const liveSession = await harness.newSession({
       agent: session2.opencode?.lastUsedConfig.agent ?? "build",
+      model,
       harnessSessionId: rowId
     });
     const journal = deps.journalFactory.create(rowId);
-    const extractChunk = createOpencodeSdkChunkExtractor();
+    const extractChunk = createChunkExtractor(harness.type);
     const idleConfig = {
       agent: session2.opencode?.lastUsedConfig.agent ?? "build",
       model: session2.opencode?.lastUsedConfig.model
@@ -83833,9 +84577,11 @@ async function processOne(daemonSession, deps, session2) {
       await journal.commit();
       await liveSession.close();
       await deps.sessionRepository.markClosed(rowId);
+      deps.activeSessions.delete(rowId);
     };
     const handle = {
       harnessSessionId: rowId,
+      harnessName,
       opencodeSessionId: liveSession.opencodeSessionId,
       workspaceId: session2.workspaceId,
       session: liveSession,
@@ -83873,7 +84619,61 @@ async function processOne(daemonSession, deps, session2) {
 var init_session_subscriber = __esm(() => {
   init_idle_handler();
   init_api3();
-  init_opencode_sdk2();
+  init_registry4();
+});
+
+// src/commands/machine/daemon-start/direct-harness/shutdown-sessions.ts
+async function listHarnessSessionIdsForShutdown(session2) {
+  const ids3 = new Set;
+  const managed = await session2.backend.query(api.daemon.directHarness.turns.getMachineHarnessSessions, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId
+  });
+  for (const row of managed) {
+    ids3.add(row.harnessSessionId);
+  }
+  const pending3 = await session2.backend.query(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId
+  });
+  for (const row of pending3) {
+    ids3.add(row._id);
+  }
+  return [...ids3];
+}
+async function closeAllMachineHarnessSessionsOnShutdown(session2, deps) {
+  const commandDeps = {
+    lifecycleManager: deps.lifecycleManager,
+    publisher: {},
+    activeSessions: deps.activeSessions,
+    sessionRepository: deps.sessionRepository
+  };
+  const harnessSessionIds = await listHarnessSessionIdsForShutdown(session2);
+  if (harnessSessionIds.length === 0)
+    return;
+  console.log(`[direct-harness] Closing ${harnessSessionIds.length} harness session(s) on daemon shutdown...`);
+  for (const harnessSessionId of harnessSessionIds) {
+    try {
+      await session2.backend.mutation(api.daemon.directHarness.turns.markOrphanTurnsFailed, {
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        harnessSessionId
+      });
+    } catch {}
+    try {
+      await closeHarnessSession(session2, commandDeps, harnessSessionId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[direct-harness] Failed to close session ${harnessSessionId} on shutdown: ${message}`);
+      try {
+        await deps.sessionRepository.markClosed(harnessSessionId);
+      } catch {}
+    }
+  }
+}
+var init_shutdown_sessions = __esm(() => {
+  init_command_subscriber();
+  init_api3();
 });
 
 // src/infrastructure/repos/convex-capabilities-publisher.ts
@@ -84164,13 +84964,20 @@ function startDirectHarnessSubscriptions(session2, wsClient2, activeSessions, ha
     publisher: new ConvexCapabilitiesPublisher({
       backend: session2.backend,
       sessionId: session2.sessionId
-    })
+    }),
+    activeSessions,
+    sessionRepository
   });
   return {
     pendingPromptSubscriptionHandle,
     pendingHarnessSessionSubscriptionHandle,
     commandSubscriptionHandle,
-    lifecycleManager
+    lifecycleManager,
+    closeSessionsOnShutdown: () => closeAllMachineHarnessSessionsOnShutdown(session2, {
+      lifecycleManager,
+      activeSessions,
+      sessionRepository
+    })
   };
 }
 var init_start_subscriptions = __esm(() => {
@@ -84178,6 +84985,7 @@ var init_start_subscriptions = __esm(() => {
   init_harness_lifecycle_manager();
   init_prompt_subscriber();
   init_session_subscriber();
+  init_shutdown_sessions();
   init_api3();
   init_convex_capabilities_publisher();
   init_convex_output_repository();
@@ -85191,12 +85999,13 @@ class NativeTaskDeliveryCoordinator {
     }
   }
   reconcileAssignedTasks(params) {
-    const { tasks, runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps } = params;
-    for (const task of tasks) {
-      const slot = agentMgr.getSlot(task.chatroomId, task.agentConfig.role);
+    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(task, {
-        ledger: this.ledger,
+      if (!shouldDeliverNativeTask(row, {
+        ledger,
         harnessSessionId
       })) {
         continue;
@@ -85204,14 +86013,24 @@ class NativeTaskDeliveryCoordinator {
       if (!harnessSessionId) {
         continue;
       }
-      exports_Runtime.runFork(runtime4)(runNativeInjectionEffect(task, harnessSessionId, {
-        sessionId: sessionDeps.sessionId,
-        backend: sessionDeps.backend,
-        agentMgr: {
-          resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
-        },
-        convexUrl: sessionDeps.convexUrl
-      }, this.ledger).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${task.agentConfig.role}@${task.chatroomId}: ${getErrorMessage(err)}`)))));
+      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,
+          backend: sessionDeps.backend,
+          agentMgr: {
+            resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
+          },
+          convexUrl: sessionDeps.convexUrl
+        }, ledger);
+      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${row.agentConfig.role}@${row.chatroomId}: ${getErrorMessage(err)}`)))));
     }
   }
 }
@@ -85227,6 +86046,7 @@ var init_native_task_delivery_coordinator = __esm(() => {
   init_esm();
   init_native_task_injector_logic();
   init_native_task_injector();
+  init_api3();
   init_convex_error();
 });
 
@@ -85557,6 +86377,9 @@ function appendRecentLogLine(slot, line) {
 }
 var RECENT_LOG_LINE_CAP2 = 100;
 
+// 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";
+
 // src/domain/agent-lifecycle/use-cases/handle-turn-completed.ts
 async function handleTurnCompleted(deps, input, slot) {
   if (await tryAbortResumeStorm(deps, input, slot)) {
@@ -85956,6 +86779,7 @@ class AgentProcessManager {
   deps;
   slots = new Map;
   lastHarnessSessions = new Map;
+  sessionReopenRetryInFlight = new Set;
   exitRetryQueue = [];
   exitRetryTimer = null;
   turnEndQueue = new TurnEndQueue;
@@ -86305,6 +87129,10 @@ class AgentProcessManager {
       return;
     }
     const coldRestartAfterRunError = this.clearHarnessSessionAfterRunError(key, logs);
+    if (harness === "cursor-sdk") {
+      this.retryCursorSdkSessionReopen(opts, ctx, coldRestartAfterRunError);
+      return;
+    }
     this.ensureRunning({
       chatroomId: opts.chatroomId,
       role: opts.role,
@@ -86322,6 +87150,49 @@ class AgentProcessManager {
       this.emitStartFailedEvent(opts.role, opts.chatroomId, err.message);
     });
   }
+  async retryCursorSdkSessionReopen(opts, ctx, coldRestartAfterRunError) {
+    const key = agentKey3(opts.chatroomId, opts.role);
+    if (this.sessionReopenRetryInFlight.has(key)) {
+      return;
+    }
+    this.sessionReopenRetryInFlight.add(key);
+    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++) {
+        await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, attempt > 1 ? lastError : undefined, storedSessionId);
+        const result = await this.ensureRunning({
+          chatroomId: opts.chatroomId,
+          role: opts.role,
+          agentHarness: harness,
+          model,
+          workingDir,
+          reason: CURSOR_SDK_SESSION_REOPEN_REASON,
+          wantResume
+        });
+        if (result.success) {
+          return;
+        }
+        lastError = result.error ?? "unknown";
+        if (attempt < CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS) {
+          await this.deps.clock.delay(CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS);
+        }
+      }
+      const failureMessage = `cursor-sdk session reopen failed after ${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS} attempts: ${lastError}`;
+      console.log(`[AgentProcessManager] ⛔ ${failureMessage}`);
+      this.emitStartFailedEvent(opts.role, opts.chatroomId, failureMessage);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`   ⚠️  cursor-sdk session reopen retry loop failed: ${message}`);
+      this.emitStartFailedEvent(opts.role, opts.chatroomId, message);
+    } finally {
+      this.sessionReopenRetryInFlight.delete(key);
+    }
+  }
   handlePermanentFailureForRestart(opts, recentLogLines, startFailedAlreadyEmitted) {
     const error = isTerminalProviderFailureInLogs(recentLogLines ?? []) ? formatTerminalProviderFailureMessage(recentLogLines ?? []) : formatPermanentHarnessFailureMessage(recentLogLines ?? []);
     console.log(`[AgentProcessManager] ⛔ Skipping restart — ${error}`);
@@ -86637,6 +87508,23 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${err.message}`);
     }
   }
+  async emitSessionReopenRetry(chatroomId, role, attempt, error, harnessSessionId) {
+    try {
+      await this.deps.backend.mutation(api.machines.emitSessionReopenRetry, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId,
+        role,
+        attempt,
+        maxAttempts: CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS,
+        ...error ? { error } : {},
+        ...harnessSessionId ? { harnessSessionId } : {}
+      });
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionReopenRetry for ${role} (attempt ${attempt}/${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS})`);
+    } catch (err) {
+      console.log(`   ⚠️  Failed to emit sessionReopenRetry event: ${err.message}`);
+    }
+  }
   resetSlotIdle(slot) {
     slot.state = "idle";
     slot.pendingOperation = undefined;
@@ -87039,7 +87927,7 @@ class SpawnRateLimiter {
     this.config = { ...DEFAULT_CONFIG2, ...config3 };
   }
   tryConsume(chatroomId, reason) {
-    if (reason.startsWith("user.") || reason === "platform.auto_restart_on_new_context") {
+    if (reason.startsWith("user.") || reason === "platform.auto_restart_on_new_context" || reason === "platform.cursor_sdk_session_reopen") {
       return { allowed: true };
     }
     const bucket = this._getOrCreateBucket(chatroomId);
@@ -87066,13 +87954,16 @@ class SpawnRateLimiter {
     };
   }
   _getOrCreateBucket(chatroomId) {
-    if (!this.buckets.has(chatroomId)) {
-      this.buckets.set(chatroomId, {
-        tokens: this.config.initialTokens,
-        lastRefillAt: Date.now()
-      });
+    const existing = this.buckets.get(chatroomId);
+    if (existing) {
+      return existing;
     }
-    return this.buckets.get(chatroomId);
+    const bucket = {
+      tokens: this.config.initialTokens,
+      lastRefillAt: Date.now()
+    };
+    this.buckets.set(chatroomId, bucket);
+    return bucket;
   }
   _refill(bucket) {
     const now = Date.now();
@@ -87959,6 +88850,432 @@ var init_task_monitor_logic = __esm(() => {
   init_predicates();
 });
 
+// src/infrastructure/incremental-sync/working-snapshot.ts
+class WorkingSnapshot {
+  opts;
+  rows = new Map;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  replaceAll(rows) {
+    this.rows.clear();
+    for (const row of rows) {
+      this.rows.set(this.opts.rowKey(row), row);
+    }
+  }
+  getByKey(key) {
+    return this.rows.get(key);
+  }
+  getBySignal(signal) {
+    return this.rows.get(this.opts.signalKey(signal));
+  }
+  mergeSignal(signal) {
+    const key = this.opts.signalKey(signal);
+    const merged = this.opts.mergeSignal(this.rows.get(key), signal);
+    if (!merged) {
+      return;
+    }
+    this.rows.set(key, merged);
+    return merged;
+  }
+}
+
+// src/commands/machine/daemon-start/task-monitor-snapshot.ts
+function taskSnapshotKey(taskId, role) {
+  return `${taskId}:${role}`;
+}
+function mergeSignalIntoTaskSnapshot(existing, signal) {
+  if (!existing) {
+    return;
+  }
+  return {
+    ...existing,
+    status: signal.status,
+    agentConfig: {
+      ...existing.agentConfig,
+      spawnedAgentPid: signal.spawnedAgentPid ?? existing.agentConfig.spawnedAgentPid,
+      desiredState: signal.desiredState ?? existing.agentConfig.desiredState
+    },
+    participant: {
+      lastSeenAction: signal.lastSeenAction ?? existing.participant?.lastSeenAction ?? null,
+      lastSeenAt: existing.participant?.lastSeenAt ?? null,
+      lastStatus: existing.participant?.lastStatus ?? null
+    }
+  };
+}
+function createTaskMonitorSnapshot() {
+  return new WorkingSnapshot(taskMonitorSnapshotOptions);
+}
+var taskMonitorSnapshotOptions;
+var init_task_monitor_snapshot = __esm(() => {
+  taskMonitorSnapshotOptions = {
+    rowKey: (row) => taskSnapshotKey(row.taskId, row.agentConfig.role),
+    signalKey: (signal) => taskSnapshotKey(signal.taskId, signal.role),
+    mergeSignal: mergeSignalIntoTaskSnapshot
+  };
+});
+
+// src/infrastructure/incremental-sync/layers.ts
+var IntervalClock, IntervalClockLive;
+var init_layers = __esm(() => {
+  init_esm();
+  IntervalClock = class IntervalClock extends exports_Context.Tag("IntervalClock")() {
+  };
+  IntervalClockLive = exports_Layer.succeed(IntervalClock, {
+    sleep: (ms) => exports_Effect.promise(() => new Promise((resolve5) => setTimeout(resolve5, ms)))
+  });
+});
+
+// src/infrastructure/incremental-sync/message-buffer.ts
+class MessageBuffer {
+  keyOf;
+  queue = [];
+  inBuffer = new Set;
+  inFlight = new Map;
+  recentlyAcked = new Map;
+  dedupe;
+  dedupeTtlMs;
+  maxSize;
+  constructor(config3, keyOf) {
+    this.keyOf = keyOf;
+    this.dedupe = config3.dedupe ?? true;
+    this.dedupeTtlMs = config3.dedupeTtlMs ?? 0;
+    this.maxSize = config3.maxSize;
+  }
+  enqueue(items) {
+    this.pruneRecentlyAcked();
+    let enqueued = 0;
+    for (const item of items) {
+      const key = this.keyOf(item);
+      if (this.dedupe && this.shouldSkip(key)) {
+        continue;
+      }
+      this.queue.push({ key, item });
+      this.inBuffer.add(key);
+      enqueued++;
+    }
+    if (enqueued > 0) {
+      this.queue.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+    }
+    this.enforceMaxSize();
+    return enqueued;
+  }
+  dequeue() {
+    this.pruneRecentlyAcked();
+    const next4 = this.queue.shift();
+    if (!next4)
+      return;
+    this.inBuffer.delete(next4.key);
+    this.inFlight.set(next4.key, next4.item);
+    return next4.item;
+  }
+  ack(key) {
+    this.inFlight.delete(key);
+    if (this.dedupe) {
+      this.recentlyAcked.set(key, Date.now());
+    }
+  }
+  nack(key, requeue = false) {
+    const item = this.inFlight.get(key);
+    this.inFlight.delete(key);
+    if (requeue && item !== undefined) {
+      this.enqueue([item]);
+    }
+  }
+  size() {
+    return this.queue.length;
+  }
+  highKeyOf(items) {
+    if (items.length === 0)
+      return null;
+    let high = null;
+    for (const item of items) {
+      const key = this.keyOf(item);
+      if (high === null || key > high) {
+        high = key;
+      }
+    }
+    return high;
+  }
+  shouldSkip(key) {
+    if (this.inBuffer.has(key) || this.inFlight.has(key)) {
+      return true;
+    }
+    if (this.dedupeTtlMs > 0) {
+      const ackedAt = this.recentlyAcked.get(key);
+      if (ackedAt !== undefined && Date.now() - ackedAt < this.dedupeTtlMs) {
+        return true;
+      }
+    } else if (this.recentlyAcked.has(key)) {
+      return true;
+    }
+    return false;
+  }
+  pruneRecentlyAcked() {
+    if (this.dedupeTtlMs <= 0)
+      return;
+    const now = Date.now();
+    for (const [key, ackedAt] of this.recentlyAcked) {
+      if (now - ackedAt >= this.dedupeTtlMs) {
+        this.recentlyAcked.delete(key);
+      }
+    }
+  }
+  enforceMaxSize() {
+    while (this.queue.length > this.maxSize) {
+      const dropped = this.queue.shift();
+      if (dropped) {
+        this.inBuffer.delete(dropped.key);
+        console.warn(`[incremental-sync] Buffer full — dropped oldest unacked item (key=${dropped.key})`);
+      }
+    }
+  }
+}
+
+// src/infrastructure/incremental-sync/resolve-high-key.ts
+function resolveHighKey(def, buffer, page) {
+  if (page.highKey !== null)
+    return page.highKey;
+  const fromItems = buffer.highKeyOf(page.items);
+  if (fromItems !== null)
+    return fromItems;
+  if (def.itemToKey && page.items.length > 0) {
+    let high = null;
+    for (const item of page.items) {
+      const key = def.itemToKey(item);
+      if (high === null || key > high)
+        high = key;
+    }
+    return high;
+  }
+  return null;
+}
+
+// src/infrastructure/incremental-sync/subscribe-loop.ts
+function startSubscribeLoop(opts) {
+  let afterKey = opts.initialAfterKey ?? null;
+  let stopped = false;
+  let unsubscribe;
+  let drainInFlight = false;
+  const subscribe = () => {
+    if (stopped)
+      return;
+    unsubscribe?.();
+    unsubscribe = opts.wsClient.onUpdate(opts.target.query, opts.target.buildArgs(opts.args, afterKey, opts.config.limit), (result) => {
+      if (stopped)
+        return;
+      const page = opts.target.parsePage(result);
+      drainPages(page);
+    }, (err) => {
+      opts.onError?.(err);
+    });
+  };
+  const fetchPage = async (cursor) => {
+    const result = await opts.wsClient.query(opts.target.query, opts.target.buildArgs(opts.args, cursor, opts.config.limit));
+    return opts.target.parsePage(result);
+  };
+  const drainPages = async (initialPage) => {
+    if (stopped || drainInFlight)
+      return;
+    drainInFlight = true;
+    try {
+      const cursorAtStart = afterKey;
+      let page = initialPage;
+      while (!stopped && page.items.length > 0) {
+        opts.buffer.enqueue(page.items);
+        const nextKey = resolveHighKey(opts.def, opts.buffer, page);
+        if (nextKey === null) {
+          break;
+        }
+        afterKey = nextKey;
+        if (!page.hasMore) {
+          break;
+        }
+        page = await fetchPage(afterKey);
+      }
+      if (!stopped && afterKey !== cursorAtStart) {
+        subscribe();
+      }
+    } catch (err) {
+      opts.onError?.(err);
+    } finally {
+      drainInFlight = false;
+    }
+  };
+  subscribe();
+  return {
+    stop: () => {
+      stopped = true;
+      unsubscribe?.();
+      unsubscribe = undefined;
+    },
+    getAfterKey: () => afterKey
+  };
+}
+var init_subscribe_loop = () => {};
+
+// src/infrastructure/incremental-sync/feed-runtime.ts
+function runWorkerLoop(feedName, buffer, keyOf, onItem) {
+  return exports_Effect.gen(function* () {
+    while (true) {
+      const item = buffer.dequeue();
+      if (item === undefined) {
+        yield* exports_Effect.sleep("10 millis");
+        continue;
+      }
+      const key = keyOf(item);
+      const ctx = {
+        item,
+        feedName,
+        ack: () => buffer.ack(key),
+        nack: (opts) => buffer.nack(key, opts?.requeue ?? false)
+      };
+      yield* onItem(ctx).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    }
+  });
+}
+var runIncrementalSubscribeLive = (opts) => exports_Effect.gen(function* () {
+  const buffer = new MessageBuffer(opts.buffer, opts.def.itemKey);
+  const subscribeHandle = startSubscribeLoop({
+    wsClient: opts.wsClient,
+    target: opts.target,
+    args: opts.args,
+    buffer,
+    def: opts.def,
+    config: opts.subscribe,
+    initialAfterKey: opts.initialAfterKey ?? null,
+    onError: opts.onError
+  });
+  const workerFiber = yield* exports_Effect.forkDaemon(runWorkerLoop(opts.def.name, buffer, opts.def.itemKey, opts.onItem));
+  return {
+    buffer,
+    stop: () => exports_Effect.gen(function* () {
+      subscribeHandle.stop();
+      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));
+  };
+  const resolveRowForSignal = async (signal) => {
+    const merged = opts.snapshot.mergeSignal(signal);
+    if (merged) {
+      return merged;
+    }
+    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();
+    })
+  };
+});
+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 init_assigned_task_signals = __esm(() => {
+  init_api3();
+  assignedTaskSignalsFeedDef = {
+    name: "assigned-task-signals",
+    itemKey: (item) => item.revisionKey
+  };
+  assignedTaskSignalsSubscribeTarget = {
+    query: api.machines.subscribeAssignedTaskSignalsSince,
+    buildArgs: (args2, afterKey, limit) => ({
+      sessionId: args2.sessionId,
+      machineId: args2.machineId,
+      afterKey: afterKey ?? undefined,
+      limit
+    }),
+    parsePage: (result) => result
+  };
+  ASSIGNED_TASK_SIGNAL_FEED_BUFFER = {
+    maxSize: 200,
+    dedupe: true
+  };
+});
+
 // src/commands/machine/daemon-start/task-monitor.ts
 function resolveTaskWantResume(task) {
   return compressContextToWantResume(parseCompressContext(task.taskContent ?? ""));
@@ -87971,7 +89288,7 @@ function buildCliNudgeLogLine(task) {
   const wantResume = resolveTaskWantResume(task);
   return `[TaskMonitor] nudging ${role}@${chatroomId} — pending task ${task.taskId}, lastSeenAction=${lastSeenAction}, compress_context=${compressMode}, wantResume=${wantResume}`;
 }
-function resolveTaskRunnerContext(task) {
+function resolveTaskRunnerContextFromFull(task) {
   const { chatroomId, agentConfig } = task;
   const { role } = agentConfig;
   const workingDir = agentConfig.workingDir;
@@ -87986,7 +89303,7 @@ function resolveTaskRunnerContext(task) {
   };
 }
 function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
-  const ctx = resolveTaskRunnerContext(task);
+  const ctx = resolveTaskRunnerContextFromFull(task);
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
@@ -88004,7 +89321,7 @@ function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
   }).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) {
-  const ctx = resolveTaskRunnerContext(task);
+  const ctx = resolveTaskRunnerContextFromFull(task);
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
@@ -88021,63 +89338,124 @@ function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
     });
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native revive failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
+async function fetchTaskForAction(sessionDeps, machineId, snapshotRow) {
+  const result = await sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
+    sessionId: sessionDeps.sessionId,
+    machineId,
+    taskId: snapshotRow.taskId,
+    role: snapshotRow.agentConfig.role
+  });
+  return result;
+}
 function runCliNudgeEffect(task, runtime4, effectContext2, agentMgr) {
   console.log(buildCliNudgeLogLine(task));
   executeCliNudge(task, runtime4, effectContext2, agentMgr);
 }
-function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr) {
-  for (const task of listTasksReadyForNudge(tasks, now, cooldown)) {
-    runCliNudgeEffect(task, runtime4, effectContext2, agentMgr);
+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);
   }
 }
-function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr) {
-  for (const task of listNativeTasksNeedingRevive(tasks, localHealth, now, cooldown)) {
-    runNativeReviveEffect(task, runtime4, effectContext2, agentMgr);
+async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
+  for (const row of listNativeTasksNeedingRevive(tasks, localHealth, now, cooldown)) {
+    const full = await fetchTaskForAction(sessionDeps, machineId, row);
+    if (!full)
+      continue;
+    runNativeReviveEffect(full, runtime4, effectContext2, agentMgr);
   }
 }
-function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps) {
+async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, machineId, pass) {
+  if (tasks.length === 0)
+    return;
   const now = Date.now();
   const localHealth = {
     getSlot: (chatroomId, role) => agentMgr.getSlot(chatroomId, role),
     isPidAlive: (pid) => isProcessAlive((p) => process.kill(p, 0), pid)
   };
-  reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr);
+  await reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
     tasks,
     runtime: runtime4,
     effectContext: effectContext2,
     agentMgr,
-    sessionDeps
+    sessionDeps,
+    machineId
   });
-  nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr);
+  if (pass === "reconcile") {
+    await nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
+  }
 }
-var startTaskMonitorSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
+var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
   const effectContext2 = yield* exports_Effect.context();
   const runtime4 = yield* exports_Effect.runtime();
-  console.log(`[${formatTimestamp()}] \uD83D\uDCCB Starting task-monitor subscription (reactive)`);
+  console.log(`[${formatTimestamp()}] \uD83D\uDCCB Starting task-monitor (incremental subscribe)`);
   const cooldown = new NudgeCooldown;
+  const snapshot = createTaskMonitorSnapshot();
   let stopped = false;
+  let monitorPassInFlight = false;
   const sessionDeps = {
     sessionId: session2.sessionId,
     convexUrl: session2.convexUrl,
+    machineId: session2.machineId,
     backend: {
       mutation: (fn2, args2) => session2.backend.mutation(fn2, args2),
       query: (fn2, args2) => session2.backend.query(fn2, args2)
     }
   };
-  const onTasksUpdate = (result) => {
-    if (stopped || !result?.tasks?.length)
+  const runMonitorPass = (tasks, pass) => {
+    if (stopped || monitorPassInFlight || tasks.length === 0)
       return;
-    processTasksUpdate(result.tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps);
+    monitorPassInFlight = true;
+    processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, pass).finally(() => {
+      monitorPassInFlight = false;
+    });
   };
-  const unsubscribe = wsClient2.onUpdate(api.machines.getAssignedTasks, { sessionId: session2.sessionId, machineId: session2.machineId }, onTasksUpdate, (err) => console.warn(`[${formatTimestamp()}] Task-monitor subscription error: ${getErrorMessage(err)}`));
+  const queryReconcileSnapshots = () => session2.backend.query(api.machines.listAssignedTasksForReconcile, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId
+  });
+  const feedHandle = yield* runDualChannelFeedLive({
+    name: "assigned-tasks",
+    wsClient: wsClient2,
+    def: assignedTaskSignalsFeedDef,
+    target: assignedTaskSignalsSubscribeTarget,
+    args: {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId
+    },
+    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
+      });
+      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;
-      unsubscribe();
-      console.log(`[${formatTimestamp()}] \uD83D\uDCCB Task-monitor subscription stopped`);
+      exports_Effect.runPromise(feedHandle.stop());
+      console.log(`[${formatTimestamp()}] \uD83D\uDCCB Task-monitor stopped`);
     }
   };
 });
@@ -88087,7 +89465,10 @@ var init_task_monitor = __esm(() => {
   init_daemon_services();
   init_native_task_delivery_coordinator();
   init_task_monitor_logic();
+  init_task_monitor_snapshot();
   init_api3();
+  init_dual_channel_feed();
+  init_assigned_task_signals();
   init_convex_error();
 });
 
@@ -88290,6 +89671,11 @@ function handleRefreshCapabilitiesEffect(event, tracker) {
     })));
   });
 }
+function forkDaemonSyncBatch(runtime4, effectContext2, failureLabel) {
+  exports_Runtime.runFork(runtime4)(exports_Effect.all([pushGitStateEffect, pushCommandsEffect, syncCommitDetailsEffect()], {
+    concurrency: "unbounded"
+  }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️  ${failureLabel}: ${getErrorMessage(err)}`)))));
+}
 var GIT_PUSH_ACTIONS, commandEventHandlers, dispatchCommandEventEffect = (event, tracker) => {
   const factory2 = commandEventHandlers[event.type];
   return factory2 != null ? factory2(event, tracker) : exports_Effect.void;
@@ -88348,9 +89734,7 @@ var init_command_loop = __esm(() => {
         heartbeatCount++;
         console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
         if (!observedSyncEnabled) {
-          exports_Runtime.runFork(runtime4)(exports_Effect.all([pushGitStateEffect, pushCommandsEffect, syncCommitDetailsEffect()], {
-            concurrency: "unbounded"
-          }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️  Heartbeat sync failed: ${getErrorMessage(err)}`)))));
+          forkDaemonSyncBatch(runtime4, effectContext2, "Heartbeat sync failed");
         }
       }).catch((err) => {
         console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${getErrorMessage(err)}`);
@@ -88367,14 +89751,13 @@ var init_command_loop = __esm(() => {
     let pendingHarnessSessionSubscriptionHandle = null;
     let commandSubscriptionHandle = null;
     let lifecycleManager = null;
+    let closeDirectHarnessSessionsOnShutdown = null;
     const activeSessions = new Map;
     const harnesses = new Map;
     if (observedSyncEnabled) {
       console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync enabled, skipping immediate push`);
     } else {
-      exports_Runtime.runFork(runtime4)(exports_Effect.all([pushGitStateEffect, pushCommandsEffect, syncCommitDetailsEffect()], {
-        concurrency: "unbounded"
-      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️ Startup sync failed: ${getErrorMessage(err)}`)))));
+      forkDaemonSyncBatch(runtime4, effectContext2, "Startup sync failed");
     }
     const PROCESS_KILL_TIMEOUT_MS = 6000;
     const CLOSE_TIMEOUT_MS = 3000;
@@ -88442,8 +89825,12 @@ var init_command_loop = __esm(() => {
       await withTimeout2(exports_Effect.runPromise(onDaemonShutdownEffect.pipe(exports_Effect.provide(effectContext2))), PROCESS_KILL_TIMEOUT_MS);
     };
     const closeAllSessionsAndHarnesses = async () => {
-      for (const handle of activeSessions.values()) {
-        await withTimeout2(handle.close(), CLOSE_TIMEOUT_MS);
+      if (closeDirectHarnessSessionsOnShutdown) {
+        await withTimeout2(closeDirectHarnessSessionsOnShutdown(), PROCESS_KILL_TIMEOUT_MS);
+      } else {
+        for (const handle of activeSessions.values()) {
+          await withTimeout2(handle.close(), CLOSE_TIMEOUT_MS);
+        }
       }
       for (const harness of harnesses.values()) {
         await withTimeout2(harness.close(), CLOSE_TIMEOUT_MS);
@@ -88473,7 +89860,7 @@ var init_command_loop = __esm(() => {
     if (observedSyncEnabled) {
       observedSyncSubscriptionHandle = yield* startObservedSyncSubscriptionEffect(wsClient2);
     }
-    const taskMonitorHandle = yield* startTaskMonitorSubscriptionEffect(wsClient2);
+    const taskMonitorHandle = yield* startTaskMonitorEffect(wsClient2);
     logObserverSubscriptionHandle = startLogObserverSubscription({ sessionId: session2.sessionId, machineId: session2.machineId }, wsClient2);
     if (featureFlags.directHarnessWorkers) {
       const handles = startDirectHarnessSubscriptions({
@@ -88486,6 +89873,7 @@ var init_command_loop = __esm(() => {
       pendingHarnessSessionSubscriptionHandle = handles.pendingHarnessSessionSubscriptionHandle;
       commandSubscriptionHandle = handles.commandSubscriptionHandle;
       lifecycleManager = handles.lifecycleManager;
+      closeDirectHarnessSessionsOnShutdown = handles.closeSessionsOnShutdown;
     }
     console.log(`
 Listening for commands...`);
@@ -88672,8 +90060,8 @@ import * as os2 from "os";
 import * as path4 from "path";
 async function isChatroomInstalledDefault() {
   try {
-    const { execSync: execSync2 } = await import("child_process");
-    execSync2("chatroom --version", { stdio: "pipe" });
+    const { execSync: execSync3 } = await import("child_process");
+    execSync3("chatroom --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -89587,4 +90975,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=4A0FE03BEB3CACE864756E2164756E21
+//# debugId=00A3989CD8BAD93D64756E2164756E21