@schoolai/shipyard 3.2.0 → 3.2.1-rc.20260421.0

package/dist/{serve-3EFFP3PN.js → serve-P5WC5JIT.js}

@@ -4,10 +4,11 @@ import {
   appendTrailerToMessage,
   emitCommitAttributed,
   emitPrAttributed,
+  emitPrMerged,
   emitTaskEnded,
   emitTaskStarted,
   hasShipyardTrailer
-} from "./chunk-FD2QK7IN.js";
+} from "./chunk-DKMDBOFU.js";
 import {
   AuthGitHubCallbackRequestSchema,
   AuthGitHubCallbackResponseSchema,
@@ -46,7 +47,7 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-5SJBSLGT.js";
+} from "./chunk-FMMRZTOF.js";
 import "./chunk-EHQITHQX.js";
 import {
   loadAuthToken
@@ -82,7 +83,7 @@ import {
 } from "./chunk-2H7UOFLK.js";
 
 // src/services/serve.ts
-import { mkdir as mkdir24 } from "fs/promises";
+import { mkdir as mkdir24, realpath as realpath2 } from "fs/promises";
 import { join as join55 } from "path";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -27123,7 +27124,10 @@ var MessageSchema = external_exports.object({
   reasoningEffort: ReasoningEffortSchema.nullable().optional(),
   permissionMode: PermissionModeSchema2.nullable().optional(),
   isSynthetic: external_exports.boolean().optional(),
-  anchorToolUseId: external_exports.string().optional()
+  anchorToolUseId: external_exports.string().optional(),
+  correlationId: external_exports.string().optional(),
+  batchCorrelationIds: external_exports.array(external_exports.string()).optional(),
+  sdkUuid: external_exports.string().optional()
 });
 var ChannelSchema = external_exports.object({
   id: external_exports.string(),
@@ -27286,9 +27290,14 @@ var TaskRecordSchema = external_exports.object({
   abandonedAt: external_exports.number().nullable().optional(),
   lastPlanDetection: PlanDetectionSchema.optional(),
   lastActivityAt: external_exports.number().default(0),
-  appliedTemplateId: external_exports.string().optional()
+  appliedTemplateId: external_exports.string().optional(),
+  roiStartedEmitted: external_exports.boolean().default(false),
+  totalTurnCount: external_exports.number().int().nonnegative().default(0),
+  mergedAt: external_exports.number().int().positive().nullable().default(null),
+  attributedCommitShas: external_exports.array(external_exports.string()).max(50).default([]),
+  lastCommitScanSha: external_exports.string().nullable().default(null)
 });
-var TASK_STORE_VERSION = 10;
+var TASK_STORE_VERSION = 11;
 var TaskStoreSchema = external_exports.object({
   schemaVersion: external_exports.number(),
   tasks: external_exports.record(external_exports.string(), TaskRecordSchema)
@@ -27305,6 +27314,9 @@ function migrateTaskStore(raw) {
   if (version < 10) {
     backfillLastActivityAt(prop(raw, "tasks"));
   }
+  if (version < 11) {
+    backfillRoiStartedEmitted(prop(raw, "tasks"));
+  }
   return TaskStoreSchema.parse({ ...raw, schemaVersion: TASK_STORE_VERSION });
 }
 function backfillLastActivityAt(tasksRaw) {
@@ -27322,6 +27334,23 @@ function backfillLastActivityAt(tasksRaw) {
     Object.assign(record, { lastActivityAt: fallback });
   }
 }
+function backfillRoiStartedEmitted(tasksRaw) {
+  if (typeof tasksRaw !== "object" || tasksRaw === null)
+    return;
+  const alreadyRanStatuses = /* @__PURE__ */ new Set(["in_progress", "input_required", "completed", "canceled"]);
+  for (const record of Object.values(tasksRaw)) {
+    if (typeof record !== "object" || record === null)
+      continue;
+    const existing = prop(record, "roiStartedEmitted");
+    if (existing === true)
+      continue;
+    const taskStartedAt = prop(record, "taskStartedAt");
+    const status = prop(record, "status");
+    if (taskStartedAt != null || typeof status === "string" && alreadyRanStatuses.has(status)) {
+      Object.assign(record, { roiStartedEmitted: true });
+    }
+  }
+}
 var TemplateItemSchema = external_exports.object({
   id: external_exports.string(),
   content: external_exports.string(),
@@ -27584,6 +27613,7 @@ var CheckpointFileEntrySchema = external_exports.object({
 var BrowserToDaemonMessageSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({
     type: external_exports.literal("send_message"),
+    correlationId: external_exports.string(),
     content: external_exports.array(ContentBlockSchema),
     model: external_exports.string().optional(),
     reasoningEffort: ReasoningEffortSchema.optional(),
@@ -27595,7 +27625,8 @@ var BrowserToDaemonMessageSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({
     type: external_exports.literal("subscribe"),
     sinceSeqNo: external_exports.number(),
-    maxMessages: external_exports.number().int().positive().optional()
+    maxMessages: external_exports.number().int().positive().optional(),
+    inFlightCorrelationIds: external_exports.array(external_exports.string()).optional()
   }),
   external_exports.object({ type: external_exports.literal("cancel_queued") }),
   external_exports.object({
@@ -27662,6 +27693,19 @@ var DaemonToBrowserMessageSchema = external_exports.discriminatedUnion("type", [
     type: external_exports.literal("older_messages"),
     messages: external_exports.array(MessageSchema),
     hasMore: external_exports.boolean()
+  }),
+  external_exports.object({
+    type: external_exports.literal("send_message_ack"),
+    correlationId: external_exports.string(),
+    stage: external_exports.enum(["accepted", "persisted", "forwarded", "confirmed", "rejected"]),
+    error: external_exports.string().optional()
+  }),
+  external_exports.object({
+    type: external_exports.literal("correlation_status_snapshot"),
+    entries: external_exports.array(external_exports.object({
+      correlationId: external_exports.string(),
+      status: external_exports.enum(["unknown", "persisted", "forwarded", "confirmed", "rejected"])
+    }))
   })
 ]);
 var PermissionRequestPayloadSchema = external_exports.object({
@@ -27757,7 +27801,8 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
   }),
   external_exports.object({
     type: external_exports.literal("update_settings"),
-    settings: DaemonSettingsSchema
+    settings: DaemonSettingsSchema,
+    correlationId: external_exports.string().optional()
   }),
   external_exports.object({
     type: external_exports.literal("update_task_settings"),
@@ -28067,7 +28112,8 @@ var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("t
   external_exports.object({
     type: external_exports.literal("settings_ack"),
     settings: DaemonSettingsSchema,
-    taskId: external_exports.string().optional()
+    taskId: external_exports.string().optional(),
+    correlationId: external_exports.string().optional()
   }),
   external_exports.object({
     type: external_exports.literal("enhance_prompt_chunk"),
@@ -28375,6 +28421,15 @@ var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("t
   external_exports.object({ type: external_exports.literal("template_list"), templates: external_exports.array(TaskTemplateRecordSchema) }),
   external_exports.object({ type: external_exports.literal("template_updated"), template: TaskTemplateRecordSchema }),
   external_exports.object({ type: external_exports.literal("template_deleted"), templateId: external_exports.string() }),
+  external_exports.object({
+    type: external_exports.literal("task_created_ack"),
+    taskId: external_exports.string(),
+    templateId: external_exports.string().nullable(),
+    appliedTemplate: external_exports.object({
+      templateId: external_exports.string(),
+      todos: external_exports.array(external_exports.object({ id: external_exports.string(), content: external_exports.string(), deps: external_exports.array(external_exports.string()) }))
+    }).nullable()
+  }),
   external_exports.object({
     type: external_exports.literal("review_comment"),
     taskId: external_exports.string(),
@@ -28684,7 +28739,11 @@ var DaemonToFileIOMessageSchema = external_exports.discriminatedUnion("type", [
   }),
   external_exports.object({ type: external_exports.literal("git_stage_result"), requestId: external_exports.string() }),
   external_exports.object({ type: external_exports.literal("git_unstage_result"), requestId: external_exports.string() }),
-  external_exports.object({ type: external_exports.literal("set_cwd_ack"), requestId: external_exports.string() }),
+  external_exports.object({
+    type: external_exports.literal("set_cwd_ack"),
+    requestId: external_exports.string(),
+    canonical: external_exports.string().optional()
+  }),
   external_exports.object({
     type: external_exports.literal("git_diff_turn_result"),
     requestId: external_exports.string(),
@@ -31391,7 +31450,7 @@ function nanoid(size2 = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.2.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.2.1" : "unknown";
 function createDaemonSignaling(config2) {
   const agentId = config2.agentId ?? nanoid();
   function send(msg) {
@@ -35103,7 +35162,10 @@ async function rehydrateFromPersistence(persistence, taskManager, log, taskState
           initialTurnStats: record?.lastTurnStats,
           initialTokenCount: record?.lastTokenCount,
           initialPlanDetection: record?.lastPlanDetection,
-          mode: record?.mode
+          mode: record?.mode,
+          initialRoiStartedEmitted: record?.roiStartedEmitted ?? false,
+          taskCreatedAt: record?.createdAt ?? Date.now(),
+          initialTurnCount: record?.totalTurnCount ?? 0
         });
         log({ event: "task_restored", taskId: action.taskId, kind: "resumable" });
         break;
@@ -35120,6 +35182,50 @@ async function rehydrateFromPersistence(persistence, taskManager, log, taskState
     }
   }
 }
+async function applyMainQueueRehydrate(taskId, orchestrator, log) {
+  let claimedByCollab = /* @__PURE__ */ new Set();
+  try {
+    claimedByCollab = await orchestrator.rehydrateCollabQueue();
+    log({ event: "collab_queue_rehydrate_applied", taskId });
+  } catch (err) {
+    log({
+      event: "collab_queue_rehydrate_failed",
+      taskId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  try {
+    const count = await orchestrator.rehydrateUnpushedMessages(claimedByCollab);
+    if (count > 0) {
+      log({ event: "unpushed_messages_rehydrate_applied", taskId, count });
+    }
+  } catch (err) {
+    log({
+      event: "unpushed_messages_rehydrate_failed",
+      taskId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function applyThreadQueueRehydrate(key, taskId, threadId, orchestrator, persistence, log) {
+  try {
+    const found2 = await orchestrator.rehydrateThreadQueue(threadId);
+    if (found2) {
+      log({ event: "collab_queue_thread_rehydrate_applied", taskId, threadId });
+    } else {
+      await persistence.clear(key).catch(() => {
+      });
+      log({ event: "collab_queue_thread_rehydrate_orphan_cleared", taskId, threadId });
+    }
+  } catch (err) {
+    log({
+      event: "collab_queue_thread_rehydrate_failed",
+      taskId,
+      threadId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 async function rehydrateCollabQueues(persistence, taskManager, log) {
   await persistence.cleanupOrphanTmpFiles().catch(() => {
   });
@@ -35127,12 +35233,6 @@ async function rehydrateCollabQueues(persistence, taskManager, log) {
   if (keys3.length === 0) return;
   for (const key of keys3) {
     const parsed = parseQueueKey(key);
-    if (parsed.kind !== "main") {
-      await persistence.clear(key).catch(() => {
-      });
-      log({ event: "collab_queue_thread_rehydrate_skipped", key });
-      continue;
-    }
     const orchestrator = taskManager.getOrchestrator(parsed.taskId);
     if (!orchestrator) {
       await persistence.clear(key).catch(() => {
@@ -35140,15 +35240,17 @@ async function rehydrateCollabQueues(persistence, taskManager, log) {
       log({ event: "collab_queue_rehydrate_skipped", taskId: parsed.taskId, reason: "no_task" });
       continue;
     }
-    try {
-      await orchestrator.rehydrateCollabQueue();
-      log({ event: "collab_queue_rehydrate_applied", taskId: parsed.taskId });
-    } catch (err) {
-      log({
-        event: "collab_queue_rehydrate_failed",
-        taskId: parsed.taskId,
-        error: err instanceof Error ? err.message : String(err)
-      });
+    if (parsed.kind === "main") {
+      await applyMainQueueRehydrate(parsed.taskId, orchestrator, log);
+    } else {
+      await applyThreadQueueRehydrate(
+        key,
+        parsed.taskId,
+        parsed.threadId,
+        orchestrator,
+        persistence,
+        log
+      );
     }
   }
 }
@@ -69677,6 +69779,7 @@ async function runAbandonedSweep(deps) {
     try {
       await deps.setAbandonedAt(taskId, now);
       markedAbandoned.push(taskId);
+      deps.onTaskAbandoned(taskId, task, now);
     } catch (err) {
       deps.log?.({
         event: "abandoned_sweep_mark_failed",
@@ -69716,6 +69819,222 @@ function createAbandonedSweeper(deps, intervalMs = ABANDONED_SWEEP_INTERVAL_MS)
   };
 }
 
+// src/services/roi/inject-shipyard-trailer.ts
+function buildDefaultTrailerInjectDeps() {
+  return {
+    readCommitMessage: async (cwd) => runWithTimeout("git", ["log", "-1", "--pretty=%B"], cwd, 5e3),
+    amendCommit: async (cwd, message) => {
+      await runWithTimeout("git", ["commit", "--amend", "--no-edit", "-m", message], cwd, 15e3);
+    },
+    getHeadSha: async (cwd) => (await runWithTimeout("git", ["rev-parse", "HEAD"], cwd, 5e3)).trim(),
+    getCurrentBranch: async (cwd) => (await runWithTimeout("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd, 5e3)).trim(),
+    getRepoSlug: async (cwd) => {
+      const url = (await runWithTimeout("git", ["config", "--get", "remote.origin.url"], cwd, 5e3).catch(
+        () => ""
+      )).trim();
+      const match2 = url.match(/[:/]([^/:]+\/[^/:]+?)(\.git)?\s*$/);
+      return match2?.[1] ?? "";
+    }
+  };
+}
+async function injectShipyardTrailer(ctx, deps) {
+  const original = await deps.readCommitMessage(ctx.cwd);
+  if (hasShipyardTrailer(original)) {
+    return { injected: false, reason: "already_trailered" };
+  }
+  const newMessage = appendTrailerToMessage(original, ctx.trailer);
+  await deps.amendCommit(ctx.cwd, newMessage);
+  const [commitSha, branch, repo] = await Promise.all([
+    deps.getHeadSha(ctx.cwd),
+    deps.getCurrentBranch(ctx.cwd),
+    deps.getRepoSlug(ctx.cwd)
+  ]);
+  return { injected: true, commitSha, branch, repo };
+}
+
+// src/services/roi/commit-sweep.ts
+async function fetchCurrentHead(cwd) {
+  return (await runWithTimeout("git", ["rev-parse", "HEAD"], cwd, 5e3)).trim();
+}
+async function fetchCommits(cwd, lastSeenSha) {
+  let args;
+  if (lastSeenSha) {
+    const inHistory = await runWithTimeout("git", ["cat-file", "-t", lastSeenSha], cwd, 5e3).then(
+      (t) => t.trim() === "commit",
+      () => false
+    );
+    if (inHistory) {
+      args = ["log", `${lastSeenSha}..HEAD`, "--pretty=%H%n%B%x00", "--reverse"];
+    } else {
+      args = ["log", "HEAD", "--since=5 minutes ago", "--pretty=%H%n%B%x00", "--reverse"];
+    }
+  } else {
+    args = ["log", "HEAD", "--since=5 minutes ago", "--pretty=%H%n%B%x00", "--reverse"];
+  }
+  const raw = await runWithTimeout("git", args, cwd, 1e4);
+  if (!raw) return [];
+  return raw.split("\0").map((chunk) => chunk.trim()).filter(Boolean).map((chunk) => {
+    const newlineIdx = chunk.indexOf("\n");
+    if (newlineIdx === -1) return { sha: chunk.trim(), message: "" };
+    const sha = chunk.slice(0, newlineIdx).trim();
+    const message = chunk.slice(newlineIdx + 1).trim();
+    return { sha, message };
+  }).filter((c) => Boolean(c.sha));
+}
+async function handleHeadCommit(commit, input, deps) {
+  const { cwd, taskId, userId } = input;
+  const { sha } = commit;
+  const payload = deps.getAttributionPayload(taskId);
+  if (!payload) return;
+  const trailer = {
+    version: TRAILER_SCHEMA_VERSION,
+    taskId,
+    sessionId: payload.sessionId,
+    model: payload.model,
+    tokens: payload.tokens,
+    costUsd: payload.costUsd,
+    turnCount: payload.turnCount,
+    attributionType: "originated",
+    clientVersion: "shipyard-daemon"
+  };
+  try {
+    const result = await deps.injectTrailer({ cwd, trailer }, buildDefaultTrailerInjectDeps());
+    if (!result.injected) {
+      if (result.reason !== "already_trailered") {
+        deps.log({ event: "roi_trailer_not_injected", taskId, sha, reason: result.reason });
+      }
+      await deps.addAttributedCommitSha(taskId, sha);
+      return;
+    }
+    const newSha = result.commitSha;
+    if (newSha && result.repo && result.branch) {
+      emitCommitAttributed(deps.metricsCollector, {
+        taskId,
+        userId,
+        commitSha: newSha,
+        repo: result.repo,
+        branch: result.branch,
+        model: trailer.model,
+        tokens: trailer.tokens,
+        costUsd: trailer.costUsd,
+        turnCount: trailer.turnCount,
+        attributionType: "originated"
+      });
+      await deps.addAttributedCommitSha(taskId, newSha);
+    }
+  } catch (err) {
+    deps.log({
+      event: "roi_trailer_injection_failed",
+      taskId,
+      sha,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function handleNonHeadCommit(commit, input, deps) {
+  const { cwd, taskId, userId } = input;
+  const { sha } = commit;
+  const payload = deps.getAttributionPayload(taskId);
+  if (!payload) {
+    deps.log({ event: "roi_scan_skip_no_payload", taskId, sha });
+    return;
+  }
+  const injectDeps = buildDefaultTrailerInjectDeps();
+  try {
+    const [branch, repo] = await Promise.all([
+      injectDeps.getCurrentBranch(cwd),
+      injectDeps.getRepoSlug(cwd)
+    ]);
+    emitCommitAttributed(deps.metricsCollector, {
+      taskId,
+      userId,
+      commitSha: sha,
+      repo,
+      branch,
+      model: payload.model,
+      tokens: payload.tokens,
+      costUsd: payload.costUsd,
+      turnCount: payload.turnCount,
+      attributionType: "extended"
+    });
+    await deps.addAttributedCommitSha(taskId, sha);
+  } catch (err) {
+    deps.log({
+      event: "roi_extended_attribution_failed",
+      taskId,
+      sha,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function scanAndAttributeCommits(input, deps) {
+  const { cwd, taskId, lastSeenSha, attributedCommitShas } = input;
+  const [commits, headSha] = await Promise.all([
+    fetchCommits(cwd, lastSeenSha),
+    fetchCurrentHead(cwd)
+  ]);
+  if (commits.length === 0) {
+    if (headSha !== lastSeenSha) {
+      await deps.setLastCommitScanSha(taskId, headSha);
+    }
+    return;
+  }
+  for (const commit of commits) {
+    const { sha, message } = commit;
+    if (hasShipyardTrailer(message)) continue;
+    if (attributedCommitShas.includes(sha)) continue;
+    if (sha === headSha && deps.amendHead) {
+      await handleHeadCommit(commit, input, deps);
+    } else {
+      await handleNonHeadCommit(commit, input, deps);
+    }
+  }
+  await deps.setLastCommitScanSha(taskId, headSha);
+}
+var CommitSweepService = class {
+  #deps;
+  #intervalMs;
+  #timer = null;
+  constructor(deps, intervalMs = 6e4) {
+    this.#deps = deps;
+    this.#intervalMs = intervalMs;
+  }
+  start() {
+    if (this.#timer) return;
+    this.#timer = setInterval(() => {
+      this.#runSweep().catch((err) => {
+        this.#deps.log({
+          event: "commit_sweep_failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }, this.#intervalMs);
+    this.#timer.unref?.();
+  }
+  stop() {
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+  }
+  async #runSweep() {
+    const tasks = this.#deps.getActiveTasks();
+    for (const { taskId, cwd, userId } of tasks) {
+      const attribution = await this.#deps.getTaskAttribution(taskId);
+      await scanAndAttributeCommits(
+        {
+          cwd,
+          taskId,
+          userId: attribution.userId || userId,
+          lastSeenSha: attribution.lastSeenSha,
+          attributedCommitShas: attribution.attributedCommitShas
+        },
+        this.#deps
+      );
+    }
+  }
+};
+
 // ../../node_modules/.pnpm/croner@10.0.1/node_modules/croner/dist/croner.js
 function T(s2) {
   return Date.UTC(s2.y, s2.m - 1, s2.d, s2.h, s2.i, s2.s);
@@ -81033,6 +81352,50 @@ function buildJsonlConversationStore(dataDir) {
     }
     return messages;
   }
+  function contentFingerprint(message) {
+    const texts = message.content.filter((b2) => b2.type === "text").map((b2) => b2.type === "text" ? b2.text : "").join("\0");
+    return `${message.participantId}
${texts}`;
+  }
+  function lookupByCorrelationId(existing, correlationId) {
+    return existing.find((m2) => m2.senderKind === "human" && m2.correlationId === correlationId);
+  }
+  function lookupBySdkUuid(existing, sdkUuid) {
+    return existing.find((m2) => m2.senderKind === "human" && m2.sdkUuid === sdkUuid);
+  }
+  function lookupByFingerprint(existing, fingerprint, windowStart) {
+    return existing.find(
+      (m2) => m2.senderKind === "human" && !m2.correlationId && !m2.sdkUuid && m2.timestamp >= windowStart && contentFingerprint(m2) === fingerprint
+    );
+  }
+  function decideDedupByCorrelation(existing, message) {
+    if (!message.correlationId) return null;
+    const found2 = lookupByCorrelationId(existing, message.correlationId);
+    if (!found2) return null;
+    return { kind: "duplicate", seqNo: found2.seqNo, dedupKey: `corr:${message.correlationId}` };
+  }
+  function decideDedupBySdkUuid(existing, message) {
+    if (!message.sdkUuid) return null;
+    const found2 = lookupBySdkUuid(existing, message.sdkUuid);
+    if (!found2) return null;
+    return { kind: "duplicate", seqNo: found2.seqNo, dedupKey: `sdk:${message.sdkUuid}` };
+  }
+  function decideDedupByFingerprint(existing, message, dedupWindowMs, now) {
+    if (message.correlationId || message.sdkUuid) return null;
+    const fingerprint = contentFingerprint(message);
+    const found2 = lookupByFingerprint(existing, fingerprint, now - dedupWindowMs);
+    if (!found2) return null;
+    return { kind: "duplicate", seqNo: found2.seqNo, dedupKey: `fp:${fingerprint}` };
+  }
+  function classifyDedupResult(existing, message, currentSeq, dedupWindowMs, now) {
+    const byCorr = decideDedupByCorrelation(existing, message);
+    if (byCorr) return byCorr;
+    const bySdk = decideDedupBySdkUuid(existing, message);
+    if (bySdk) return bySdk;
+    const byFp = decideDedupByFingerprint(existing, message, dedupWindowMs, now);
+    if (byFp) return byFp;
+    const seqNo = currentSeq !== void 0 ? currentSeq + 1 : existing.length;
+    return { kind: "append", seqNo };
+  }
   return {
     async appendMessage(message) {
       let resolveSeqNo;
@@ -81064,6 +81427,88 @@ function buildJsonlConversationStore(dataDir) {
       channelQueues.set(message.channelId, next);
       return seqNoPromise;
     },
+    async appendMessageDeduped(message, opts = {}) {
+      const DEDUP_WINDOW_MS = opts.dedupWindowMs ?? 6e4;
+      let resolveResult;
+      let rejectResult;
+      const resultPromise = new Promise((resolve4, reject) => {
+        resolveResult = resolve4;
+        rejectResult = reject;
+      });
+      const prev = channelQueues.get(message.channelId) ?? Promise.resolve();
+      const next = prev.then(async () => {
+        await ensureDir();
+        const existing = await readLines(message.channelId);
+        const currentSeq = seqCounters.get(message.channelId);
+        const decision = classifyDedupResult(
+          existing,
+          message,
+          currentSeq,
+          DEDUP_WINDOW_MS,
+          Date.now()
+        );
+        if (decision.kind === "duplicate") {
+          resolveResult({
+            seqNo: decision.seqNo,
+            isDuplicate: true,
+            dedupKey: decision.dedupKey
+          });
+          return;
+        }
+        seqCounters.set(message.channelId, decision.seqNo);
+        const { channelId: _channelId, ...rest } = message;
+        const line = JSON.stringify(rest);
+        await appendFile2(channelPath(message.channelId), `${line}
+`, "utf-8");
+        resolveResult({ seqNo: decision.seqNo, isDuplicate: false, dedupKey: null });
+      }).catch((err) => {
+        rejectResult(err);
+      });
+      channelQueues.set(message.channelId, next);
+      return resultPromise;
+    },
+    async stampSdkUuid(channelId, primaryCorrelationId, sdkUuid, batchCorrelationIds) {
+      let resolveVoid;
+      let rejectVoid;
+      const voidPromise = new Promise((resolve4, reject) => {
+        resolveVoid = resolve4;
+        rejectVoid = reject;
+      });
+      const prev = channelQueues.get(channelId) ?? Promise.resolve();
+      const next = prev.then(async () => {
+        const messages = await readLines(channelId);
+        const target = messages.find(
+          (m2) => m2.senderKind === "human" && m2.correlationId === primaryCorrelationId && !m2.sdkUuid
+        );
+        if (!target) {
+          resolveVoid();
+          return;
+        }
+        const secondaryIds = batchCorrelationIds && batchCorrelationIds.length > 0 ? batchCorrelationIds : void 0;
+        const lines = messages.map((m2) => {
+          const { seqNo: _seqNo, channelId: _channelId, ...rest } = m2;
+          if (m2.seqNo === target.seqNo) {
+            return JSON.stringify({
+              ...rest,
+              sdkUuid,
+              ...secondaryIds ? { batchCorrelationIds: secondaryIds } : {}
+            });
+          }
+          return JSON.stringify(rest);
+        });
+        const content = lines.length > 0 ? `${lines.join("\n")}
+` : "";
+        const filePath = channelPath(channelId);
+        const tmpPath = `${filePath}.tmp`;
+        await writeFile16(tmpPath, content, "utf-8");
+        await rename10(tmpPath, filePath);
+        resolveVoid();
+      }).catch((err) => {
+        rejectVoid(err);
+      });
+      channelQueues.set(channelId, next);
+      return voidPromise;
+    },
     async getMessages(channelId) {
       return readLines(channelId);
     },
@@ -81158,6 +81603,17 @@ function buildObservableConversationStore(inner) {
       notify(message.channelId, fullMessage);
       return seqNo;
     },
+    async appendMessageDeduped(message, opts) {
+      const result = await inner.appendMessageDeduped(message, opts);
+      if (!result.isDuplicate) {
+        const fullMessage = { ...message, seqNo: result.seqNo };
+        notify(message.channelId, fullMessage);
+      }
+      return result;
+    },
+    stampSdkUuid(channelId, correlationId, sdkUuid, batchCorrelationIds) {
+      return inner.stampSdkUuid(channelId, correlationId, sdkUuid, batchCorrelationIds);
+    },
     getMessages(channelId) {
       return inner.getMessages(channelId);
     },
@@ -81350,6 +81806,7 @@ function buildJsonDocumentStore(opts) {
         if (!existing) return;
         const parsed = recordSchema.parse(existing);
         const updated = fn(parsed);
+        if (updated === parsed) return;
         store.records[id] = updated;
         await atomicWrite3(store);
         notify({ kind: "set", id, data: updated });
@@ -81612,7 +82069,7 @@ var EVENT_BATCHING = {
   /** Resources: sliding window for file/plan/git/task pushes. */
   resources: { idleMs: 1e4, maxWindowMs: 6e4 },
   /** Messages: sliding window for collab message micro-batching. */
-  messages: { idleMs: 5e3, maxWindowMs: 3e4 }
+  messages: { idleMs: 250, maxWindowMs: 3e4 }
 };
 var MAX_COLLAB_BATCH_SIZE = 4;
 var SlidingWindowTimer = class {
@@ -81702,18 +82159,58 @@ function formatCollabBatch(batch) {
   for (const block2 of nonTextBlocks) result.push(block2);
   return result;
 }
+var IDLE_STATES = /* @__PURE__ */ new Set(["warm_idle", "resumable_idle", "cold_idle"]);
 var CollabMessageQueue = class {
   #deps;
   #slots = /* @__PURE__ */ new Map();
   #maxBatchSize;
   #disposed = false;
+  #unsubscribeThreadState = null;
   constructor(deps) {
     this.#deps = deps;
     this.#maxBatchSize = deps.maxBatchSize ?? MAX_COLLAB_BATCH_SIZE;
+    if (deps.subscribeToThreadState) {
+      this.#unsubscribeThreadState = deps.subscribeToThreadState((newState) => {
+        if (IDLE_STATES.has(newState)) {
+          this.onTurnComplete();
+        }
+      });
+    }
+  }
+  /**
+   * Wire Thread state-change notifications into this queue after construction.
+   *
+   * Use this when the Thread isn't available yet at queue-construction time
+   * (e.g., the main collab queue, which is created before `#mainThread`).
+   * Must be called at most once — subsequent calls are no-ops.
+   *
+   * On Thread transition to any idle state (`warm_idle`, `resumable_idle`,
+   * `cold_idle`), releases all slots blocked in `waiting_for_turn`.
+   */
+  wireThreadStateSubscription(subscribe2) {
+    if (this.#unsubscribeThreadState) return;
+    this.#unsubscribeThreadState = subscribe2((newState) => {
+      if (IDLE_STATES.has(newState)) {
+        this.onTurnComplete();
+      }
+    });
   }
   enqueue(entry) {
     this.#enqueueInternal(entry, { persist: true });
   }
+  #transitionSlot(key, slot, to, trigger) {
+    const from2 = slot.state;
+    if (from2 === to) return;
+    slot.state = to;
+    this.#deps.log({
+      event: "collab_queue_slot_transition",
+      participantId: key,
+      queueKey: this.#deps.queueKey ?? null,
+      from: from2,
+      to,
+      trigger
+    });
+  }
   #enqueueInternal(entry, opts) {
     if (this.#disposed) return;
     const participants = opts.participantsOverride ?? this.#deps.getCollabParticipants();
@@ -81733,7 +82230,7 @@ var CollabMessageQueue = class {
       });
       return;
     }
-    slot.state = "accumulating";
+    this.#transitionSlot(key, slot, "accumulating", "enqueue");
     if (slot.pending.length >= this.#maxBatchSize) {
       this.#flushSlot(key);
       return;
@@ -81744,15 +82241,23 @@ var CollabMessageQueue = class {
    * Signal that the agent turn finished. Every participant slot that
    * was blocked in waiting_for_turn is released. Slots with pending
    * messages transition back to accumulating with a fresh idle window.
+   *
+   * Defers internally via queueMicrotask (Invariant #11) so callers can
+   * invoke this synchronously from library callbacks without risking re-entry.
    */
   onTurnComplete() {
+    queueMicrotask(() => {
+      this.#doTurnComplete();
+    });
+  }
+  #doTurnComplete() {
     for (const [key, slot] of this.#slots) {
       if (slot.state !== "waiting_for_turn") continue;
       if (slot.pending.length > 0) {
-        slot.state = "accumulating";
+        this.#transitionSlot(key, slot, "accumulating", "turn_complete_with_pending");
         slot.timer.schedule();
       } else {
-        slot.state = "idle";
+        this.#transitionSlot(key, slot, "idle", "turn_complete_drained");
         this.#slots.delete(key);
       }
     }
@@ -81764,7 +82269,7 @@ var CollabMessageQueue = class {
       slot.pending.length = 0;
       slot.timer.cancel();
       slot.timer.reset();
-      slot.state = "idle";
+      this.#transitionSlot(key, slot, "idle", "cancel_queued");
       this.#clearPersistedFor(key);
     }
     this.#slots.clear();
@@ -81775,11 +82280,13 @@ var CollabMessageQueue = class {
       slot.pending.length = 0;
       slot.timer.dispose();
       this.#clearPersistedFor(key);
-      slot.state = "idle";
+      this.#transitionSlot(key, slot, "idle", "reset");
     }
     this.#slots.clear();
   }
   dispose() {
+    this.#unsubscribeThreadState?.();
+    this.#unsubscribeThreadState = null;
     this.#flushAllImmediate();
     for (const slot of this.#slots.values()) {
       slot.timer.dispose();
@@ -81861,17 +82368,17 @@ var CollabMessageQueue = class {
     slot.timer.cancel();
     slot.timer.reset();
     if (slot.pending.length === 0) {
-      slot.state = "idle";
+      this.#transitionSlot(key, slot, "idle", "flush_empty");
       return;
     }
     const batch = slot.pending.splice(0);
     const content = formatCollabBatch(batch);
-    slot.state = "waiting_for_turn";
+    this.#transitionSlot(key, slot, "waiting_for_turn", "flush");
     try {
       this.#deps.forwardBatch(content, batch);
     } catch (err) {
       slot.pending.unshift(...batch);
-      slot.state = "accumulating";
+      this.#transitionSlot(key, slot, "accumulating", "forward_failed");
       slot.timer.schedule();
       this.#deps.log({
         event: "collab_queue_forward_failed",
@@ -81881,6 +82388,12 @@ var CollabMessageQueue = class {
       return;
     }
     this.#clearPersistedFor(key);
+    if (this.#deps.onBatchForwarded) {
+      const batchCorrelationIds = batch.map((e) => e.correlationId).filter((id) => id !== void 0);
+      if (batchCorrelationIds.length > 0) {
+        this.#deps.onBatchForwarded(batchCorrelationIds);
+      }
+    }
     this.#deps.log({
       event: "collab_queue_flushed",
       participantId: key,
@@ -81901,6 +82414,12 @@ var CollabMessageQueue = class {
       const content = formatCollabBatch(batch);
       this.#deps.forwardBatch(content, batch);
       this.#clearPersistedFor(key);
+      if (this.#deps.onBatchForwarded) {
+        const batchCorrelationIds = batch.map((e) => e.correlationId).filter((id) => id !== void 0);
+        if (batchCorrelationIds.length > 0) {
+          this.#deps.onBatchForwarded(batchCorrelationIds);
+        }
+      }
       this.#deps.log({
         event: "collab_queue_flushed_immediate",
         participantId: key,
@@ -82634,6 +83153,7 @@ function handleSpawning(snapshot, event) {
     b2.log("spawning", "cold_idle", event.type);
     b2.taskStatus("input_required");
     b2.emitError(event.error, "spawn_failed");
+    b2.effects.push({ type: "re_queue_initial", content: event.lastInitialContent ?? [] });
     return { state: "cold_idle", sessionId: null, rewindAtMessageId: null, effects: b2.effects };
   }
   if (event.type === "sdk_error" || event.type === "subprocess_died") {
@@ -82729,14 +83249,19 @@ function exitStoppingAlive(snapshot, trigger) {
   const { sessionId, rewindAtMessageId } = snapshot;
   const b2 = createEffectBuilder();
   b2.effects.push({ type: "clear_pending_inputs" });
-  b2.effects.push({ type: "clear_queue" });
+  b2.effects.push({ type: "clear_unmarked_queue" });
   b2.log("stopping", "warm_idle", trigger);
   b2.taskStatus("input_required");
+  b2.effects.push({ type: "push_message" });
   return { state: "warm_idle", sessionId, rewindAtMessageId, effects: b2.effects };
 }
 function handleStopping(snapshot, event) {
   const { sessionId, rewindAtMessageId } = snapshot;
   const b2 = createEffectBuilder();
+  if (event.type === "user_message") {
+    b2.effects.push({ type: "mark_queue_preserve" });
+    return { state: "stopping", sessionId, rewindAtMessageId, effects: b2.effects };
+  }
   if (event.type === "turn_complete") {
     return exitStoppingAlive(snapshot, event.type);
   }
@@ -82746,14 +83271,14 @@ function handleStopping(snapshot, event) {
   if (event.type === "close_acknowledged") {
     b2.log("stopping", "resumable_idle", event.type);
     b2.effects.push({ type: "clear_pending_inputs" });
-    b2.effects.push({ type: "clear_queue" });
+    b2.effects.push({ type: "clear_unmarked_queue" });
     b2.taskStatus("input_required");
     return { state: "resumable_idle", sessionId, rewindAtMessageId, effects: b2.effects };
   }
   if (event.type === "subprocess_died" || event.type === "sdk_error") {
     b2.log("stopping", "resumable_idle", event.type);
     b2.effects.push({ type: "clear_pending_inputs" });
-    b2.effects.push({ type: "clear_queue" });
+    b2.effects.push({ type: "clear_unmarked_queue" });
     b2.taskStatus("input_required");
     return { state: "resumable_idle", sessionId, rewindAtMessageId, effects: b2.effects };
   }
@@ -82761,7 +83286,7 @@ function handleStopping(snapshot, event) {
     b2.log("stopping", "resumable_idle", event.type);
     b2.effects.push({ type: "force_kill" });
     b2.effects.push({ type: "clear_pending_inputs" });
-    b2.effects.push({ type: "clear_queue" });
+    b2.effects.push({ type: "clear_unmarked_queue" });
     b2.taskStatus("input_required");
     return { state: "resumable_idle", sessionId, rewindAtMessageId, effects: b2.effects };
   }
@@ -82823,6 +83348,12 @@ var AgentSessionManager = class {
   }
   sendMessage(content) {
     this.#queue.push({ content });
+    this.#config.log({
+      event: "session_send_message",
+      taskId: this.#config.taskId,
+      queueDepth: this.#queue.length,
+      eventType: "user_message"
+    });
     this.#dispatch({ type: "user_message" });
   }
   notifyInitReceived(sessionId) {
@@ -82852,8 +83383,8 @@ var AgentSessionManager = class {
   notifyCloseAcknowledged() {
     this.#dispatch({ type: "close_acknowledged" });
   }
-  notifySpawnFailed(error2) {
-    this.#dispatch({ type: "spawn_failed", error: error2 });
+  notifySpawnFailed(error2, lastInitialContent) {
+    this.#dispatch({ type: "spawn_failed", error: error2, lastInitialContent });
   }
   addPendingInput(toolUseId, request) {
     this.#pendingInputs.set(toolUseId, request);
@@ -82899,10 +83430,14 @@ var AgentSessionManager = class {
     }
   }
   #processEvent(event) {
+    const prevState = this.#state;
     const result = transition(this.#snapshot(), event);
     this.#state = result.state;
     this.#sessionId = result.sessionId;
     this.#rewindAtMessageId = result.rewindAtMessageId;
+    if (this.#state !== prevState) {
+      this.#config.onSessionStateChange(this.#state, prevState);
+    }
     this.#applyEffects(result.effects);
     this.#manageTimers();
   }
@@ -82914,17 +83449,9 @@ var AgentSessionManager = class {
           this.#config.onSpawn(effect.reason, initial?.content ?? []);
           break;
         }
-        case "push_message": {
-          const messages = [];
-          while (this.#queue.length > 0) {
-            const msg = this.#queue.shift();
-            if (msg) messages.push(msg.content);
-          }
-          if (messages.length > 0) {
-            this.#config.onFlushQueue(messages);
-          }
+        case "push_message":
+          this.#flushQueue();
           break;
-        }
         case "interrupt":
           this.#config.onInterrupt();
           break;
@@ -82955,6 +83482,17 @@ var AgentSessionManager = class {
         case "clear_queue":
           this.#queue = [];
           break;
+        case "mark_queue_preserve":
+          this.#markLastPreserved();
+          break;
+        case "clear_unmarked_queue":
+          this.#queue = this.#queue.filter((q) => q.preserved);
+          break;
+        case "re_queue_initial":
+          if (effect.content.length > 0) {
+            this.#queue.unshift({ content: effect.content, preserved: true });
+          }
+          break;
         default: {
           const _exhaustive = effect;
           throw new Error(`Unhandled effect: ${JSON.stringify(_exhaustive)}`);
@@ -82962,6 +83500,22 @@ var AgentSessionManager = class {
       }
     }
   }
+  #flushQueue() {
+    const messages = [];
+    while (this.#queue.length > 0) {
+      const msg = this.#queue.shift();
+      if (msg) messages.push(msg.content);
+    }
+    if (messages.length > 0) {
+      this.#config.onFlushQueue(messages);
+    }
+  }
+  #markLastPreserved() {
+    if (this.#queue.length > 0) {
+      const last = this.#queue[this.#queue.length - 1];
+      if (last) last.preserved = true;
+    }
+  }
   #manageTimers() {
     if (this.#state === "warm_idle") {
       this.#clearStopTimer();
@@ -83411,6 +83965,7 @@ var Thread = class {
   #subprocess = null;
   #asyncQueue = Promise.resolve();
   #disposed = false;
+  #stateChangeListeners = /* @__PURE__ */ new Set();
   #permissionQueue = [];
   #sendControlMessage;
   #streamDeltaSinks = /* @__PURE__ */ new Set();
@@ -83496,7 +84051,8 @@ var Thread = class {
         onInterrupt: () => this.#handleInterrupt(),
         onClose: () => this.#handleClose(),
         onForceKill: () => this.#handleForceKill(),
-        log: config2.log
+        log: config2.log,
+        onSessionStateChange: (newState, prevState) => this.#notifyStateChange(newState, prevState)
       },
       initialSnapshot
     );
@@ -83507,6 +84063,21 @@ var Thread = class {
   get state() {
     return this.#manager.state;
   }
+  /**
+   * Subscribe to session state changes. The listener is called with the new
+   * and previous SessionState whenever a transition occurs.
+   *
+   * Dispatch is microtask-deferred (Invariant #11) to prevent re-entry into
+   * wasm/loro and other synchronous event emitters.
+   *
+   * Returns an unsubscribe function.
+   */
+  onStateChange(listener) {
+    this.#stateChangeListeners.add(listener);
+    return () => {
+      this.#stateChangeListeners.delete(listener);
+    };
+  }
   get sessionId() {
     return this.#ownSessionId ?? this.#manager.sessionId;
   }
@@ -83618,6 +84189,7 @@ var Thread = class {
     this.#permissionHandler.denyAllPending("Thread disposed");
     this.#permissionQueue.length = 0;
     this.#streamDeltaSinks.clear();
+    this.#stateChangeListeners.clear();
     this.#manager.dispose();
     await this.#asyncQueue;
     this.#subprocess?.close();
@@ -83713,6 +84285,17 @@ var Thread = class {
   /** ------------------------------------------------------------------ */
   /** Session manager callbacks                                          */
   /** ------------------------------------------------------------------ */
+  /**
+   * Dispatches state-change notifications to all registered listeners via
+   * queueMicrotask so listeners cannot synchronously re-enter the session
+   * manager or wasm-backed libraries (Invariant #11).
+   */
+  #notifyStateChange(newState, prevState) {
+    if (this.#stateChangeListeners.size === 0) return;
+    for (const listener of this.#stateChangeListeners) {
+      queueMicrotask(() => listener(newState, prevState));
+    }
+  }
   #handleStatusChange(status) {
     this.#config.log({
       event: "thread_status_changed",
@@ -83783,7 +84366,7 @@ ${conversationReplay}` : conversationReplay;
         threadId: this.#config.threadId,
         error: msg
       });
-      this.#manager.notifySpawnFailed(msg);
+      this.#manager.notifySpawnFailed(msg, this.#lastSpawnInitialContent ?? void 0);
     });
   }
   async #applySettingsToSubprocess() {
@@ -84131,9 +84714,13 @@ ${conversationReplay}` : conversationReplay;
           model: meta?.model ?? null,
           reasoningEffort: meta?.reasoningEffort ?? null,
           permissionMode: meta?.permissionMode ?? null,
-          ...meta?.isSynthetic && { isSynthetic: true }
+          ...meta?.isSynthetic && { isSynthetic: true },
+          ...meta?.correlationId && { correlationId: meta.correlationId }
         });
         this.#callbacks.onMessageStored?.(echoSeqNo, echoMsgId, "human", event.sdkUuid);
+        if (meta?.correlationId) {
+          this.#callbacks.onUserMessageConfirmed?.(meta.correlationId, event.sdkUuid);
+        }
         break;
       }
       case "assistant_message": {
@@ -85463,39 +86050,6 @@ function buildIncrementalMessage(uri, current2, incremental, name, now) {
   };
 }
 
-// src/services/roi/inject-shipyard-trailer.ts
-function buildDefaultTrailerInjectDeps() {
-  return {
-    readCommitMessage: async (cwd) => runWithTimeout("git", ["log", "-1", "--pretty=%B"], cwd, 5e3),
-    amendCommit: async (cwd, message) => {
-      await runWithTimeout("git", ["commit", "--amend", "--no-edit", "-m", message], cwd, 15e3);
-    },
-    getHeadSha: async (cwd) => (await runWithTimeout("git", ["rev-parse", "HEAD"], cwd, 5e3)).trim(),
-    getCurrentBranch: async (cwd) => (await runWithTimeout("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd, 5e3)).trim(),
-    getRepoSlug: async (cwd) => {
-      const url = (await runWithTimeout("git", ["config", "--get", "remote.origin.url"], cwd, 5e3).catch(
-        () => ""
-      )).trim();
-      const match2 = url.match(/[:/]([^/:]+\/[^/:]+?)(\.git)?\s*$/);
-      return match2?.[1] ?? "";
-    }
-  };
-}
-async function injectShipyardTrailer(ctx, deps) {
-  const original = await deps.readCommitMessage(ctx.cwd);
-  if (hasShipyardTrailer(original)) {
-    return { injected: false, reason: "already_trailered" };
-  }
-  const newMessage = appendTrailerToMessage(original, ctx.trailer);
-  await deps.amendCommit(ctx.cwd, newMessage);
-  const [commitSha, branch, repo] = await Promise.all([
-    deps.getHeadSha(ctx.cwd),
-    deps.getCurrentBranch(ctx.cwd),
-    deps.getRepoSlug(ctx.cwd)
-  ]);
-  return { injected: true, commitSha, branch, repo };
-}
-
 // src/services/task-resource-resolver.ts
 var TASK_URI_PREFIX = "shipyard://task/";
 function buildTaskResourceUri(taskId) {
@@ -88518,17 +89072,6 @@ function trackPlanFileCreation(content, onPlanFile) {
     }
   }
 }
-function detectCommitInBashToolResults(content) {
-  const commitPattern = /(?:^|\n)\[[\w][^[\]]*\s[0-9a-f]{7,40}\]/;
-  const graphitePattern = /Amended.*commit|Committing changes to/i;
-  for (const block2 of content) {
-    if (block2.type !== "tool_result" || block2.isError) continue;
-    if (commitPattern.test(block2.content) || graphitePattern.test(block2.content)) {
-      return true;
-    }
-  }
-  return false;
-}
 
 // src/services/token-counter.ts
 import { execFile as execFile7 } from "child_process";
@@ -88870,9 +89413,18 @@ function replayTurnStats(lastTurnStats, send) {
 }
 
 // src/services/task/orchestrator/task.ts
+function hasActiveCollaborators(participants) {
+  return participants.length > 0;
+}
 function shouldClearPersistence(status) {
   return status === "completed" || status === "canceled";
 }
+function classifyRoiTransition(nextStatus, roiEverRan) {
+  if (nextStatus === "completed" || nextStatus === "canceled") return "emit-ended";
+  if (nextStatus === "input_required" && roiEverRan) return "emit-ended";
+  if (nextStatus === "in_progress") return "reset-cycle";
+  return "nothing";
+}
 var Task = class {
   #deps;
   #mainThread;
@@ -88914,19 +89466,17 @@ var Task = class {
   #pendingPostCompactStats = null;
   #pendingPostCompactTurnStats = null;
   /** ROI: wall-clock start of this task lifetime, used for durationMs on task_ended. */
-  #roiStartedAtMs = Date.now();
+  #roiStartedAtMs;
   /** ROI: tracks the most recent status for finalStatus on task_ended. */
   #roiLastStatus = "open";
   /** ROI: flips true the first time status transitions to in_progress (i.e. agent ran). */
   #roiEverRan = false;
-  /** ROI: guard against duplicate task_ended emission. */
-  #roiEndedEmitted = false;
+  /** ROI: guard against duplicate task_ended emission for the current run cycle. */
+  #roiEndedEmittedForCurrentCycle = false;
   /** ROI: counts agent turns (incremented on each turn_complete). */
   #roiTurnCount = 0;
-  /** ROI: serializes trailer injections so concurrent tool_result_echo events don't race the git amend. */
+  /** ROI: serializes commit-scan triggers so concurrent tool_result_echo events don't race the git amend inside scanAndAttributeCommits. */
   #trailerInjectionChain = Promise.resolve();
-  /** ROI: trailer injection deps (overridable for tests). */
-  #trailerInjectDeps = buildDefaultTrailerInjectDeps();
   /** MCP status polling (delegated to McpPoller) */
   #mcpPoller;
   /** Telemetry (delegated to TaskTelemetry) */
@@ -88949,6 +89499,8 @@ var Task = class {
     this.#lastTurnStats = deps.initialTurnStats ?? null;
     this.#tokenCountResult = deps.initialTokenCount ?? null;
     this.#hydrationPromise = deps.hydrationPromise ?? null;
+    this.#roiStartedAtMs = deps.taskCreatedAt;
+    this.#roiTurnCount = deps.initialTurnCount;
     this.#telemetry = new TaskTelemetry({
       taskId: deps.taskId,
       metricsCollector: deps.metricsCollector,
@@ -88978,10 +89530,16 @@ var Task = class {
           settings: mergedSettings,
           participantId: firstMeta?.participantId ?? this.#deps.humanParticipantId,
           senderName: firstMeta?.senderDisplayName ?? this.#deps.ownerDisplayName ?? null,
-          originalContent: content
+          originalContent: content,
+          correlationIds: metadata.map((m2) => m2.correlationId).filter((x2) => !!x2)
         });
         this.#mainThread.handleUserMessage(content, mergedSettings);
       },
+      onBatchForwarded: (correlationIds) => {
+        for (const id of correlationIds) {
+          this.#deps.onForwardedAck(id);
+        }
+      },
       log: deps.log,
       persistence: deps.collabQueuePersistence,
       queueKey: mainQueueKey(deps.taskId)
@@ -89210,15 +89768,43 @@ var Task = class {
              * rather than a real user message. Mark it so the browser
              * hides it via assembleMessages' isSynthetic filter.
              */
-            isSynthetic: meta === void 0
+            isSynthetic: meta === void 0,
+            correlationId: meta?.correlationIds[0]
           };
         },
+        onUserMessageConfirmed: (correlationId, sdkUuid) => {
+          const currentMeta = this.#pendingMessageMeta[0];
+          const idsToAck = currentMeta?.correlationIds ?? [correlationId];
+          if (sdkUuid) {
+            const [primary, ...secondary] = idsToAck;
+            const primaryId = primary ?? correlationId;
+            this.#deps.store.stampSdkUuid(
+              this.#deps.channelId,
+              primaryId,
+              sdkUuid,
+              secondary.length > 0 ? secondary : void 0
+            ).catch((err) => {
+              this.#deps.log({
+                event: "stamp_sdk_uuid_failed",
+                taskId: this.#deps.taskId,
+                correlationId: primaryId,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            });
+          }
+          for (const id of idsToAck) {
+            this.#deps.onConfirmedAck(id);
+          }
+        },
         onBeforeSpawn: (content) => this.#handleBeforeSpawn(content),
         onBeforeFlush: (messages) => this.#handleBeforeFlush(messages),
         buildCanUseTool: () => this.#buildCanUseTool()
       }
     );
     this.#mainThread.initAdoptedCanUseTool();
+    this.#collabQueue.wireThreadStateSubscription(
+      (listener) => this.#mainThread.onStateChange(listener)
+    );
     this.#sideThreads = new SideThreadRegistry({
       taskId: deps.taskId,
       dataDir: deps.dataDir,
@@ -89244,13 +89830,22 @@ var Task = class {
         })
       );
     }
-    emitTaskStarted(deps.metricsCollector, {
-      taskId: deps.taskId,
-      userId: deps.userId,
-      activeTaskCount: deps.getActiveTaskCount(),
-      mode: deps.mode,
-      timestamp: this.#roiStartedAtMs
-    });
+    if (!deps.initialRoiStartedEmitted) {
+      emitTaskStarted(deps.metricsCollector, {
+        taskId: deps.taskId,
+        userId: deps.userId,
+        activeTaskCount: deps.getActiveTaskCount(),
+        mode: deps.mode,
+        timestamp: this.#roiStartedAtMs
+      });
+      deps.persistRoiStarted().catch((err) => {
+        deps.log({
+          event: "roi_persist_started_failed",
+          taskId: deps.taskId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
   }
   get state() {
     return this.#mainThread.state;
@@ -89258,23 +89853,28 @@ var Task = class {
   get sessionId() {
     return this.#mainThread.sessionId;
   }
+  /** Current working directory. May be undefined during early bootstrap before EnterWorktree. */
+  get cwd() {
+    return this.#cwd;
+  }
   get latestSettings() {
     return this.#latestSettings;
   }
   get mainThread() {
     return this.#mainThread;
   }
-  handleUserMessage(content, settings, participantId, senderDisplayName) {
+  handleUserMessage(content, settings, participantId, senderDisplayName, correlationId) {
     if (settings) {
       this.#latestSettings = { ...this.#latestSettings, ...settings };
     }
     const participants = this.#deps.getCollabParticipants();
-    if (participants.length > 0) {
+    if (hasActiveCollaborators(participants)) {
       this.#collabQueue.enqueue({
         content,
         settings,
         participantId: participantId ?? this.#deps.humanParticipantId,
-        senderDisplayName: senderDisplayName ?? void 0
+        senderDisplayName: senderDisplayName ?? void 0,
+        correlationId
       });
       return;
     }
@@ -89282,23 +89882,100 @@ var Task = class {
       settings: { ...this.#latestSettings },
       participantId: participantId ?? this.#deps.humanParticipantId,
       senderName: senderDisplayName ?? this.#deps.ownerDisplayName ?? null,
-      originalContent: content
+      originalContent: content,
+      correlationIds: correlationId ? [correlationId] : []
     });
     this.#mainThread.handleUserMessage(content, settings);
+    if (correlationId) {
+      this.#deps.onForwardedAck(correlationId);
+    }
   }
   /**
    * Restore in-flight collab batches from persistence after daemon
    * restart. Replays entries through the main queue so per-peer
    * timers re-initialize and missed messages reach the agent on
    * the next flush.
+   *
+   * Returns the set of correlationIds whose JSONL rows were claimed by this
+   * replay so rehydrateUnpushedMessages can skip them and avoid double-sending.
    */
   async rehydrateCollabQueue() {
     const persistence = this.#deps.collabQueuePersistence;
-    if (!persistence) return;
+    if (!persistence) return /* @__PURE__ */ new Set();
     const key = mainQueueKey(this.#deps.taskId);
     const entries = await persistence.read(key);
-    if (entries.length === 0) return;
+    if (entries.length === 0) return /* @__PURE__ */ new Set();
     await this.#collabQueue.rehydrate(entries);
+    const messages = await this.#deps.store.getMessages(this.#deps.channelId);
+    return matchCollabQueueCorrelationIds(messages, entries);
+  }
+  /**
+   * Restore in-flight collab batches for a side thread from persistence
+   * after daemon restart. Mirrors rehydrateCollabQueue for thread-scoped queues.
+   *
+   * Returns false when the side thread is not in the registry — signals orphan
+   * so caller clears the file, mirroring the main-queue orphan-clear path.
+   * Lazily initializes the thread's CollabMessageQueue using the same
+   * construction path as the write side (handleThreadUserMessage).
+   */
+  async rehydrateThreadQueue(threadId) {
+    const persistence = this.#deps.collabQueuePersistence;
+    if (!persistence || !this.#sideThreads.get(threadId)) return false;
+    const key = threadQueueKey(this.#deps.taskId, threadId);
+    const entries = await persistence.read(key);
+    if (entries.length === 0) return true;
+    let queue = this.#threadQueues.get(threadId);
+    if (!queue) {
+      const sideThread = this.#sideThreads.get(threadId);
+      queue = new CollabMessageQueue({
+        getCollabParticipants: this.#deps.getCollabParticipants,
+        forwardBatch: (batchContent, metadata) => {
+          this.#forwardThreadBatch(threadId, batchContent, metadata);
+        },
+        log: this.#deps.log,
+        persistence: this.#deps.collabQueuePersistence,
+        queueKey: threadQueueKey(this.#deps.taskId, threadId),
+        subscribeToThreadState: sideThread ? (listener) => sideThread.onStateChange(listener) : void 0
+      });
+      this.#threadQueues.set(threadId, queue);
+    }
+    await queue.rehydrate(entries);
+    return true;
+  }
+  /**
+   * Sub-phase 7b: Rehydrate persisted-but-unpushed user messages after daemon restart.
+   *
+   * Scans the JSONL store for rows where correlationId is set but sdkUuid is null
+   * (persisted but not confirmed by SDK). Re-injects them as pushMessage content
+   * so the next subprocess spawn receives them in order.
+   *
+   * Pass excludeCorrelationIds to skip messages already handled by rehydrateCollabQueue,
+   * preventing double-send of the same message to the subprocess.
+   *
+   * Returns the number of messages re-injected.
+   */
+  async rehydrateUnpushedMessages(excludeCorrelationIds) {
+    const messages = await this.#deps.store.getMessages(this.#deps.channelId);
+    const unpushed = messages.filter(
+      (m2) => m2.senderKind === "human" && m2.correlationId && !m2.sdkUuid && !(excludeCorrelationIds && m2.correlationId && excludeCorrelationIds.has(m2.correlationId))
+    );
+    if (unpushed.length === 0) return 0;
+    for (const msg of unpushed) {
+      this.#pendingMessageMeta.push({
+        settings: { ...this.#latestSettings },
+        participantId: msg.participantId,
+        senderName: null,
+        originalContent: msg.content,
+        correlationIds: msg.correlationId ? [msg.correlationId, ...msg.batchCorrelationIds ?? []] : []
+      });
+      this.#mainThread.handleUserMessage(msg.content);
+    }
+    this.#deps.log({
+      event: "unpushed_messages_rehydrated",
+      taskId: this.#deps.taskId,
+      count: unpushed.length
+    });
+    return unpushed.length;
   }
   /**
    * Route a thread user message through collab micro-batching when
@@ -89326,7 +90003,8 @@ var Task = class {
           },
           log: this.#deps.log,
           persistence: this.#deps.collabQueuePersistence,
-          queueKey: threadQueueKey(this.#deps.taskId, threadId)
+          queueKey: threadQueueKey(this.#deps.taskId, threadId),
+          subscribeToThreadState: (listener) => sideThread.onStateChange(listener)
         });
         this.#threadQueues.set(threadId, queue);
       }
@@ -89342,7 +90020,8 @@ var Task = class {
       settings: settings ?? this.#latestSettings,
       participantId: participantId ?? this.#deps.humanParticipantId,
       senderName: senderDisplayName ?? null,
-      originalContent: content
+      originalContent: content,
+      correlationIds: []
     });
     sideThread.handleUserMessage(content, settings);
   }
@@ -89855,7 +90534,8 @@ var Task = class {
       settings: mergedSettings,
       participantId: firstMeta?.participantId ?? this.#deps.humanParticipantId,
       senderName: firstMeta?.senderDisplayName ?? this.#deps.ownerDisplayName ?? null,
-      originalContent: content
+      originalContent: content,
+      correlationIds: metadata.map((m2) => m2.correlationId).filter((x2) => !!x2)
     });
     sideThread.handleUserMessage(content, mergedSettings);
   }
@@ -89872,11 +90552,14 @@ var Task = class {
     if (!arr || arr.length === 0) return void 0;
     return arr.shift();
   }
-  async #handleBeforeSpawn(initialContent) {
+  async #awaitHydration() {
     if (this.#hydrationPromise) {
       await this.#hydrationPromise;
       this.#hydrationPromise = null;
     }
+  }
+  async #handleBeforeSpawn(initialContent) {
+    await this.#awaitHydration();
     await this.#ensureCompactContextFromStore();
     if (this.#needsPromotionContext) {
       this.#needsPromotionContext = false;
@@ -89966,6 +90649,7 @@ Use this context to maintain continuity. You have already done this work \u2014
     return syntheticPrepend.length > 0 ? [...syntheticPrepend, ...annotated] : annotated;
   }
   async #handleBeforeFlush(messages) {
+    await this.#awaitHydration();
     this.#rewindCheckpoint.enqueueSpawnCheckpoint();
     const history2 = await this.#deps.store.getMessages(this.#deps.channelId);
     const result = [];
@@ -90005,19 +90689,29 @@ Use this context to maintain continuity. You have already done this work \u2014
     }
     return null;
   }
-  #handleStatusChange(status) {
-    if (!isTaskStatus(status)) return;
-    let effectiveStatus = status;
+  /**
+   * Scheduled (cron) tasks have no interactive user — the first agent turn
+   * is the complete run. When the session reaches `input_required` (i.e.
+   * the agent finished and is waiting for the next user message), auto-
+   * complete the task and tear down the session.
+   *
+   * The guard prevents re-entry: stop() triggers stopping -> resumable_idle
+   * which emits another `input_required`, but by then we've already written
+   * `completed`. Subsequent status callbacks after auto-complete are dropped.
+   *
+   * Returns the effective status to use, or null if the caller should return early.
+   */
+  #resolveScheduledStatus(status) {
     if (this.#deps.scheduleId && this.#scheduledAutoCompleted) {
       if (status === "in_progress") {
         this.#scheduledAutoCompleted = false;
       } else {
-        return;
+        return null;
       }
     }
     if (status === "input_required" && this.#deps.scheduleId && !this.#scheduledAutoCompleted) {
       this.#scheduledAutoCompleted = true;
-      effectiveStatus = this.#explicitlyStopped ? "canceled" : "completed";
+      const effective = this.#explicitlyStopped ? "canceled" : "completed";
       this.#deps.log({
         event: this.#explicitlyStopped ? "scheduled_task_stopped" : "scheduled_task_auto_completed",
         taskId: this.#deps.taskId,
@@ -90026,7 +90720,14 @@ Use this context to maintain continuity. You have already done this work \u2014
       if (!this.#explicitlyStopped) {
         this.#mainThread.stop();
       }
+      return effective;
     }
+    return status;
+  }
+  #handleStatusChange(status) {
+    if (!isTaskStatus(status)) return;
+    const effectiveStatus = this.#resolveScheduledStatus(status);
+    if (effectiveStatus === null) return;
     this.#deps.log({
       event: "task_status_changed",
       taskId: this.#deps.taskId,
@@ -90037,6 +90738,19 @@ Use this context to maintain continuity. You have already done this work \u2014
       status: effectiveStatus
     });
     this.#trackRoiStatus(effectiveStatus);
+    const roiAction = classifyRoiTransition(effectiveStatus, this.#roiEverRan);
+    switch (roiAction) {
+      case "emit-ended":
+        this.#emitTaskEndedOnce();
+        break;
+      case "reset-cycle":
+        this.#roiEndedEmittedForCurrentCycle = false;
+        break;
+      case "nothing":
+        break;
+      default:
+        assertNever(roiAction);
+    }
     this.#deps.writeTaskStatus(effectiveStatus);
     if (shouldClearPersistence(effectiveStatus)) {
       this.#rewindCheckpoint.cleanup(this.#cwd).catch((err) => {
@@ -90126,7 +90840,7 @@ Use this context to maintain continuity. You have already done this work \u2014
         this.#handleWorktreeToolResults(event.content);
         this.#subagentManager.handleSubagentToolResults(event.content);
         this.#trackPlanFileCreation(event.content);
-        this.#maybeInjectShipyardTrailer(event.content);
+        this.#triggerCommitScan();
         break;
       case "api_usage_snapshot":
         this.#lastApiUsage = {
@@ -90227,6 +90941,13 @@ Use this context to maintain continuity. You have already done this work \u2014
   }
   #handleTurnComplete(event) {
     this.#roiTurnCount += 1;
+    this.#deps.onTurnComplete().catch((err) => {
+      this.#deps.log({
+        event: "roi_persist_turn_count_failed",
+        taskId: this.#deps.taskId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
     const prevResult = this.#lastTurnResult;
     this.#lastTurnResult = event.result;
     this.#deps.log({
@@ -90382,8 +91103,8 @@ Use this context to maintain continuity. You have already done this work \u2014
     if (status === "in_progress") this.#roiEverRan = true;
   }
   #emitTaskEndedOnce() {
-    if (this.#roiEndedEmitted) return;
-    this.#roiEndedEmitted = true;
+    if (this.#roiEndedEmittedForCurrentCycle) return;
+    this.#roiEndedEmittedForCurrentCycle = true;
     const finalStatus = this.#roiLastStatus === "completed" ? "completed" : this.#roiLastStatus === "input_required" ? "input_required" : "canceled";
     emitTaskEnded(this.#deps.metricsCollector, {
       taskId: this.#deps.taskId,
@@ -90398,45 +91119,44 @@ Use this context to maintain continuity. You have already done this work \u2014
       this.#deps.persistAbandonedAt(Date.now());
     }
   }
-  #maybeInjectShipyardTrailer(content) {
-    if (!detectCommitInBashToolResults(content)) return;
+  #triggerCommitScan() {
     const cwd = this.#cwd;
     if (!cwd) return;
-    const sessionId = this.sessionId ?? `pre-session-${this.#deps.taskId}`;
-    const trailer = {
-      version: TRAILER_SCHEMA_VERSION,
-      taskId: this.#deps.taskId,
-      sessionId,
-      model: this.#latestSettings.model ?? "unknown",
-      tokens: this.#costBaseline.totalOutputTokens,
-      costUsd: this.#costBaseline.totalCostUsd,
-      turnCount: this.#roiTurnCount,
-      attributionType: "originated",
-      clientVersion: "shipyard-daemon"
-    };
     this.#trailerInjectionChain = this.#trailerInjectionChain.then(async () => {
       try {
-        const result = await injectShipyardTrailer({ cwd, trailer }, this.#trailerInjectDeps);
-        if (!result.injected || !result.commitSha || !result.repo || !result.branch) return;
-        emitCommitAttributed(this.#deps.metricsCollector, {
-          taskId: this.#deps.taskId,
-          userId: this.#deps.userId,
-          commitSha: result.commitSha,
-          repo: result.repo,
-          branch: result.branch,
-          model: trailer.model,
-          tokens: trailer.tokens,
-          costUsd: trailer.costUsd,
-          turnCount: trailer.turnCount,
-          attributionType: "originated"
-        });
+        const state = await this.#deps.getCommitScanState();
+        await scanAndAttributeCommits(
+          {
+            cwd,
+            taskId: this.#deps.taskId,
+            userId: this.#deps.userId,
+            lastSeenSha: state.lastSeenSha,
+            attributedCommitShas: state.attributedCommitShas
+          },
+          {
+            metricsCollector: this.#deps.metricsCollector,
+            log: this.#deps.log,
+            amendHead: true,
+            setLastCommitScanSha: (_taskId, sha) => this.#deps.setLastCommitScanSha(sha),
+            addAttributedCommitSha: (_taskId, sha) => this.#deps.addAttributedCommitSha(sha),
+            injectTrailer: injectShipyardTrailer,
+            getAttributionPayload: () => ({
+              model: this.#latestSettings.model ?? "unknown",
+              tokens: this.#costBaseline.totalOutputTokens,
+              costUsd: this.#costBaseline.totalCostUsd,
+              turnCount: this.#roiTurnCount,
+              sessionId: this.sessionId ?? `pre-session-${this.#deps.taskId}`
+            })
+          }
+        );
       } catch (err) {
         this.#deps.log({
-          event: "roi_trailer_injection_failed",
+          event: "roi_commit_scan_failed",
           taskId: this.#deps.taskId,
           error: err instanceof Error ? err.message : String(err)
         });
       }
+    }).catch(() => {
     });
   }
   applyOverlay(overlay) {
@@ -90552,6 +91272,27 @@ Use this context to maintain continuity. You have already done this work \u2014
     replayTurnStats(this.#lastTurnStats, send);
   }
 };
+function matchCollabQueueCorrelationIds(messages, queueEntries) {
+  const unpushedHuman = messages.filter(
+    (m2) => m2.senderKind === "human" && m2.correlationId && !m2.sdkUuid
+  );
+  const claimedIds = /* @__PURE__ */ new Set();
+  let queueIdx = 0;
+  for (const msg of unpushedHuman) {
+    if (queueIdx >= queueEntries.length) break;
+    const entry = queueEntries[queueIdx];
+    if (entry && JSON.stringify(msg.content) === JSON.stringify(entry.content)) {
+      if (msg.correlationId) {
+        claimedIds.add(msg.correlationId);
+        for (const secondary of msg.batchCorrelationIds ?? []) {
+          claimedIds.add(secondary);
+        }
+      }
+      queueIdx++;
+    }
+  }
+  return claimedIds;
+}
 
 // src/services/task/manager/task-manager-diff.ts
 async function rewindTask(params) {
@@ -90894,6 +91635,35 @@ function findSdkUuidForSeqNoInTask(tasks, taskId, seqNo) {
   return tasks.get(taskId)?.orchestrator.findSdkUuidForSeqNo(seqNo) ?? null;
 }
 
+// src/services/task/manager/task-manager-template.ts
+function buildInitialOverlayFromTemplate(template, now) {
+  if (!template || template.items.length === 0) return void 0;
+  const userTasks = template.items.map((item2) => ({
+    id: item2.id,
+    subject: item2.content,
+    description: item2.description,
+    status: "pending",
+    blocks: [],
+    blockedBy: item2.deps,
+    createdAt: now,
+    updatedAt: now
+  }));
+  return { ...DEFAULT_TASK_OVERLAY, userTasks };
+}
+function applyInitialOverlayToOrchestrator(args) {
+  const { taskId, initialOverlay, orchestratorRef, isTaskRegistered } = args;
+  if (orchestratorRef && isTaskRegistered(taskId)) {
+    orchestratorRef.applyOverlay(initialOverlay);
+    args.notifyTaskResourceChange(taskId);
+    return;
+  }
+  args.log({
+    event: "initial_overlay_skipped",
+    taskId,
+    reason: orchestratorRef ? "task_removed" : "orchestrator_not_registered"
+  });
+}
+
 // src/services/task/manager/task-manager.ts
 var TaskManager = class {
   #deps;
@@ -90906,6 +91676,18 @@ var TaskManager = class {
   #onRateLimitEvent = null;
   #overlayQueues = /* @__PURE__ */ new Map();
   #preWarmManager = null;
+  /**
+   * Per-task confirmed-ack emitter. Set when a message channel channel opens for a task,
+   * cleared when it closes. Called by Task.onConfirmedAck to route 'confirmed' acks back
+   * to the originating peer's message channel handler.
+   */
+  #confirmedAckEmitters = /* @__PURE__ */ new Map();
+  /**
+   * Per-task forwarded-ack emitter. Set when a message channel opens for a task,
+   * cleared when it closes. Called by Task.onForwardedAck to route 'forwarded' acks
+   * back to the originating peer's message channel handler.
+   */
+  #forwardedAckEmitters = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.#deps = deps;
   }
@@ -91102,6 +91884,28 @@ var TaskManager = class {
   subscribeThreadStreamDelta(taskId, threadId, listener) {
     return this.#tasks.get(taskId)?.orchestrator.subscribeSideThreadStreamDelta(threadId, listener) ?? null;
   }
+  /**
+   * Register a confirmed-ack emitter for a task's message channel.
+   * Returns an unregister function to call when the channel closes.
+   * When the task's SDK user_message_echo fires for a correlationId,
+   * the emitter is called so the channel can send stage:'confirmed'.
+   */
+  registerConfirmedAckEmitter(taskId, emitter) {
+    this.#confirmedAckEmitters.set(taskId, emitter);
+    return () => {
+      if (this.#confirmedAckEmitters.get(taskId) === emitter) {
+        this.#confirmedAckEmitters.delete(taskId);
+      }
+    };
+  }
+  registerForwardedAckEmitter(taskId, emitter) {
+    this.#forwardedAckEmitters.set(taskId, emitter);
+    return () => {
+      if (this.#forwardedAckEmitters.get(taskId) === emitter) {
+        this.#forwardedAckEmitters.delete(taskId);
+      }
+    };
+  }
   subscribeStreamDelta(taskId, listener) {
     const task = this.#tasks.get(taskId);
     if (task) {
@@ -91197,6 +92001,8 @@ var TaskManager = class {
     if (this.#tasks.has(params.taskId)) return;
     const cwd = params.cwd;
     const mode = params.mode ?? "task";
+    let orchestratorRef = null;
+    const taskCreatedAt = Date.now();
     const storeAndHydrate = async () => {
       const template = params.templateId ? await this.#deps.templateStore.get(params.templateId) : null;
       if (params.templateId && !template) {
@@ -91206,26 +92012,23 @@ var TaskManager = class {
           templateId: params.templateId
         });
       }
-      const now = Date.now();
-      const initialOverlay = template?.items.map((item2) => ({
-        id: item2.id,
-        subject: item2.content,
-        description: item2.description,
-        status: "pending",
-        blocks: [],
-        blockedBy: item2.deps,
-        createdAt: now,
-        updatedAt: now
-      })) ?? [];
+      const initialOverlay = buildInitialOverlayFromTemplate(template, taskCreatedAt);
       await this.#deps.taskStateStore.createTask({
         ...params,
         cwd,
         mode,
         appliedTemplateId: params.templateId,
-        initialOverlay: initialOverlay.length > 0 ? { ...DEFAULT_TASK_OVERLAY, userTasks: initialOverlay } : void 0
+        initialOverlay
       });
-      if (initialOverlay.length > 0) {
-        this.#deps.notifyTaskResourceChange(params.taskId);
+      if (initialOverlay) {
+        applyInitialOverlayToOrchestrator({
+          taskId: params.taskId,
+          initialOverlay,
+          orchestratorRef,
+          isTaskRegistered: (id) => this.#tasks.has(id),
+          notifyTaskResourceChange: this.#deps.notifyTaskResourceChange,
+          log: this.#deps.log
+        });
       }
     };
     const hydrationPromise = storeAndHydrate().catch((err) => {
@@ -91238,14 +92041,28 @@ var TaskManager = class {
     const claim = mode !== "conversation" ? this.#preWarmManager?.claim(cwd) : void 0;
     if (claim) {
       claim.subprocess.setHarnessTaskId(params.taskId);
+      const resolved = this.#deps.resolveMcpServers();
+      if (resolved && Object.keys(resolved).length > 0) {
+        claim.subprocess.setMcpServers(resolved).catch((err) => {
+          this.#deps.log({
+            event: "prewarm_adoption_mcp_sync_failed",
+            taskId: params.taskId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
     }
     const orchestrator = this.#createTask(params.taskId, params.channelId, {
       adoptedSubprocess: claim ?? void 0,
       cwd,
       mode,
       scheduleId: params.scheduleId,
-      hydrationPromise
+      hydrationPromise,
+      initialRoiStartedEmitted: false,
+      taskCreatedAt,
+      initialTurnCount: 0
     });
+    orchestratorRef = orchestrator;
     this.#tasks.set(params.taskId, {
       taskId: params.taskId,
       channelId: params.channelId,
@@ -91273,7 +92090,10 @@ var TaskManager = class {
       initialTurnStats: opts.initialTurnStats,
       initialTokenCount: opts.initialTokenCount,
       initialPlanDetection: opts.initialPlanDetection,
-      mode
+      mode,
+      initialRoiStartedEmitted: opts.initialRoiStartedEmitted,
+      taskCreatedAt: opts.taskCreatedAt,
+      initialTurnCount: opts.initialTurnCount
     });
     this.#tasks.set(taskId, { taskId, channelId, cwd, mode, orchestrator });
     this.#flushPendingStreamSubs(taskId, orchestrator);
@@ -91320,7 +92140,7 @@ var TaskManager = class {
   getTaskMode(taskId) {
     return this.#tasks.get(taskId)?.mode ?? "task";
   }
-  async handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName) {
+  async handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName, correlationId) {
     let task = this.#tasks.get(taskId);
     if (!task) {
       const record = await this.#deps.taskStateStore.getTask(taskId);
@@ -91337,7 +92157,10 @@ var TaskManager = class {
         },
         initialTurnStats: record.lastTurnStats,
         initialTokenCount: record.lastTokenCount,
-        initialPlanDetection: record.lastPlanDetection
+        initialPlanDetection: record.lastPlanDetection,
+        initialRoiStartedEmitted: record.roiStartedEmitted,
+        taskCreatedAt: record.createdAt,
+        initialTurnCount: record.totalTurnCount
       });
       task = this.#tasks.get(taskId);
       if (!task) {
@@ -91356,7 +92179,13 @@ var TaskManager = class {
         });
       });
     }
-    task.orchestrator.handleUserMessage(content, settings, participantId, senderDisplayName);
+    task.orchestrator.handleUserMessage(
+      content,
+      settings,
+      participantId,
+      senderDisplayName,
+      correlationId
+    );
     this.#deps.taskStateStore.bumpActivity(taskId).catch((err) => {
       this.#deps.log({
         event: "task_state_store_bump_activity_failed",
@@ -91500,7 +92329,8 @@ var TaskManager = class {
     return [...this.#tasks.values()].map((t) => ({
       taskId: t.taskId,
       channelId: t.channelId,
-      sessionState: t.orchestrator.state
+      sessionState: t.orchestrator.state,
+      cwd: t.orchestrator.cwd
     }));
   }
   has(taskId) {
@@ -91736,7 +92566,35 @@ var TaskManager = class {
       mode: opts?.mode ?? "task",
       scheduleId: opts?.scheduleId,
       collabQueuePersistence: this.#deps.collabQueuePersistence,
-      hydrationPromise: opts?.hydrationPromise
+      hydrationPromise: opts?.hydrationPromise,
+      initialRoiStartedEmitted: opts?.initialRoiStartedEmitted ?? false,
+      persistRoiStarted: async () => {
+        await this.#deps.taskStateStore.setRoiStartedEmitted(taskId, { broadcast: false });
+      },
+      taskCreatedAt: opts?.taskCreatedAt ?? Date.now(),
+      initialTurnCount: opts?.initialTurnCount ?? 0,
+      onTurnComplete: async () => {
+        await this.#deps.taskStateStore.incrementTotalTurnCount(taskId, 1, { broadcast: false });
+      },
+      getCommitScanState: async () => {
+        const record = await this.#deps.taskStateStore.getTask(taskId);
+        return {
+          lastSeenSha: record?.lastCommitScanSha ?? null,
+          attributedCommitShas: record?.attributedCommitShas ?? []
+        };
+      },
+      setLastCommitScanSha: async (sha) => {
+        await this.#deps.taskStateStore.setLastCommitScanSha(taskId, sha, { broadcast: false });
+      },
+      addAttributedCommitSha: async (sha) => {
+        await this.#deps.taskStateStore.addAttributedCommitSha(taskId, sha, { broadcast: false });
+      },
+      onConfirmedAck: (correlationId) => {
+        this.#confirmedAckEmitters.get(taskId)?.(correlationId);
+      },
+      onForwardedAck: (correlationId) => {
+        this.#forwardedAckEmitters.get(taskId)?.(correlationId);
+      }
     });
   }
 };
@@ -91753,6 +92611,37 @@ function applyStatusTransition(task, status, now) {
     attentionAt: status === "input_required" ? now : null
   };
 }
+function arraysEqual(a, b2) {
+  if (a.length !== b2.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b2[i]) return false;
+  }
+  return true;
+}
+var structuredTaskEqual = (x2, y) => {
+  if (x2.id !== y.id) return false;
+  if (x2.subject !== y.subject) return false;
+  if (x2.description !== y.description) return false;
+  if (x2.activeForm !== y.activeForm) return false;
+  if (x2.owner !== y.owner) return false;
+  if (x2.status !== y.status) return false;
+  if (x2.createdAt !== y.createdAt) return false;
+  if (x2.updatedAt !== y.updatedAt) return false;
+  if (!arraysEqual(x2.blocks, y.blocks)) return false;
+  if (!arraysEqual(x2.blockedBy, y.blockedBy)) return false;
+  return true;
+};
+function structuredTasksEqual(a, b2) {
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b2).length) return false;
+  for (const id of aKeys) {
+    const x2 = a[id];
+    const y = b2[id];
+    if (!x2 || !y) return false;
+    if (!structuredTaskEqual(x2, y)) return false;
+  }
+  return true;
+}
 function buildTaskStateStore(dataDir) {
   const store = buildJsonDocumentStore({
     filePath: join45(dataDir, "tasks.json"),
@@ -91834,6 +92723,11 @@ function buildTaskStateStore(dataDir) {
         cwd,
         totalCostUsd: 0,
         totalOutputTokens: 0,
+        totalTurnCount: 0,
+        roiStartedEmitted: false,
+        mergedAt: null,
+        attributedCommitShas: [],
+        lastCommitScanSha: null,
         mode: mode ?? "task",
         ...scheduleId ? { scheduleId } : {},
         ...scheduleName ? { scheduleName } : {},
@@ -91895,20 +92789,25 @@ function buildTaskStateStore(dataDir) {
       );
     },
     async updateStructuredTasks(taskId, tasks, todoProgress, options) {
-      const now = Date.now();
       await safeUpdate(
         taskId,
-        (task) => ({
-          ...task,
-          structuredTasks: tasks,
-          ...todoProgress && {
-            todoCompleted: todoProgress.todoCompleted,
-            todoTotal: todoProgress.todoTotal,
-            currentActivity: todoProgress.currentActivity
-          },
-          updatedAt: now,
-          lastActivityAt: now
-        }),
+        (task) => {
+          const sameTasks = structuredTasksEqual(task.structuredTasks ?? {}, tasks);
+          const sameProgress = !todoProgress || task.todoCompleted === todoProgress.todoCompleted && task.todoTotal === todoProgress.todoTotal && task.currentActivity === todoProgress.currentActivity;
+          if (sameTasks && sameProgress) return task;
+          const now = Date.now();
+          return {
+            ...task,
+            structuredTasks: tasks,
+            ...todoProgress && {
+              todoCompleted: todoProgress.todoCompleted,
+              todoTotal: todoProgress.todoTotal,
+              currentActivity: todoProgress.currentActivity
+            },
+            updatedAt: now,
+            lastActivityAt: now
+          };
+        },
         options
       );
     },
@@ -92004,7 +92903,48 @@ function buildTaskStateStore(dataDir) {
       await safeUpdate(
         taskId,
         (task) => task.abandonedAt != null ? task : { ...task, abandonedAt: timestamp },
-        { broadcast: false, ...options }
+        { ...options, broadcast: false }
+      );
+    },
+    async setRoiStartedEmitted(taskId, options) {
+      await safeUpdate(
+        taskId,
+        (task) => task.roiStartedEmitted ? task : { ...task, roiStartedEmitted: true },
+        { ...options, broadcast: false }
+      );
+    },
+    async setMergedAt(taskId, mergedAt, options) {
+      await safeUpdate(taskId, (task) => task.mergedAt != null ? task : { ...task, mergedAt }, {
+        ...options,
+        broadcast: false
+      });
+    },
+    async setLastCommitScanSha(taskId, sha, options) {
+      await safeUpdate(
+        taskId,
+        (task) => task.lastCommitScanSha === sha ? task : { ...task, lastCommitScanSha: sha },
+        { ...options, broadcast: false }
+      );
+    },
+    async addAttributedCommitSha(taskId, sha, options) {
+      await safeUpdate(
+        taskId,
+        (task) => {
+          if (task.attributedCommitShas.includes(sha)) return task;
+          const next = [...task.attributedCommitShas, sha];
+          return {
+            ...task,
+            attributedCommitShas: next.length > 50 ? next.slice(next.length - 50) : next
+          };
+        },
+        { ...options, broadcast: false }
+      );
+    },
+    async incrementTotalTurnCount(taskId, delta = 1, options) {
+      await safeUpdate(
+        taskId,
+        (task) => ({ ...task, totalTurnCount: task.totalTurnCount + delta }),
+        { ...options, broadcast: false }
       );
     },
     async sweepToInputRequired(taskId, options) {
@@ -94125,9 +95065,58 @@ async function createDaemon(deps) {
   const abandonedSweeper = createAbandonedSweeper({
     listTasks: () => taskStateStore.listTasks(),
     setAbandonedAt: (taskId, timestamp) => taskStateStore.setAbandonedAt(taskId, timestamp),
+    onTaskAbandoned: (taskId, task, abandonedAt) => {
+      if (task.taskStartedAt == null && (task.totalTurnCount ?? 0) === 0) return;
+      emitTaskEnded(deps.metricsCollector, {
+        taskId,
+        userId: deps.auth.userId,
+        finalStatus: "input_required",
+        totalCostUsd: task.totalCostUsd ?? 0,
+        totalOutputTokens: task.totalOutputTokens ?? 0,
+        turnCount: task.totalTurnCount ?? 0,
+        durationMs: Math.max(0, abandonedAt - task.createdAt),
+        timestamp: abandonedAt
+      });
+    },
     log: (entry) => deps.log(entry)
   });
   abandonedSweeper.start();
+  const commitSweepService = new CommitSweepService({
+    metricsCollector: deps.metricsCollector,
+    log: (entry) => deps.log(entry),
+    setLastCommitScanSha: (taskId, sha) => taskStateStore.setLastCommitScanSha(taskId, sha, { broadcast: false }),
+    addAttributedCommitSha: (taskId, sha) => taskStateStore.addAttributedCommitSha(taskId, sha, { broadcast: false }),
+    injectTrailer: injectShipyardTrailer,
+    /**
+     * Periodic sweep never amends HEAD — a zero-cost trailer injected here
+     * would permanently block future in-session scans from attributing the
+     * same commit with real cost (hasShipyardTrailer skips already-trailered
+     * commits). External commits are emitted as 'extended' instead (no
+     * git-amend, attributed for bookkeeping only). See amendHead: false below.
+     */
+    amendHead: false,
+    getAttributionPayload: (taskId) => ({
+      model: "unknown",
+      tokens: 0,
+      costUsd: 0,
+      turnCount: 0,
+      sessionId: `periodic-sweep-${taskId}`
+    }),
+    getActiveTasks: () => taskManager.listManagedTasks().map(({ taskId, cwd }) => ({
+      taskId,
+      cwd: cwd ?? deps.workspaceRoot,
+      userId: deps.auth.userId
+    })),
+    getTaskAttribution: async (taskId) => {
+      const record = await taskStateStore.getTask(taskId);
+      return {
+        lastSeenSha: record?.lastCommitScanSha ?? null,
+        attributedCommitShas: record?.attributedCommitShas ?? [],
+        userId: deps.auth.userId
+      };
+    }
+  });
+  commitSweepService.start();
   const awarenessSampler = createLoroAwarenessSampler({
     getRepo: () => repo,
     listTaskIds: () => taskManager.listManagedTasks().map((t) => t.taskId),
@@ -94141,6 +95130,7 @@ async function createDaemon(deps) {
   async function dispose() {
     awarenessSampler.stop();
     abandonedSweeper.stop();
+    commitSweepService.stop();
     scheduleEvaluator.dispose();
     preWarmManager.dispose();
     compactor?.dispose();
@@ -94531,6 +95521,7 @@ function filterOutboundForCollab(msg, collabTaskId) {
     /** Task-scoped: pass through only if taskId matches */
     case "task_state_update":
     case "task_removed":
+    case "task_created_ack":
     case "permission_request":
     case "permission_resolved":
     case "pr_action_result":
@@ -94774,7 +95765,7 @@ function routeMessage(msg, callbacks, log) {
       );
       break;
     case "update_settings":
-      callbacks.onUpdateSettings(msg.settings);
+      callbacks.onUpdateSettings(msg.settings, msg.correlationId);
       break;
     case "update_task_settings":
       callbacks.onUpdateTaskSettings(msg.taskId, msg.settings);
@@ -96356,6 +97347,31 @@ function sendPluginAuthStatusesIfTokens(handler, tokenStore, logAdapter) {
     });
   });
 }
+async function emitTaskCreatedAck(controlHandler, daemon, taskId, templateId, logAdapter) {
+  try {
+    const template = templateId ? await daemon.templateStore.get(templateId) ?? null : null;
+    controlHandler.sendControl({
+      type: "task_created_ack",
+      taskId,
+      templateId: templateId ?? null,
+      appliedTemplate: template ? {
+        templateId: template.id,
+        todos: template.items.map((item2) => ({
+          id: item2.id,
+          content: item2.content,
+          deps: item2.deps
+        }))
+      } : null
+    });
+  } catch (err) {
+    logAdapter({
+      event: "task_created_ack_failed",
+      taskId,
+      templateId: templateId ?? null,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
   const dc = narrow(rawChannel);
   const wsRoot = deps?.workspaceRoot ?? findProjectRoot(process.cwd());
@@ -96430,11 +97446,128 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     logAdapter
   });
   const prAttributedTaskIds = /* @__PURE__ */ new Set();
+  const prMergedTaskIds = /* @__PURE__ */ new Set();
+  const seedReadyPromise = daemon.taskStateStore.listTasks().then((tasks) => {
+    for (const [taskId, record] of Object.entries(tasks)) {
+      if (record.prUrl != null) prAttributedTaskIds.add(taskId);
+      if (record.mergedAt != null) prMergedTaskIds.add(taskId);
+    }
+  }).catch((err) => {
+    logAdapter({
+      event: "pr_sets_seed_failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+  const defaultBranchCache2 = /* @__PURE__ */ new Map();
+  async function resolveDefaultBranch2(cwd) {
+    const cached2 = defaultBranchCache2.get(cwd);
+    if (cached2) return cached2;
+    let resolved;
+    try {
+      const branch = await run(
+        "gh",
+        ["repo", "view", "--json", "defaultBranchRef", "-q", ".defaultBranchRef.name"],
+        cwd
+      );
+      const trimmed = branch.trim();
+      if (!trimmed) {
+        return "main";
+      }
+      resolved = trimmed;
+    } catch {
+      return "main";
+    }
+    defaultBranchCache2.set(cwd, resolved);
+    return resolved;
+  }
+  async function findCommitByTrailer(cwd, trunk, taskId) {
+    const sha = await run(
+      "git",
+      ["log", `origin/${trunk}`, `--grep=Shipyard-Task-Id: ${taskId}`, "-n1", "--pretty=%H"],
+      cwd
+    ).catch(() => "");
+    return sha.trim() || null;
+  }
+  async function detectMergeIfNew(pr, taskId, cwd) {
+    if (pr.state === "merged" || pr.mergeCommitSha != null) {
+      return {
+        merged: true,
+        method: "github_native",
+        sha: pr.mergeCommitSha,
+        at: pr.mergedAt ?? Date.now()
+      };
+    }
+    if (pr.state === "closed" && pr.headCommitInBase) {
+      return {
+        merged: true,
+        method: "graphite_queue",
+        sha: pr.headRefSha,
+        at: Date.now()
+      };
+    }
+    if (pr.state === "closed") {
+      const trunk = await resolveDefaultBranch2(cwd);
+      await run("git", ["fetch", "origin", trunk, "--quiet"], cwd, 1e4).catch((err) => {
+        logAdapter({
+          event: "roi_tier3_fetch_failed",
+          taskId,
+          trunk,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      const sha = await findCommitByTrailer(cwd, trunk, taskId);
+      if (sha) {
+        return { merged: true, method: "graphite_queue", sha, at: Date.now() };
+      }
+    }
+    return { merged: false };
+  }
   const prPoller = createPRPoller(
     {
       onPRState: (payload) => {
         controlHandler.sendControl({ type: "pr_state", data: payload });
-        attributePrIfFirstDiscovery(payload);
+        seedReadyPromise.then(() => {
+          attributePrIfFirstDiscovery(payload);
+          const pr = payload.currentBranchPR;
+          if (!pr || prMergedTaskIds.has(payload.taskId)) return;
+          const { taskId } = payload;
+          const cwd = prPoller.getCwd(taskId);
+          if (!cwd) return;
+          prMergedTaskIds.add(taskId);
+          detectMergeIfNew(pr, taskId, cwd).then((result) => {
+            if (!result.merged) {
+              prMergedTaskIds.delete(taskId);
+              return;
+            }
+            daemon.taskStateStore.setMergedAt(taskId, result.at).catch((err) => {
+              logAdapter({
+                event: "roi_pr_merged_store_failed",
+                taskId,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            });
+            const remote = parseOwnerRepo(pr.url);
+            const repoKey = remote ? `${remote.owner}/${remote.repo}` : pr.url;
+            emitPrMerged(daemon.metricsCollector, {
+              taskId,
+              userId: daemon.userId,
+              prUrl: pr.url,
+              prNumber: pr.number,
+              repo: repoKey,
+              mergeCommitSha: result.sha,
+              mergeMethod: result.method,
+              mergedAt: result.at
+            });
+          }).catch((err) => {
+            prMergedTaskIds.delete(taskId);
+            logAdapter({
+              event: "roi_pr_merged_detection_failed",
+              taskId,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          });
+        }).catch(() => {
+        });
       }
     },
     prPollerLog
@@ -96521,7 +97654,7 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           senderParticipantId
         );
       },
-      onUpdateSettings: (settings) => {
+      onUpdateSettings: (settings, correlationId) => {
         if (settings.disabledMcpServers && daemon.capabilities.mcpServers) {
           const prevDisabled = new Set(
             daemon.capabilities.mcpServers.filter((s2) => !s2.enabled).map((s2) => s2.name)
@@ -96547,7 +97680,11 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
             });
           });
         }
-        handler.sendControl({ type: "settings_ack", settings });
+        handler.sendControl({
+          type: "settings_ack",
+          settings,
+          ...correlationId !== void 0 && { correlationId }
+        });
         logAdapter({ event: "settings_updated", settings });
       },
       onUpdateTaskSettings: (taskId, settings) => {
@@ -96982,6 +98119,7 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
       },
       onCreateTask: (taskId, channelId, title, cwd, mode, templateId) => {
         daemon.taskManager.createTask({ taskId, channelId, title, cwd, mode, templateId });
+        void emitTaskCreatedAck(controlHandler, daemon, taskId, templateId, logAdapter);
       },
       onPromoteTask: (taskId) => {
         daemon.taskManager.promoteTask(taskId);
@@ -97737,7 +98875,7 @@ function createCollabRoomManager(deps) {
     getParticipantsForTask(taskId) {
       for (const room of rooms.values()) {
         if (room.taskId === taskId) {
-          return room.participants.map((p2) => ({ name: p2.username, role: p2.role }));
+          return room.participants.filter((p2) => p2.userId !== room.myUserId).map((p2) => ({ name: p2.username, role: p2.role }));
         }
       }
       return [];
@@ -97998,13 +99136,21 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
     respond({ type: "error", requestId, error: error2 });
   }
   function safePath(userPath) {
+    return safePathWithOverrides(userPath, null);
+  }
+  function safePathForRead(userPath) {
+    return safePathWithOverrides(userPath, /* @__PURE__ */ new Set(["node_modules"]));
+  }
+  function safePathWithOverrides(userPath, allowedHiddenNames) {
     const normalized = normalize6(userPath);
     if (normalized.startsWith("..") || normalized.includes("/..") || normalized.includes("\\..")) {
       return null;
     }
     const segments = normalized.split(/[/\\]/).filter((s2) => s2.length > 0 && s2 !== ".");
     for (const seg of segments) {
-      if (isHidden(seg)) return null;
+      if (!isHidden(seg)) continue;
+      if (allowedHiddenNames?.has(seg)) continue;
+      return null;
     }
     const abs = resolve2(cwd, normalized);
     const rel = relative3(cwd, abs);
@@ -98031,7 +99177,8 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
   function validatePath(msg) {
     const abs = safePath(msg.path);
     if (!abs) {
-      respondError(msg.requestId, "Invalid path");
+      log({ event: "file_io_path_rejected", path: msg.path });
+      respondError(msg.requestId, `hidden_path:${msg.path}`);
       return null;
     }
     return { abs, rel: relative3(cwd, abs) };
@@ -98063,10 +99210,11 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
     }
   }
   function dispatchFileOp(msg) {
-    const abs = safePath(msg.path);
+    const isReadOnlyOp = msg.type === "read_file" || msg.type === "stat";
+    const abs = isReadOnlyOp ? safePathForRead(msg.path) : safePath(msg.path);
     if (!abs) {
       log({ event: "file_io_path_rejected", path: msg.path });
-      respondError(msg.requestId, "Invalid path");
+      respondError(msg.requestId, `hidden_path:${msg.path}`);
       return;
     }
     switch (msg.type) {
@@ -98232,7 +99380,7 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
       }
       cwd = canonical;
       log({ event: "file_io_cwd_changed", cwd: canonical });
-      respond({ type: "set_cwd_ack", requestId });
+      respond({ type: "set_cwd_ack", requestId, canonical });
       for (const listener of cwdChangeListeners) {
         listener(canonical);
       }
@@ -98282,13 +99430,19 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
     try {
       const { stdout } = await execFileAsync3("git", args, {
         cwd,
-        maxBuffer: 10 * 1024 * 1024
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 1e4,
+        killSignal: "SIGKILL"
       });
       const parsed = parseGitGrepOutput(stdout, maxResults);
+      const filteredMatches = parsed.matches.filter((m2) => {
+        const segments = m2.path.split(/[/\\]/).filter((s2) => s2.length > 0 && s2 !== ".");
+        return segments.every((seg) => !isHidden(seg) || seg === "node_modules");
+      });
       respond({
         type: "git_grep_result",
         requestId,
-        matches: parsed.matches,
+        matches: filteredMatches,
         truncated: parsed.truncated
       });
     } catch (err) {
@@ -98838,22 +99992,34 @@ function handleMessageChannel(opts) {
     peerRole,
     senderDisplayName
   } = opts;
-  let catchUpInProgress = false;
-  const bufferedLiveMessages = [];
-  const unsubscribe = store.subscribe(channelId, (message) => {
-    const outgoing = { type: "message", message };
-    if (catchUpInProgress) {
-      bufferedLiveMessages.push(outgoing);
-      return;
-    }
-    send(JSON.stringify(outgoing));
-  });
+  const inFlightCorrelations = /* @__PURE__ */ new Set();
   function sendError(error2) {
     send(JSON.stringify({ type: "error", error: error2 }));
   }
   function formatError2(err) {
     return err instanceof Error ? err.message : String(err);
   }
+  function sendAck(correlationId, stage, error2) {
+    const ack = error2 ? { type: "send_message_ack", correlationId, stage, error: error2 } : { type: "send_message_ack", correlationId, stage };
+    send(JSON.stringify(ack));
+  }
+  let unregisterConfirmedEmitter = null;
+  if (opts.registerConfirmedAckEmitter) {
+    unregisterConfirmedEmitter = opts.registerConfirmedAckEmitter((correlationId) => {
+      if (inFlightCorrelations.has(correlationId)) {
+        inFlightCorrelations.delete(correlationId);
+        sendAck(correlationId, "confirmed");
+      }
+    });
+  }
+  let unregisterForwardedEmitter = null;
+  if (opts.registerForwardedAckEmitter) {
+    unregisterForwardedEmitter = opts.registerForwardedAckEmitter((correlationId) => {
+      if (inFlightCorrelations.has(correlationId)) {
+        sendAck(correlationId, "forwarded");
+      }
+    });
+  }
   function parseAndValidate(data) {
     let raw;
     try {
@@ -98873,14 +100039,51 @@ function handleMessageChannel(opts) {
     }
     return result.data;
   }
+  let catchUpInProgress = false;
+  const bufferedLiveMessages = [];
+  const unsubscribe = store.subscribe(channelId, (message) => {
+    const outgoing = { type: "message", message };
+    if (catchUpInProgress) {
+      bufferedLiveMessages.push(outgoing);
+      return;
+    }
+    send(JSON.stringify(outgoing));
+  });
   async function handleSendMessage2(msg) {
+    const { correlationId } = msg;
     try {
+      sendAck(correlationId, "accepted");
       const settings = {
         model: msg.model,
         reasoningEffort: msg.reasoningEffort,
         permissionMode: msg.permissionMode,
         fastMode: msg.fastMode
       };
+      const appendResult = await store.appendMessageDeduped(
+        {
+          messageId: crypto.randomUUID(),
+          channelId,
+          participantId: participantId ?? "human:unknown",
+          senderKind: "human",
+          content: msg.content,
+          timestamp: Date.now(),
+          correlationId,
+          model: settings.model ?? null,
+          reasoningEffort: settings.reasoningEffort ?? null,
+          permissionMode: settings.permissionMode ?? null
+        },
+        {}
+      );
+      if (appendResult.isDuplicate) {
+        log({
+          event: "jsonl_dedup_correlation",
+          taskId,
+          correlationId,
+          dedupKey: appendResult.dedupKey
+        });
+      }
+      sendAck(correlationId, "persisted");
+      inFlightCorrelations.add(correlationId);
       if (opts.onUserMessage) {
         opts.onUserMessage(msg.content, settings, msg.cwd, participantId, senderDisplayName);
       } else {
@@ -98890,12 +100093,14 @@ function handleMessageChannel(opts) {
           settings,
           msg.cwd,
           participantId,
-          senderDisplayName
+          senderDisplayName,
+          correlationId
         );
       }
     } catch (err) {
-      sendError(formatError2(err));
-      log({ event: "message_handler_error", taskId, error: formatError2(err) });
+      sendAck(correlationId, "rejected", formatError2(err));
+      inFlightCorrelations.delete(correlationId);
+      log({ event: "message_handler_error", taskId, correlationId, error: formatError2(err) });
     }
   }
   function flushBufferedMessages() {
@@ -98905,8 +100110,48 @@ function handleMessageChannel(opts) {
     }
     bufferedLiveMessages.length = 0;
   }
+  function classifyCorrelationStatus(cid, persisted) {
+    const stored = persisted.get(cid);
+    if (stored === "confirmed") return "confirmed";
+    if (stored === "persisted") return inFlightCorrelations.has(cid) ? "forwarded" : "persisted";
+    return "unknown";
+  }
+  function buildPersistedMap(messages) {
+    const persisted = /* @__PURE__ */ new Map();
+    for (const m2 of messages) {
+      if (m2.correlationId) {
+        const status = m2.sdkUuid ? "confirmed" : "persisted";
+        persisted.set(m2.correlationId, status);
+        for (const secondary of m2.batchCorrelationIds ?? []) {
+          persisted.set(secondary, status);
+        }
+      }
+    }
+    return persisted;
+  }
+  function sendCorrelationSnapshot(inFlightIds, persisted) {
+    const entries = inFlightIds.map((cid) => ({
+      correlationId: cid,
+      status: classifyCorrelationStatus(cid, persisted)
+    }));
+    const snapshot = { type: "correlation_status_snapshot", entries };
+    send(JSON.stringify(snapshot));
+  }
   function handleSubscribe(msg) {
     catchUpInProgress = true;
+    if (msg.inFlightCorrelationIds && msg.inFlightCorrelationIds.length > 0) {
+      const inFlightIds = msg.inFlightCorrelationIds;
+      store.getMessages(channelId).then((messages) => {
+        const persisted = buildPersistedMap(messages);
+        for (const cid of inFlightIds) {
+          if (persisted.get(cid) === "persisted") {
+            inFlightCorrelations.add(cid);
+          }
+        }
+        sendCorrelationSnapshot(inFlightIds, persisted);
+      }).catch(() => {
+      });
+    }
     if (msg.maxMessages && msg.sinceSeqNo === 0) {
       const limit = msg.maxMessages;
       store.getMessagesBefore(channelId, Number.POSITIVE_INFINITY, limit).then(({ messages: page }) => {
@@ -99040,6 +100285,11 @@ function handleMessageChannel(opts) {
     sendStreamDelta,
     dispose() {
       unsubscribe();
+      unregisterConfirmedEmitter?.();
+      unregisterConfirmedEmitter = null;
+      unregisterForwardedEmitter?.();
+      unregisterForwardedEmitter = null;
+      inFlightCorrelations.clear();
     }
   };
 }
@@ -99566,6 +100816,10 @@ function attachConversationHandler(daemon, dc, channelId, params, log, attempts)
     taskManager: daemon.taskManager,
     store: daemon.store,
     log,
+    ...!threadId && {
+      registerConfirmedAckEmitter: (emitter) => daemon.taskManager.registerConfirmedAckEmitter(taskId, emitter),
+      registerForwardedAckEmitter: (emitter) => daemon.taskManager.registerForwardedAckEmitter(taskId, emitter)
+    },
     ...peer && {
       participantId: peer.participantId,
       peerRole: peer.peerRole,
@@ -101706,7 +102960,9 @@ async function serve(options = {}) {
   const shipyardHome = options.shipyardHome ?? getShipyardHome();
   const dataDir = join55(shipyardHome, options.isDev ? "data-dev" : "data");
   const log = createChildLogger({ mode: "serve" });
-  const workspaceRoot = findProjectRoot(process.cwd());
+  const workspaceRoot = await realpath2(findProjectRoot(process.cwd())).catch(
+    () => findProjectRoot(process.cwd())
+  );
   registerBuiltinPlugins();
   const pluginConfigStore = buildPluginConfigStore(join55(dataDir, "plugins"));
   await mkdir24(dataDir, { recursive: true });
@@ -102048,4 +103304,4 @@ export {
   _testing,
   serve
 };
-//# sourceMappingURL=serve-3EFFP3PN.js.map
+//# sourceMappingURL=serve-P5WC5JIT.js.map