@adhdev/daemon-standalone 1.0.41 → 1.0.42-rc.2

package/dist/index.js

@@ -31423,9 +31423,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/b4a/index.js
+// ../../node_modules/tar-stream/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
+  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31581,9 +31581,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/headers.js
+// ../../node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
+  "../../node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -31844,9 +31844,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/extract.js
+// ../../node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32189,9 +32189,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/constants.js
+// ../../node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32210,9 +32210,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/pack.js
+// ../../node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32445,9 +32445,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/index.js
+// ../../node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
+  "../../node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32690,9 +32690,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-fs/index.js
+// ../../node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
+  "../../node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "dc9692fede78fb48fa51439a40fe9436b0b08df0" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "dc9692f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.41" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-10T07:09:00.605Z" : void 0);
+      const commit = readInjected(true ? "887aef0e08676616ce97395698e7690167982603" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "887aef0e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.42-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-10T17:37:45.509Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -36826,9 +36826,9 @@ var require_dist3 = __commonJS({
       const effectiveOptions = options.timeoutMs === void 0 ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
       const cacheKey = statusCacheKey(workspace, options);
       if (!options.forceFresh) {
-        const cached4 = lastKnownGoodStatus.get(cacheKey);
-        if (cached4 && lastCheckedAt - cached4.cachedAt < GIT_STATUS_CACHE_TTL_MS) {
-          return cached4.status;
+        const cached5 = lastKnownGoodStatus.get(cacheKey);
+        if (cached5 && lastCheckedAt - cached5.cachedAt < GIT_STATUS_CACHE_TTL_MS) {
+          return cached5.status;
         }
       }
       try {
@@ -36839,10 +36839,10 @@ var require_dist3 = __commonJS({
       } catch (error48) {
         const gitError = error48 instanceof GitCommandError ? error48 : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 });
         if (isTransientGitFailure(gitError)) {
-          const cached4 = lastKnownGoodStatus.get(cacheKey)?.status;
-          if (cached4) {
+          const cached5 = lastKnownGoodStatus.get(cacheKey)?.status;
+          if (cached5) {
             return {
-              ...cached4,
+              ...cached5,
               lastCheckedAt,
               upstreamStatus: "unavailable",
               error: gitError.stderr || gitError.message,
@@ -37065,9 +37065,9 @@ var require_dist3 = __commonJS({
         return { config: null, sourceKey: "no-repo-root" };
       }
       const loaded = loadChangeImpactConfig(repoRoot);
-      const cached4 = changeImpactConfigCache.get(repoRoot);
-      if (cached4 && cached4.sourceKey === loaded.sourceKey) {
-        return { config: cached4.config, sourceKey: loaded.sourceKey };
+      const cached5 = changeImpactConfigCache.get(repoRoot);
+      if (cached5 && cached5.sourceKey === loaded.sourceKey) {
+        return { config: cached5.config, sourceKey: loaded.sourceKey };
       }
       const config2 = loaded.sourceType === "repo_file" ? loaded.config ?? null : null;
       changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config: config2 });
@@ -37817,7 +37817,7 @@ var require_dist3 = __commonJS({
       }
     });
     function resolveBuildTrack(env2 = process.env) {
-      const injected = true ? "" : void 0;
+      const injected = true ? "preview" : void 0;
       const stamped = typeof injected === "string" ? injected.trim() : "";
       const raw = (stamped || (env2[BUILD_CHANNEL_ENV_VAR] ?? "").trim()).toLowerCase();
       return raw === "preview" || raw === "next" ? "preview" : "stable";
@@ -51154,8 +51154,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function getCachedRawEntries(meshId) {
       const now = Date.now();
-      const cached4 = ledgerReadCache.get(meshId);
-      if (cached4 && now - cached4.cachedAt < LEDGER_CACHE_TTL_MS) return cached4.entries;
+      const cached5 = ledgerReadCache.get(meshId);
+      if (cached5 && now - cached5.cachedAt < LEDGER_CACHE_TTL_MS) return cached5.entries;
       let entries;
       try {
         entries = readLedgerFromStore(meshId);
@@ -55357,13 +55357,13 @@ ${rendered}`, "utf-8");
         nodes
       };
     }
-    function reconcileInlineMeshCache(cached4, incoming, removedNodeIds) {
-      if (!cached4 || typeof cached4 !== "object" || Array.isArray(cached4)) return incoming;
-      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached4;
-      const cachedNodes = Array.isArray(cached4.nodes) ? cached4.nodes : [];
+    function reconcileInlineMeshCache(cached5, incoming, removedNodeIds) {
+      if (!cached5 || typeof cached5 !== "object" || Array.isArray(cached5)) return incoming;
+      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached5;
+      const cachedNodes = Array.isArray(cached5.nodes) ? cached5.nodes : [];
       const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
-      if (!cachedNodes.length || !incomingNodes.length) return { ...cached4, ...incoming };
-      const cachedUpdatedAt = Date.parse(readStringValue(cached4.updatedAt, cached4.updated_at) || "");
+      if (!cachedNodes.length || !incomingNodes.length) return { ...cached5, ...incoming };
+      const cachedUpdatedAt = Date.parse(readStringValue(cached5.updatedAt, cached5.updated_at) || "");
       const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || "");
       const cacheFieldsWinOnConflict = Number.isFinite(cachedUpdatedAt) && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
       const cachedById = /* @__PURE__ */ new Map();
@@ -55393,10 +55393,10 @@ ${rendered}`, "utf-8");
         nodes.push(cachedNode);
       }
       if (droppedNodeIds.length > 0) {
-        LOG2.info("Mesh", `[NodeMembershipMerge] mesh=${String(cached4.id || incoming.id || "unknown")} droppedNodeIds=${JSON.stringify(droppedNodeIds)} reason=tombstoned_removal cachedCount=${cachedNodes.length} incomingCount=${incomingNodes.length}`);
+        LOG2.info("Mesh", `[NodeMembershipMerge] mesh=${String(cached5.id || incoming.id || "unknown")} droppedNodeIds=${JSON.stringify(droppedNodeIds)} reason=tombstoned_removal cachedCount=${cachedNodes.length} incomingCount=${incomingNodes.length}`);
       }
       return {
-        ...cached4,
+        ...cached5,
         ...incoming,
         nodes
       };
@@ -56332,9 +56332,9 @@ ${rendered}`, "utf-8");
            */
           async probe(daemonId, workspace, probe) {
             const key2 = this.key(daemonId, workspace);
-            const cached4 = this.recent.get(key2);
-            if (cached4 && this.now() - cached4.at < this.reuseMs) {
-              return cached4.value;
+            const cached5 = this.recent.get(key2);
+            if (cached5 && this.now() - cached5.at < this.reuseMs) {
+              return cached5.value;
             }
             const existing = this.inflight.get(key2);
             if (existing) return existing;
@@ -58478,11 +58478,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       return path18.join(getConfigDir2(), "history");
     }
     function readBoundedTailCache(key2, signature) {
-      const cached4 = boundedTailReadCache.get(key2);
-      if (!cached4 || cached4.signature !== signature) return null;
+      const cached5 = boundedTailReadCache.get(key2);
+      if (!cached5 || cached5.signature !== signature) return null;
       boundedTailReadCache.delete(key2);
-      boundedTailReadCache.set(key2, cached4);
-      return cached4.result;
+      boundedTailReadCache.set(key2, cached5);
+      return cached5.result;
     }
     function writeBoundedTailCache(key2, signature, result) {
       boundedTailReadCache.delete(key2);
@@ -58966,9 +58966,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       for (const file2 of files.slice().sort()) {
         const filePath = path18.join(dir, file2);
         const signature = fileSignatures.get(file2) || `${file2}:missing`;
-        const cached4 = savedHistoryFileSummaryCache.get(filePath);
+        const cached5 = savedHistoryFileSummaryCache.get(filePath);
         const persisted = persistedEntries.get(file2);
-        const reusableEntry = cached4?.signature === signature ? cached4 : persisted?.signature === signature ? persisted : null;
+        const reusableEntry = cached5?.signature === signature ? cached5 : persisted?.signature === signature ? persisted : null;
         const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file2);
         const nextEntry = reusableEntry || {
           signature,
@@ -59118,16 +59118,16 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         incrementalTailCache.delete(filePath);
         return { lines: [], coversWholeFile: true };
       }
-      const cached4 = incrementalTailCache.get(filePath);
-      if (cached4) {
-        if (cached4.size === size && cached4.mtimeMs === mtimeMs) {
+      const cached5 = incrementalTailCache.get(filePath);
+      if (cached5) {
+        if (cached5.size === size && cached5.mtimeMs === mtimeMs) {
           incrementalTailCache.delete(filePath);
-          incrementalTailCache.set(filePath, cached4);
-          if (cached4.coversWholeFile || cached4.lines.length >= needed) {
-            return { lines: cached4.lines, coversWholeFile: cached4.coversWholeFile };
+          incrementalTailCache.set(filePath, cached5);
+          if (cached5.coversWholeFile || cached5.lines.length >= needed) {
+            return { lines: cached5.lines, coversWholeFile: cached5.coversWholeFile };
           }
-        } else if (size > cached4.size) {
-          const incremental = tryIncrementalTailGrowth(filePath, cached4, size, mtimeMs, needed);
+        } else if (size > cached5.size) {
+          const incremental = tryIncrementalTailGrowth(filePath, cached5, size, mtimeMs, needed);
           if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
         }
         incrementalTailCache.delete(filePath);
@@ -59153,22 +59153,22 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
       return { lines: result.lines, coversWholeFile: result.coversWholeFile };
     }
-    function tryIncrementalTailGrowth(filePath, cached4, size, mtimeMs, needed) {
+    function tryIncrementalTailGrowth(filePath, cached5, size, mtimeMs, needed) {
       const fd = fs10.openSync(filePath, "r");
       try {
-        if (cached4.size > 0) {
+        if (cached5.size > 0) {
           const boundary = Buffer.alloc(1);
-          fs10.readSync(fd, boundary, 0, 1, cached4.size - 1);
+          fs10.readSync(fd, boundary, 0, 1, cached5.size - 1);
           if (boundary[0] !== 10) return null;
         }
-        const appendedLength = size - cached4.size;
+        const appendedLength = size - cached5.size;
         const appended = Buffer.alloc(appendedLength);
-        fs10.readSync(fd, appended, 0, appendedLength, cached4.size);
+        fs10.readSync(fd, appended, 0, appendedLength, cached5.size);
         const newLines = appended.toString("utf-8").split("\n");
         if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
-        const merged = cached4.lines.concat(newLines);
+        const merged = cached5.lines.concat(newLines);
         const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
-        const coversWholeFile = cached4.coversWholeFile && trimmed.length === merged.length;
+        const coversWholeFile = cached5.coversWholeFile && trimmed.length === merged.length;
         storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
         if (coversWholeFile || trimmed.length >= needed) {
           return { lines: trimmed, coversWholeFile };
@@ -59233,8 +59233,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
           const cacheKey = `${sanitized}\0${historySessionId || ""}\0${offset}\0${limit}\0${excludeRecentCount}\0${historyBehavior?.collapseConsecutiveAssistantTurns ? "1" : "0"}`;
           const signature = buildSavedHistoryCacheSignature(files, fileSignatures);
-          const cached4 = readBoundedTailCache(cacheKey, signature);
-          if (cached4) return cached4;
+          const cached5 = readBoundedTailCache(cacheKey, signature);
+          if (cached5) return cached5;
           const numericLimit = Math.max(1, Number(limit));
           const numericOffset = Math.max(0, Number(offset));
           const numericExclude = Math.max(0, Number(excludeRecentCount));
@@ -59277,23 +59277,23 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           savedHistorySessionCache.delete(sanitized);
           return { sessions: [], hasMore: false };
         }
-        const cached4 = savedHistorySessionCache.get(sanitized);
+        const cached5 = savedHistorySessionCache.get(sanitized);
         const offset = Math.max(0, options.offset || 0);
         const limit = Math.max(1, options.limit || 30);
         const indexSignature = buildSavedHistoryIndexFileSignature(dir);
         let cacheWasInvalidated = false;
-        if (cached4) {
-          const cacheLooksPersisted = cached4.signature.startsWith("index:");
-          const cacheStillValid = cacheLooksPersisted ? cached4.signature === indexSignature : (() => {
+        if (cached5) {
+          const cacheLooksPersisted = cached5.signature.startsWith("index:");
+          const cacheStillValid = cacheLooksPersisted ? cached5.signature === indexSignature : (() => {
             const files2 = listHistoryFiles(dir);
             const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
-            return cached4.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+            return cached5.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
           })();
           if (cacheStillValid) {
-            const sliced2 = cached4.summaries.slice(offset, offset + limit);
+            const sliced2 = cached5.summaries.slice(offset, offset + limit);
             return {
               sessions: sliced2,
-              hasMore: cached4.summaries.length > offset + limit
+              hasMore: cached5.summaries.length > offset + limit
             };
           }
           cacheWasInvalidated = true;
@@ -59474,6 +59474,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return {
         records,
+        turnTerminalMarkers: Array.isArray(result.turnTerminalMarkers) ? result.turnTerminalMarkers : void 0,
         sourcePath: typeof result.sourcePath === "string" ? result.sourcePath : "",
         sourceMtimeMs: Number(result.sourceMtimeMs) || 0,
         providerSessionId: typeof result.providerSessionId === "string" ? result.providerSessionId.trim() : void 0,
@@ -59541,7 +59542,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           partialReason: nativeResult.partialReason,
           unavailableReason: nativeResult.unavailableReason,
           ownerConfirmed: nativeResult.ownerConfirmed,
-          attribution: nativeResult.attribution
+          attribution: nativeResult.attribution,
+          // (NATIVE-TURN-SIGNAL) Terminal markers ride alongside the paged messages —
+          // deliberately NOT paged, since they are turn metadata, not chat content.
+          turnTerminalMarkers: nativeResult.turnTerminalMarkers
         };
       }
       return {
@@ -64363,8 +64367,8 @@ ${cleanBody}`;
     }
     function getCachedMeshByWorkspace(workspace) {
       const now = Date.now();
-      const cached4 = meshByWorkspaceCache.get(workspace);
-      if (cached4 && now - cached4.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached4.mesh;
+      const cached5 = meshByWorkspaceCache.get(workspace);
+      if (cached5 && now - cached5.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached5.mesh;
       const mesh = getMeshByRepo(workspace);
       meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
       return mesh;
@@ -66022,8 +66026,8 @@ ${cleanBody}`;
       }
     }
     function getHoldState(synthKey, meshId) {
-      const cached4 = inFlightAckedHoldState.get(synthKey);
-      if (cached4) return cached4;
+      const cached5 = inFlightAckedHoldState.get(synthKey);
+      if (cached5) return cached5;
       const store = holdStore();
       if (!store) return void 0;
       let row;
@@ -66878,9 +66882,9 @@ ${cleanBody}`;
           return;
         }
         try {
-          const cached4 = deps.getCachedInlineMesh?.(meshId);
-          if (cached4 && deps.removeInlineMeshNode) {
-            if (deps.removeInlineMeshNode(meshId, cached4, nodeId)) removed = true;
+          const cached5 = deps.getCachedInlineMesh?.(meshId);
+          if (cached5 && deps.removeInlineMeshNode) {
+            if (deps.removeInlineMeshNode(meshId, cached5, nodeId)) removed = true;
           }
         } catch {
         }
@@ -71204,6 +71208,55 @@ ${cont}` : cont;
         init_provider_cli_shared();
       }
     });
+    function resolveNativeCompletionSignalSpec(nativeHistory) {
+      if (!nativeHistory || typeof nativeHistory !== "object") return null;
+      const declared = nativeHistory.completionSignal;
+      if (!declared || typeof declared !== "object") return null;
+      const spec = declared;
+      const recordType = typeof spec.recordType === "string" ? spec.recordType.trim() : "";
+      if (!recordType) return null;
+      const abortRecordType = typeof spec.abortRecordType === "string" ? spec.abortRecordType.trim() : "";
+      const summaryField = typeof spec.summaryField === "string" ? spec.summaryField.trim() : "";
+      const turnIdField = typeof spec.turnIdField === "string" ? spec.turnIdField.trim() : "";
+      return {
+        recordType,
+        ...abortRecordType ? { abortRecordType } : {},
+        ...summaryField ? { summaryField } : {},
+        ...turnIdField ? { turnIdField } : {}
+      };
+    }
+    function providerHasNativeTurnSignal(provider) {
+      if (!provider) return false;
+      if (resolveNativeCompletionSignalSpec(provider.nativeHistory)) return true;
+      const type2 = typeof provider.type === "string" ? provider.type.trim() : "";
+      return !!type2 && BUILTIN_TURN_SIGNAL_PROVIDER_TYPES.has(type2);
+    }
+    function selectTurnTerminalMarker(markers, scope) {
+      if (!Array.isArray(markers) || markers.length === 0) return null;
+      const wantedTurnId = typeof scope.turnId === "string" && scope.turnId.trim() ? scope.turnId.trim() : "";
+      if (wantedTurnId) {
+        for (let i = markers.length - 1; i >= 0; i--) {
+          const m = markers[i];
+          if (m && m.turnId === wantedTurnId) return m;
+        }
+        return null;
+      }
+      const startedAt = typeof scope.turnStartedAt === "number" && Number.isFinite(scope.turnStartedAt) && scope.turnStartedAt > 0 ? scope.turnStartedAt : 0;
+      if (!startedAt) return null;
+      for (let i = markers.length - 1; i >= 0; i--) {
+        const m = markers[i];
+        if (!m) continue;
+        if (typeof m.receivedAt === "number" && m.receivedAt >= startedAt) return m;
+      }
+      return null;
+    }
+    var BUILTIN_TURN_SIGNAL_PROVIDER_TYPES;
+    var init_native_turn_signal = __esm2({
+      "src/providers/completion/native-turn-signal.ts"() {
+        "use strict";
+        BUILTIN_TURN_SIGNAL_PROVIDER_TYPES = /* @__PURE__ */ new Set(["codex-cli"]);
+      }
+    });
     var SCRIPT_STATUS_DEBOUNCE_MS;
     var MAX_FINISH_RETRIES;
     var FINISH_RETRY_DELAY_MS;
@@ -71213,6 +71266,8 @@ ${cont}` : cont;
     var APPROVAL_RESUME_IDLE_DEFER_CAP_MS;
     var MAX_TRANSCRIPT_FINISH_DEFERS;
     var TRANSCRIPT_FINISH_DEFER_CAP_MS;
+    var TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS;
+    var BLOCKED_FINISH_WATCHDOG_MIN_DELAY_MS;
     var SCREEN_QUIET_IDLE_MS;
     var CliStateEngine;
     var init_cli_state_engine = __esm2({
@@ -71222,6 +71277,7 @@ ${cont}` : cont;
         init_provider_cli_parse();
         init_provider_cli_shared();
         init_transcript_evidence();
+        init_native_turn_signal();
         SCRIPT_STATUS_DEBOUNCE_MS = 3e3;
         MAX_FINISH_RETRIES = 2;
         FINISH_RETRY_DELAY_MS = 300;
@@ -71231,6 +71287,8 @@ ${cont}` : cont;
         APPROVAL_RESUME_IDLE_DEFER_CAP_MS = 18e3;
         MAX_TRANSCRIPT_FINISH_DEFERS = 3;
         TRANSCRIPT_FINISH_DEFER_CAP_MS = 3e4;
+        TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS = 5 * 6e4;
+        BLOCKED_FINISH_WATCHDOG_MIN_DELAY_MS = 1e3;
         SCREEN_QUIET_IDLE_MS = 5e3;
         CliStateEngine = class {
           constructor(provider, runner, transport, callbacks, timeouts) {
@@ -71329,6 +71387,9 @@ ${cont}` : cont;
           // ── Timers ───────────────────────────────────────
           settleTimer = null;
           idleTimeout = null;
+          // (INFINITE-GENERATING) Re-evaluation tick for a BLOCKED transcript finish — the only
+          // thing that keeps the blocked path alive long enough for its hard cap to fire.
+          blockedFinishWatchdogTimer = null;
           finishRetryTimer = null;
           providerErrorRetryTimer = null;
           providerErrorRetryKey = "";
@@ -71575,6 +71636,10 @@ ${cont}` : cont;
               this.pendingIdleFinishTimer = null;
               this.pendingIdleFinishAt = 0;
             }
+            if (this.blockedFinishWatchdogTimer) {
+              clearTimeout(this.blockedFinishWatchdogTimer);
+              this.blockedFinishWatchdogTimer = null;
+            }
             this.providerErrorRetryKey = "";
           }
           resetActiveTurnState() {
@@ -72079,7 +72144,10 @@ ${cont}` : cont;
                   return;
                 }
                 if (this.shouldDeferIdleTimeoutFinish()) return;
-                if (!this.hasScreenBeenQuietForIdle(Date.now())) {
+                const hasNativeTurnSignal = providerHasNativeTurnSignal(this.provider);
+                const turnAgeMs = this.currentTurnStartedAt > 0 ? Date.now() - this.currentTurnStartedAt : 0;
+                const keepWaitingOnScreen = hasNativeTurnSignal ? false : turnAgeMs < TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS;
+                if (!this.hasScreenBeenQuietForIdle(Date.now()) && keepWaitingOnScreen) {
                   if (this.idleTimeout) clearTimeout(this.idleTimeout);
                   this.idleTimeout = setTimeout(() => {
                     if (this.isWaitingForResponse) this.evaluateSettled(this.transport.getSnapshot());
@@ -72217,6 +72285,7 @@ ${cont}` : cont;
               this.rescheduleTranscriptFinishCheck(reason);
               return "deferred";
             }
+            this.armBlockedFinishWatchdog(reason);
             if (this.currentStatus !== "generating" || !this.isWaitingForResponse || this.hasActionableApproval()) {
               this.recordTrace("transcript_finish_defer_cap_fail_closed", {
                 reason,
@@ -72228,8 +72297,20 @@ ${cont}` : cont;
               });
               return "blocked";
             }
+            const blockedForMs = elapsedMs;
+            const hardCapTripped = blockedForMs >= TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS;
             const snap = this.transport.getSnapshot();
             if (!this.hasScreenBeenQuietForIdle(now) || this.hasRecentInteractiveActivity(snap, now)) {
+              if (hardCapTripped) {
+                this.recordTrace("transcript_finish_blocked_hard_cap_escape", {
+                  reason,
+                  guard: "screen_active",
+                  count: this.transcriptFinishDeferCount,
+                  elapsedMs,
+                  hardCapMs: TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS
+                });
+                return "proceed";
+              }
               this.recordTrace("transcript_finish_defer_cap_fail_closed", {
                 reason,
                 guard: "screen_active",
@@ -72247,6 +72328,16 @@ ${cont}` : cont;
               }
             }
             if (!nativeProven) {
+              if (hardCapTripped) {
+                this.recordTrace("transcript_finish_blocked_hard_cap_escape", {
+                  reason,
+                  guard: "native_proof",
+                  count: this.transcriptFinishDeferCount,
+                  elapsedMs,
+                  hardCapMs: TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS
+                });
+                return "proceed";
+              }
               this.recordTrace("transcript_finish_defer_cap_fail_closed", {
                 reason,
                 guard: "native_proof",
@@ -72515,6 +72606,36 @@ ${cont}` : cont;
             }, this.timeouts.idleFinishConfirm);
             this.recordTrace("transcript_finish_deferred", { reason });
           }
+          /**
+           * (INFINITE-GENERATING) Keep a BLOCKED transcript finish re-evaluated until the
+           * hard cap can release it.
+           *
+           * rescheduleTranscriptFinishCheck only re-arms on the 'deferred' path. On 'blocked'
+           * nothing re-armed at all, so finishResponse was never re-entered: the FSM went
+           * fully dormant with currentTurnScope still open, and no purely time-based cap could
+           * ever be consulted because no timer would fire to consult it. That is what made the
+           * wedge permanent rather than merely slow.
+           *
+           * Deliberately NOT rescheduleTranscriptFinishCheck: this must not call setStatus or
+           * clearIdleFinishCandidate (the blocked state is already correct and re-asserting it
+           * would churn status history), and it must not touch transcriptFinishDeferCount —
+           * the defer bound stays tripped. It is a bare re-evaluation tick, self-cancelling
+           * once the turn closes.
+           */
+          armBlockedFinishWatchdog(reason) {
+            if (this.blockedFinishWatchdogTimer) return;
+            const epoch = this.responseEpoch;
+            const elapsed = this.transcriptFinishDeferSince > 0 ? Date.now() - this.transcriptFinishDeferSince : 0;
+            const remaining = Math.max(BLOCKED_FINISH_WATCHDOG_MIN_DELAY_MS, TRANSCRIPT_FINISH_BLOCKED_HARD_CAP_MS - elapsed);
+            this.blockedFinishWatchdogTimer = setTimeout(() => {
+              this.blockedFinishWatchdogTimer = null;
+              if (epoch !== this.responseEpoch) return;
+              if (!this.isWaitingForResponse || !this.currentTurnScope) return;
+              if (this.hasActionableApproval()) return;
+              this.finishResponse();
+            }, remaining);
+            this.recordTrace("transcript_finish_blocked_watchdog_armed", { reason, remainingMs: remaining });
+          }
           shouldRetryFinishResponse(snap, commitResult) {
             if (!this.currentTurnScope) return false;
             if (this.hasActionableApproval()) return false;
@@ -73008,6 +73129,7 @@ ${cont}` : cont;
         }
       }
       if (messages.length === 0) return null;
+      const turnTerminalMarkers = extractBuiltinTurnTerminalMarkers(input.agentType, lines);
       return {
         messages,
         providerSessionId,
@@ -73022,9 +73144,45 @@ ${cont}` : cont;
             providerSessionId: providerSessionId || "",
             agent: typeof input.agentType === "string" ? input.agentType : "unknown"
           })
-        } : {}
+        } : {},
+        ...turnTerminalMarkers.length > 0 ? { turnTerminalMarkers } : {}
       };
     }
+    function extractBuiltinTurnTerminalMarkers(agentType, lines) {
+      if (agentType !== "codex-cli") return [];
+      const markers = [];
+      for (const rec of lines) {
+        if (String(rec?.type ?? "") !== "event_msg") continue;
+        const payload = rec?.payload;
+        if (!payload || typeof payload !== "object") continue;
+        const payloadType = String(payload.type ?? "").trim();
+        const isComplete = payloadType === "task_complete";
+        const isAbort = payloadType === "turn_aborted";
+        if (!isComplete && !isAbort) continue;
+        const receivedAt = parseTimestamp(rec?.timestamp) ?? Date.now();
+        const summary = flattenJsonlText(payload.last_agent_message);
+        const rawTurnId = payload.turn_id;
+        const turnId = typeof rawTurnId === "string" && rawTurnId.trim() ? rawTurnId.trim() : "";
+        markers.push({
+          receivedAt,
+          outcome: isAbort ? "aborted" : "completed",
+          summary,
+          ...turnId ? { turnId } : {}
+        });
+      }
+      return markers;
+    }
+    function flattenJsonlText(value) {
+      if (typeof value === "string") return value.trim();
+      if (value == null) return "";
+      if (Array.isArray(value)) return value.map(flattenJsonlText).filter(Boolean).join("\n").trim();
+      if (typeof value === "object") {
+        const obj = value;
+        if (typeof obj.text === "string") return obj.text.trim();
+        if (typeof obj.content === "string" || Array.isArray(obj.content)) return flattenJsonlText(obj.content);
+      }
+      return "";
+    }
     function resolveJsonlSourcePath(src, input) {
       return resolveJsonlSourcePathDetailed(src, input).path;
     }
@@ -74745,10 +74903,10 @@ ${lastSnapshot}`;
             return this.accumulatedRawBuffer.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
           }
           getFreshParsedStatusCache() {
-            const cached4 = this.parsedStatusCache;
+            const cached5 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (cached4 && cached4.responseBuffer === this.responseBuffer && cached4.currentTurnScope === this.engine.currentTurnScope && cached4.recentOutputBuffer === this.recentOutputBuffer && cached4.accumulatedBuffer === this.accumulatedBuffer && cached4.accumulatedRawBufferKey === accumulatedRawBufferKey && cached4.screenText === this.lastScreenText && cached4.currentStatus === this.engine.currentStatus && cached4.activeModal === this.engine.activeModal && cached4.cliName === this.cliName) {
-              return cached4.result;
+            if (cached5 && cached5.responseBuffer === this.responseBuffer && cached5.currentTurnScope === this.engine.currentTurnScope && cached5.recentOutputBuffer === this.recentOutputBuffer && cached5.accumulatedBuffer === this.accumulatedBuffer && cached5.accumulatedRawBufferKey === accumulatedRawBufferKey && cached5.screenText === this.lastScreenText && cached5.currentStatus === this.engine.currentStatus && cached5.activeModal === this.engine.activeModal && cached5.cliName === this.cliName) {
+              return cached5.result;
             }
             return null;
           }
@@ -75355,10 +75513,10 @@ ${lastSnapshot}`;
               backgroundTaskSupport: bg.support ?? "unknown",
               ...bg.active ? { backgroundTaskActive: true, backgroundTaskCount: bg.count, backgroundTaskIds: bg.ids } : {}
             };
-            const cached4 = this.parsedStatusCache;
+            const cached5 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (!this.providerOwnsTranscript() && cached4 && cached4.responseBuffer === this.responseBuffer && cached4.currentTurnScope === this.engine.currentTurnScope && cached4.recentOutputBuffer === this.recentOutputBuffer && cached4.accumulatedBuffer === this.accumulatedBuffer && cached4.accumulatedRawBufferKey === accumulatedRawBufferKey && cached4.screenText === parseScreenText && cached4.currentStatus === this.engine.currentStatus && cached4.activeModal === this.engine.activeModal && cached4.cliName === this.cliName) {
-              return { ...cached4.result, ...backgroundTaskFields };
+            if (!this.providerOwnsTranscript() && cached5 && cached5.responseBuffer === this.responseBuffer && cached5.currentTurnScope === this.engine.currentTurnScope && cached5.recentOutputBuffer === this.recentOutputBuffer && cached5.accumulatedBuffer === this.accumulatedBuffer && cached5.accumulatedRawBufferKey === accumulatedRawBufferKey && cached5.screenText === parseScreenText && cached5.currentStatus === this.engine.currentStatus && cached5.activeModal === this.engine.activeModal && cached5.cliName === this.cliName) {
+              return { ...cached5.result, ...backgroundTaskFields };
             }
             const parsed = this.runParseSession();
             if (!parsed || !Array.isArray(parsed.messages)) {
@@ -77729,6 +77887,7 @@ ${lastSnapshot}`;
       STALE_MAGI_WINDOW_MS: () => STALE_MAGI_WINDOW_MS,
       STALE_TERMINAL_REFINE_WINDOW_MS: () => STALE_TERMINAL_REFINE_WINDOW_MS,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
+      SYM: () => SYM,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
       StatuslineInstallError: () => StatuslineInstallError2,
       TRACK: () => TRACK,
@@ -77804,6 +77963,7 @@ ${lastSnapshot}`;
       computeProviderTreeDigest: () => computeProviderTreeDigest,
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
+      consoleSymbols: () => consoleSymbols,
       coordinatorIdentityFromEmitFields: () => coordinatorIdentityFromEmitFields,
       createDebugTraceStore: () => createDebugTraceStore,
       createDefaultGitCommandServices: () => createDefaultGitCommandServices,
@@ -78052,6 +78212,7 @@ ${lastSnapshot}`;
       requeueTask: () => requeueTask,
       requireMeshHostQueueOwner: () => requireMeshHostQueueOwner,
       resetConfig: () => resetConfig,
+      resetConsoleSymbolsCache: () => resetConsoleSymbolsCache,
       resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
       resetProcessInstanceContextForTests: () => resetProcessInstanceContextForTests,
       resetState: () => resetState,
@@ -78060,6 +78221,7 @@ ${lastSnapshot}`;
       resolveBackoffMs: () => resolveBackoffMs,
       resolveBuildTrack: () => resolveBuildTrack,
       resolveChatMessageKind: () => resolveChatMessageKind,
+      resolveConsoleSymbols: () => resolveConsoleSymbols,
       resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
@@ -78121,6 +78283,7 @@ ${lastSnapshot}`;
       summarizeMeshMission: () => summarizeMeshMission,
       summarizeMeshUsage: () => summarizeMeshUsage,
       summarizeMissionTasks: () => summarizeMissionTasks,
+      supportsUnicodeSymbols: () => supportsUnicodeSymbols,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
@@ -80264,9 +80427,9 @@ ${lastSnapshot}`;
         usageFileCache.delete(path54);
         return emptyFile(meshId);
       }
-      const cached4 = usageFileCache.get(path54);
-      if (cached4 && cached4.mtimeMs === stat2.mtimeMs && cached4.size === stat2.size) {
-        return cached4.file;
+      const cached5 = usageFileCache.get(path54);
+      if (cached5 && cached5.mtimeMs === stat2.mtimeMs && cached5.size === stat2.size) {
+        return cached5.file;
       }
       try {
         const parsed = JSON.parse((0, import_fs14.readFileSync)(path54, "utf-8"));
@@ -92599,6 +92762,7 @@ ${marker}`,
     init_provider_input_support();
     init_hash();
     init_transcript_evidence();
+    init_native_turn_signal();
     init_logger();
     var BUSY_LEASE_BOUND_MS = 18e4;
     var DEFAULT_CANARY_PROVIDERS = ["kimi", "codex-cli"];
@@ -92967,6 +93131,13 @@ ${marker}`,
       return n;
     }
     var SUBMIT_DELAY_FLOOR_MS = 200;
+    var SEND_IN_FLIGHT_MAX_MS = 3e4;
+    var DUPLICATE_RESEND_WINDOW_MS = 6e4;
+    function hashSendText(text) {
+      let h = 5381;
+      for (let i = 0; i < text.length; i += 1) h = ((h << 5) + h ^ text.charCodeAt(i)) >>> 0;
+      return `${h.toString(36)}:${text.length}`;
+    }
     var fsmDriverSeq = 0;
     var WIN32_SUBMIT_RESEND_GAP_MS = 350;
     var WIN32_SUBMIT_MAX_RESENDS = 14;
@@ -93073,6 +93244,19 @@ ${marker}`,
       //    non-busy ("ready") state — same contract as v3's idleSeenOnce.
       readySeenOnce = false;
       pendingSends = [];
+      /** True while a send is written but the FSM has not yet left idle, i.e. the
+       *  composer is mid-submit. Blocks a second send from overwriting the first
+       *  before the CLI has consumed it (see handleSendMessage). */
+      sendInFlight = false;
+      /** Wall-clock (ms) the in-flight send was written. Bounds sendInFlight so a
+       *  send the CLI never visibly consumed cannot wedge the queue forever. */
+      sendInFlightAt = 0;
+      /** Content hash → wall-clock of the last PTY write, for the pre-write
+       *  duplicate gate (see isDuplicateResend). */
+      recentSendHashes = /* @__PURE__ */ new Map();
+      /** Pending queued-send drain timer, tracked so shutdown() can cancel it and
+       *  a torn-down driver never writes a queued body into a dead PTY. */
+      pendingSendDrainTimer = null;
       pickerInProgress = null;
       delegateTimers = /* @__PURE__ */ new Map();
       specWatcher = null;
@@ -93225,6 +93409,11 @@ ${marker}`,
           clearTimeout(this.win32ModalConfirmTimer);
           this.win32ModalConfirmTimer = null;
         }
+        if (this.pendingSendDrainTimer) {
+          clearTimeout(this.pendingSendDrainTimer);
+          this.pendingSendDrainTimer = null;
+        }
+        this.pendingSends.length = 0;
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -93416,12 +93605,14 @@ ${marker}`,
           this.scheduleWakeForState();
           this.scheduleStallWatchdog();
           this.maybeMarkReady();
+          this.drainPendingSends();
           return;
         }
         this.emitStateChanged(forceEmit);
         this.scheduleWakeForState();
         this.scheduleStallWatchdog();
         this.maybeMarkReady();
+        this.drainPendingSends();
       }
       commitTransition(fired, now, ev) {
         const from = this.currentStateId;
@@ -93691,8 +93882,7 @@ ${marker}`,
         if (!st) return;
         if (!st.initial && statusForState(st) === "idle") {
           this.readySeenOnce = true;
-          const queued = this.pendingSends.splice(0);
-          for (const text of queued) setTimeout(() => this.actuallySendMessage(text), 50);
+          this.drainPendingSends();
         }
       }
       // ────────────────────────────────────────────────────────────────────
@@ -93730,13 +93920,109 @@ ${marker}`,
       // ────────────────────────────────────────────────────────────────────
       // Dashboard commands (identical semantics to v3)
       // ────────────────────────────────────────────────────────────────────
+      /**
+       * SEND-OVERLAP gate. A send may only go straight to the PTY when the machine
+       * is genuinely able to accept one: it has been ready at least once, it is
+       * sitting at an idle prompt right now, and no earlier send is still in flight.
+       * Anything else is queued and drained by drainPendingSends() when the machine
+       * next returns to idle.
+       *
+       * Before the fix this consulted ONLY `readySeenOnce` — a one-shot latch — so
+       * every send after the first ignored the live FSM state and could be written
+       * on top of a still-generating turn, braiding the two bodies in the composer
+       * (see the SEND-OVERLAP note above the constants).
+       */
       handleSendMessage(text) {
-        if (!this.readySeenOnce) {
+        if (this.isDuplicateResend(text)) {
+          LOG2.info("FsmDriver", `[${this.specTag()}] send suppressed \u2014 duplicate resend within ${DUPLICATE_RESEND_WINDOW_MS}ms (len=${text.length})`);
+          return;
+        }
+        if (!this.canSendNow()) {
           this.pendingSends.push(text);
+          LOG2.info(
+            "FsmDriver",
+            `[${this.specTag()}] send queued \u2014 ${this.sendBlockedReason()} (len=${text.length}, queued=${this.pendingSends.length})`
+          );
           return;
         }
+        this.beginSend(text);
+      }
+      /** True when a send can be written to the PTY right now. */
+      canSendNow() {
+        if (!this.readySeenOnce) return false;
+        if (this.isSendInFlight()) return false;
+        return this.currentStatus() === "idle";
+      }
+      /** Human-readable reason a send was queued — logged, never used for control flow. */
+      sendBlockedReason() {
+        if (!this.readySeenOnce) return "machine not ready yet";
+        if (this.isSendInFlight()) return `previous send still in flight (${Date.now() - this.sendInFlightAt}ms)`;
+        return `machine is ${this.currentStatus()}`;
+      }
+      /** In-flight latch with its self-expiry applied, so a send the CLI never
+       *  visibly consumed cannot wedge the queue permanently. */
+      isSendInFlight() {
+        if (!this.sendInFlight) return false;
+        if (Date.now() - this.sendInFlightAt > SEND_IN_FLIGHT_MAX_MS) {
+          LOG2.warn("FsmDriver", `[${this.specTag()}] in-flight send latch expired after ${SEND_IN_FLIGHT_MAX_MS}ms \u2014 releasing`);
+          this.sendInFlight = false;
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Pre-write duplicate gate. Suppresses a repeat of text that was written to
+       * the PTY within DUPLICATE_RESEND_WINDOW_MS *while that text is still being
+       * processed* — i.e. a send is in flight or the machine has not returned to
+       * idle. A genuine repeat typed at an idle prompt is NOT suppressed: sending
+       * "continue" twice in a row is ordinary use, and silently swallowing the
+       * second one would be a worse defect than the one being fixed.
+       */
+      isDuplicateResend(text) {
+        const now = Date.now();
+        const key2 = hashSendText(text);
+        for (const [candidate, at] of this.recentSendHashes) {
+          if (now - at > DUPLICATE_RESEND_WINDOW_MS) this.recentSendHashes.delete(candidate);
+        }
+        const previous = this.recentSendHashes.get(key2);
+        if (previous === void 0) return false;
+        if (now - previous > DUPLICATE_RESEND_WINDOW_MS) return false;
+        const stillProcessing = this.isSendInFlight() || this.currentStatus() !== "idle" || this.pendingSends.length > 0;
+        return stillProcessing;
+      }
+      /** Mark a send as in flight, record it for the duplicate gate, and write it. */
+      beginSend(text) {
+        this.sendInFlight = true;
+        this.sendInFlightAt = Date.now();
+        this.recentSendHashes.set(hashSendText(text), this.sendInFlightAt);
         this.actuallySendMessage(text);
       }
+      /**
+       * Release the in-flight latch and write the next queued send, if the machine
+       * can take one. Called from the FSM evaluation loop, so it runs on the same
+       * frame the machine reaches idle — the queue never waits for an extra PTY
+       * frame that a quiet CLI would never produce (the same hazard maybeMarkReady
+       * documents for the very first message).
+       */
+      drainPendingSends() {
+        if (!this.readySeenOnce) return;
+        const status = this.currentStatus();
+        if (this.sendInFlight && status !== "idle") {
+          this.sendInFlight = false;
+        }
+        if (status !== "idle") return;
+        if (this.isSendInFlight()) return;
+        if (this.pendingSends.length === 0) return;
+        const next = this.pendingSends.shift();
+        LOG2.info("FsmDriver", `[${this.specTag()}] draining queued send (len=${next.length}, remaining=${this.pendingSends.length})`);
+        if (this.pendingSendDrainTimer) clearTimeout(this.pendingSendDrainTimer);
+        this.pendingSendDrainTimer = setTimeout(() => {
+          this.pendingSendDrainTimer = null;
+          this.beginSend(next);
+        }, 50);
+        this.sendInFlight = true;
+        this.sendInFlightAt = Date.now();
+      }
       actuallySendMessage(text) {
         const sm = this.spec.send_message;
         const perChar = sm.delay_ms_per_char ?? 0;
@@ -95535,6 +95821,7 @@ ${marker}`,
     var PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
     var ANTIGRAVITY_HOLD_QUIET_DWELL_MS = 3e3;
     var ANTIGRAVITY_HOLD_HARD_CAP_MS = 5 * 6e4;
+    var TERMINAL_BLOCK_HARD_CAP_MS = 10 * 6e4;
     var BACKGROUND_TASK_HOLD_MAX_MS = 5 * 6e4;
     var USER_INPUT_ACK_DEDUP_WINDOW_MS = 6e4;
     var STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12e3;
@@ -95593,6 +95880,12 @@ ${marker}`,
         evidencePatch.resolvedFinalEvidenceObservedAt = null;
       }
       if (!evidence.present) {
+        if (evidence.source === "native-signal") {
+          return {
+            block: { reason: "native_signal_adapter_pending", terminal: false, allowTimeout: true },
+            evidencePatch
+          };
+        }
         if (ownsExternal) {
           if (evidence.source === "external-native") {
             const probe = reader.externalNativeTailProbe();
@@ -95625,17 +95918,15 @@ ${marker}`,
               evidencePatch
             };
           }
-          if (timing === "floor") {
-            return {
-              block: {
-                reason: "missing_final_assistant",
-                terminal: true,
-                allowTimeout: allowMissingAssistantTimeout,
-                noExternalTranscriptSource: true
-              },
-              evidencePatch
-            };
-          }
+          return {
+            block: {
+              reason: "missing_final_assistant",
+              terminal: false,
+              allowTimeout: true,
+              ...timing === "floor" ? { noExternalTranscriptSource: true } : {}
+            },
+            evidencePatch
+          };
         } else {
           return {
             block: {
@@ -95771,7 +96062,7 @@ ${marker}`,
           }
         }
       }
-      if (!isTranscriptEvidenceGate && (block2.terminal || waitedMs < policy.finalizationMaxWaitMs)) {
+      if (!isTranscriptEvidenceGate && (block2.terminal ? waitedMs < policy.terminalBlockHardCapMs : waitedMs < policy.finalizationMaxWaitMs)) {
         return hold(block2.reason, {
           terminal: block2.terminal === true,
           holdForTranscript: block2.holdForTranscript === true,
@@ -95789,11 +96080,13 @@ ${marker}`,
         });
       }
       const emittedAfterFinalizationTimeout = waitedMs >= policy.finalizationMaxWaitMs;
+      const releasedByTerminalBlockHardCap = block2.terminal === true && !isTranscriptEvidenceGate && waitedMs >= policy.terminalBlockHardCapMs;
       return {
         kind: "emit-weak",
         block: block2,
         emittedAfterFinalizationTimeout,
         decoupledImmediateEmit: isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout,
+        releasedByTerminalBlockHardCap,
         waitedMs,
         armPatch: basePatch,
         trace: {
@@ -95801,6 +96094,7 @@ ${marker}`,
           latestVisibleStatus: visibleStatus,
           approvalResolvedIdle: arm.previousStatus === "waiting_approval",
           emittedAfterFinalizationTimeout,
+          releasedByTerminalBlockHardCap,
           waitedMs,
           busyEpoch
         }
@@ -96431,7 +96725,17 @@ ${buttons.join("\n")}`;
         instanceId: host.instanceId,
         envOverrides: host.spawnedEnvOverrides(),
         forceRefresh: true
+        // (NATIVE-TURN-SIGNAL audit) excludeInProgressTurn is deliberately NOT passed
+        // here, and that is correct — not the declared-but-ignored field it looks like.
+        // It is a per-CALL display concern, not a manifest policy: read_chat sets it only
+        // for `returnedStatus === 'waiting_approval'` (chat-commands-read.ts) so a paused
+        // turn's half-written tail is hidden from the user. The completion gate needs the
+        // exact opposite — it exists to judge the turn that JUST finished, so excluding the
+        // in-progress turn would hide the very evidence it is looking for and would make
+        // missing_final_assistant strictly more common. Codex's manifest sets
+        // excludeInProgressTurn:true for its own read path; that must not leak here.
       });
+      host.lastNativeTurnTerminalMarkers = Array.isArray(restoredHistory.turnTerminalMarkers) ? restoredHistory.turnTerminalMarkers : null;
       if (restoredHistory.source !== "provider-native") {
         host.lastExternalCompletionProbe = null;
         host.publishTranscriptSignalObservation(null);
@@ -96446,11 +96750,11 @@ ${buttons.join("\n")}`;
       return restoredHistory.messages;
     }
     function cachedInTurnCompletionSummaryContent(host, turnStartedAt) {
-      const cached4 = host.lastCompletionSummary;
-      const content = typeof cached4?.content === "string" ? cached4.content.trim() : "";
+      const cached5 = host.lastCompletionSummary;
+      const content = typeof cached5?.content === "string" ? cached5.content.trim() : "";
       if (!content) return "";
       const hasBoundary = typeof turnStartedAt === "number" && Number.isFinite(turnStartedAt) && turnStartedAt > 0;
-      const ts2 = cached4?.sourceTimestampMs;
+      const ts2 = cached5?.sourceTimestampMs;
       if (hasBoundary && typeof ts2 === "number" && Number.isFinite(ts2) && ts2 < turnStartedAt) {
         return "";
       }
@@ -96458,6 +96762,16 @@ ${buttons.join("\n")}`;
     }
     function completionFinalAssistantEvidence(host, parsedMessages, turnStartedAt) {
       const turnClosed = !host.hasAdapterPendingResponse();
+      const terminalMarker = host.nativeTurnTerminalMarker?.(turnStartedAt);
+      if (terminalMarker) {
+        return {
+          present: turnClosed,
+          messages: Array.isArray(parsedMessages) ? parsedMessages : [],
+          source: "native-signal",
+          nativeSummary: terminalMarker.summary,
+          nativeOutcome: terminalMarker.outcome
+        };
+      }
       const preferNativeOverParsed = host.adapter?.chatMessagesOwnedExternally === true && host.busyLeaseGateEnabled();
       if (!preferNativeOverParsed && host.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
         return {
@@ -98173,6 +98487,9 @@ ${buttons.join("\n")}`;
       completedDebounceTimer = null;
       completedDebouncePending = null;
       lastExternalCompletionProbe = null;
+      // (NATIVE-TURN-SIGNAL) Terminal markers from the last native transcript read. Refreshed
+      // on every completion probe; null when the provider surfaces none.
+      lastNativeTurnTerminalMarkers = null;
       /** TX-FSM: lazily-created transcript signal normalizer. Fed ONLY by
        *  transcript reads this instance already performs — it adds zero I/O.
        *  Stage 0: its output was a pure shadow observation for the FSM driver.
@@ -98431,8 +98748,8 @@ ${buttons.join("\n")}`;
        * next turn (see lastCompletionSummary = null on onTurnStarted).
        */
       cachedCompletionSummaryContent() {
-        const cached4 = this.lastCompletionSummary;
-        const content = typeof cached4?.content === "string" ? cached4.content.trim() : "";
+        const cached5 = this.lastCompletionSummary;
+        const content = typeof cached5?.content === "string" ? cached5.content.trim() : "";
         return content;
       }
       /** See completion/evidence.ts — FALSE-IDLE Defect 1c turn-scoped cache view. */
@@ -98752,6 +99069,28 @@ ${buttons.join("\n")}`;
           return false;
         }
       }
+      /**
+       * (NATIVE-TURN-SIGNAL) This turn's terminal marker from the provider's own transcript,
+       * or null when the provider declares no completion signal / the turn has not ended.
+       *
+       * Turn scoping prefers the provider-native turn id when the adapter knows it, falling
+       * back to the turn-start boundary — see selectTurnTerminalMarker. Any read error fails
+       * CLOSED (null ⇒ shape inference), so a malformed transcript can never manufacture a
+       * completion.
+       */
+      nativeTurnTerminalMarker(turnStartedAt) {
+        try {
+          const markers = this.lastNativeTurnTerminalMarkers;
+          if (!markers || markers.length === 0) return null;
+          const adapterTurnId = typeof this.adapter?.currentProviderTurnId === "string" ? this.adapter.currentProviderTurnId : void 0;
+          return selectTurnTerminalMarker(markers, {
+            ...adapterTurnId ? { turnId: adapterTurnId } : {},
+            ...typeof turnStartedAt === "number" ? { turnStartedAt } : {}
+          });
+        } catch {
+          return null;
+        }
+      }
       /**
        * See completion/stall-rescue.ts — pre-cleanup mesh completion flush
        * (verbatim move; KIMI-MESH-COMPLETION-EMIT axis 2 provenance lives with
@@ -98912,7 +99251,8 @@ ${buttons.join("\n")}`;
           canonCMinElapsedFloorMs: CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS,
           transcriptGrowthQuietMs: MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS,
           holdClassHardCapMs: ANTIGRAVITY_HOLD_HARD_CAP_MS,
-          ptyParsedFinalAssistantQuietDwellMs: PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS
+          ptyParsedFinalAssistantQuietDwellMs: PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS,
+          terminalBlockHardCapMs: TERMINAL_BLOCK_HARD_CAP_MS
         };
       }
       /**
@@ -99149,12 +99489,14 @@ ${buttons.join("\n")}`;
             emittedAfterFinalizationTimeout
           });
           completionDiagnostic.decoupledImmediateEmit = decision.decoupledImmediateEmit;
-          LOG2.warn("CLI", `[${this.type}] emitting completed event (${decision.decoupledImmediateEmit ? "CANON-C decoupled-immediate, transcript pending" : `after ${waitedMs}ms`}) without finalized assistant turn (${blockReason})`);
+          completionDiagnostic.releasedByTerminalBlockHardCap = decision.releasedByTerminalBlockHardCap;
+          const emitCause = decision.releasedByTerminalBlockHardCap ? `terminal block never cleared, released at ${waitedMs}ms hard cap` : decision.decoupledImmediateEmit ? "CANON-C decoupled-immediate, transcript pending" : `after ${waitedMs}ms`;
+          LOG2.warn("CLI", `[${this.type}] emitting completed event (${emitCause}) without finalized assistant turn (${blockReason})`);
           if (this.isMeshWorkerSession()) {
             traceMeshEventStage("fired", this.meshTraceCtx(), `forced after ${waitedMs}ms (${blockReason})`);
           }
           if (this.completionTraceOn()) this.recordCompletionGateTrace("fire", {
-            path: decision.decoupledImmediateEmit ? "canon_c_decoupled" : "forced_timeout",
+            path: decision.releasedByTerminalBlockHardCap ? "terminal_block_hard_cap" : decision.decoupledImmediateEmit ? "canon_c_decoupled" : "forced_timeout",
             blockReason,
             latestVisibleStatus,
             approvalResolvedIdle: pending.previousStatus === "waiting_approval",
@@ -99173,7 +99515,7 @@ ${buttons.join("\n")}`;
             taskId: pending.taskId,
             // finalSummary provenance chain unchanged (see snapshotExternalNativeCompletionSummary /
             // completionFinalSummary / cachedInTurnCompletionSummaryContent docs above).
-            finalSummary: this.snapshotExternalNativeCompletionSummary(pending) || this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt) || this.cachedInTurnCompletionSummaryContent(pending.turnStartedAt) || (blockReason.startsWith("parsed_status:") ? "" : void 0),
+            finalSummary: this.nativeTurnTerminalSummary(pending.turnStartedAt) || this.snapshotExternalNativeCompletionSummary(pending) || this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt) || this.cachedInTurnCompletionSummaryContent(pending.turnStartedAt) || (blockReason.startsWith("parsed_status:") ? "" : void 0),
             completionDiagnostic
           });
           this.completedDebouncePending = null;
@@ -99260,6 +99602,21 @@ ${buttons.join("\n")}`;
       cleanCompletionFinalSummary(pending) {
         return cleanCompletionFinalSummary(this, pending);
       }
+      /**
+       * (NATIVE-TURN-SIGNAL) finalSummary straight from the provider's own terminal record.
+       *
+       * Placed at the HEAD of the finalSummary provenance chain so the two sources can never
+       * diverge: when the provider states the turn's final text, that text wins outright and
+       * the reconstruction chain (native snapshot > parsed screen > cached in-turn summary) is
+       * not consulted at all. Returns undefined — not '' — for a terminal record with no text,
+       * so a tool-terminated turn falls through to the existing chain rather than forcing an
+       * empty summary onto a completion that might legitimately have one from elsewhere.
+       */
+      nativeTurnTerminalSummary(turnStartedAt) {
+        const marker = this.nativeTurnTerminalMarker(turnStartedAt);
+        const text = typeof marker?.summary === "string" ? marker.summary.trim() : "";
+        return text || void 0;
+      }
       /** See completion/evidence.ts — KIMI-RC30 forced-emit native snapshot seed. */
       snapshotExternalNativeCompletionSummary(pending) {
         return snapshotExternalNativeCompletionSummary(pending);
@@ -103304,6 +103661,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var fs33 = __toESM2(require("fs"));
     var path37 = __toESM2(require("path"));
     init_usage_normalize();
+    init_native_turn_signal();
+    var CODEX_DEFAULT_COMPLETION_SIGNAL = {
+      recordType: "task_complete",
+      abortRecordType: "turn_aborted",
+      summaryField: "last_agent_message",
+      turnIdField: "turn_id"
+    };
     function extractTimestampValue2(value) {
       if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
       if (typeof value === "string") {
@@ -103418,8 +103782,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (!totals || typeof totals !== "object" || Array.isArray(totals)) return null;
       const t = totals;
       const rawInput = Number(t.input_tokens);
-      const cached4 = Number(t.cached_input_tokens);
-      const uncachedInput = Number.isFinite(rawInput) && Number.isFinite(cached4) ? Math.max(0, rawInput - cached4) : rawInput;
+      const cached5 = Number(t.cached_input_tokens);
+      const uncachedInput = Number.isFinite(rawInput) && Number.isFinite(cached5) ? Math.max(0, rawInput - cached5) : rawInput;
       const usage = makeUsage({
         inputTokens: uncachedInput,
         outputTokens: t.output_tokens,
@@ -103441,16 +103805,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return null;
       }
     }
-    function parseSessionFile(filePath, sessionId, workspaceFallback) {
+    function parseSessionFile(filePath, sessionId, workspaceFallback, completionSignal = CODEX_DEFAULT_COMPLETION_SIGNAL) {
       let raw;
       try {
         raw = fs33.readFileSync(filePath, "utf-8");
       } catch {
-        return { messages: [], usageRecords: [] };
+        return { messages: [], usageRecords: [], turnTerminalMarkers: [] };
       }
       const lines = raw.split("\n").filter(Boolean);
       const records = [];
       const usageRecords = [];
+      const turnTerminalMarkers = [];
       let fallbackTs = Date.now();
       let detectedWorkspace = typeof workspaceFallback === "string" ? workspaceFallback.trim() : "";
       for (const line of lines) {
@@ -103469,7 +103834,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!payload) continue;
         if (type2 === "session_meta") {
           const metaId = String(payload.id ?? "").trim();
-          if (metaId && metaId !== sessionId) return { messages: [], usageRecords: [] };
+          if (metaId && metaId !== sessionId) return { messages: [], usageRecords: [], turnTerminalMarkers: [] };
           const metaWorkspace = String(payload.cwd ?? "").trim();
           if (!detectedWorkspace && metaWorkspace) detectedWorkspace = metaWorkspace;
           if (records.length === 0 && detectedWorkspace) {
@@ -103488,6 +103853,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         const payloadType = String(payload.type ?? "").trim();
         if (type2 === "event_msg") {
+          if (completionSignal) {
+            const isComplete = payloadType === completionSignal.recordType;
+            const isAbort = !!completionSignal.abortRecordType && payloadType === completionSignal.abortRecordType;
+            if (isComplete || isAbort) {
+              const summary = completionSignal.summaryField ? flattenCodexContent(payload[completionSignal.summaryField]).trim() : "";
+              const rawTurnId = completionSignal.turnIdField ? payload[completionSignal.turnIdField] : void 0;
+              const turnId = typeof rawTurnId === "string" && rawTurnId.trim() ? rawTurnId.trim() : "";
+              turnTerminalMarkers.push({
+                receivedAt,
+                outcome: isAbort ? "aborted" : "completed",
+                summary,
+                ...turnId ? { turnId } : {}
+              });
+            }
+          }
           if (payloadType === "task_complete") {
             pushAssistantStandardMessage(
               records,
@@ -103560,9 +103940,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
           records.push(msg);
         }
       }
-      return { messages: records, usageRecords };
+      return { messages: records, usageRecords, turnTerminalMarkers };
     }
-    function readSession2(sessionPath) {
+    function readSession2(sessionPath, nativeHistory) {
       if (!sessionPath || !path37.isAbsolute(sessionPath)) return null;
       if (!fs33.existsSync(sessionPath)) return null;
       const meta3 = readSessionMeta(sessionPath);
@@ -103575,7 +103955,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (!sessionId || !isUuidLikeSessionId(sessionId)) return null;
       const workspaceFallback = typeof meta3?.cwd === "string" ? meta3.cwd : void 0;
       const sourceMtimeMs = statMtimeMs2(sessionPath);
-      const { messages, usageRecords } = parseSessionFile(sessionPath, sessionId, workspaceFallback);
+      const declaredSignal = resolveNativeCompletionSignalSpec(nativeHistory);
+      const { messages, usageRecords, turnTerminalMarkers } = parseSessionFile(
+        sessionPath,
+        sessionId,
+        workspaceFallback,
+        declaredSignal ?? CODEX_DEFAULT_COMPLETION_SIGNAL
+      );
       if (messages.length === 0) return null;
       const firstSystem = messages.find((m) => m.kind === "session_start");
       const workspace = firstSystem?.workspace || firstSystem?.content || void 0;
@@ -103594,6 +103980,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           agent: "codex-cli"
         });
       }
+      if (turnTerminalMarkers.length > 0) session.turnTerminalMarkers = turnTerminalMarkers;
       return session;
     }
     var fs34 = __toESM2(require("fs"));
@@ -103805,6 +104192,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     var AGY_STEP_TYPE_USER = 14;
     var AGY_STEP_TYPE_MODEL = 15;
+    var AGY_STATUS_DONE = 3;
     function readVarint(buf, offset) {
       let result = 0;
       let shift = 0;
@@ -103929,6 +104317,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       return best;
     }
+    function extractStepCreatedAtMs(metadata) {
+      if (!metadata || !Buffer.isBuffer(metadata) || metadata.length === 0) return null;
+      const stamp = firstLenField(metadata, 1);
+      if (!stamp) return null;
+      let seconds = 0;
+      let nanos = 0;
+      for (const f of decodeProtoFields(stamp)) {
+        if (f.wireType !== 0 || typeof f.varint !== "number") continue;
+        if (f.field === 1) seconds = f.varint;
+        else if (f.field === 2) nanos = f.varint;
+      }
+      if (!(seconds > 15e8 && seconds < 25e8)) return null;
+      const ms = seconds * 1e3 + Math.floor(nanos / 1e6);
+      return Number.isFinite(ms) ? ms : null;
+    }
     function isSqliteBusyError(err) {
       if (!err) return false;
       const code = err.code;
@@ -103965,10 +104368,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
             db.pragma(`busy_timeout = ${AGY_DB_BUSY_TIMEOUT_MS}`);
           } catch {
           }
+          let columns;
+          try {
+            columns = new Set(
+              db.prepare("PRAGMA table_info(steps)").all().map((c) => String(c?.name ?? ""))
+            );
+          } catch {
+            columns = /* @__PURE__ */ new Set();
+          }
+          const hasStatus = columns.has("status");
+          const hasMetadata = columns.has("metadata");
           rows = db.prepare(
-            `SELECT idx, step_type, step_payload
+            `SELECT idx, step_type, step_payload${hasMetadata ? ", metadata" : ""}
              FROM steps
             WHERE step_type IN (${AGY_STEP_TYPE_USER}, ${AGY_STEP_TYPE_MODEL})
+              ${hasStatus ? `AND status = ${AGY_STATUS_DONE}` : ""}
             ORDER BY idx ASC`
           ).all();
           break;
@@ -104005,7 +104419,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       for (const row of rows) {
         const payload = row.step_payload;
         if (!payload || !Buffer.isBuffer(payload) || payload.length === 0) continue;
-        const receivedAt = baseTs + messages.length;
+        const realCreatedAt = extractStepCreatedAtMs(row.metadata ?? null);
+        const receivedAt = realCreatedAt ?? baseTs + messages.length;
         if (row.step_type === AGY_STEP_TYPE_USER) {
           let content = extractUserPrompt(payload);
           if (!content) {
@@ -104475,7 +104890,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
           sourcePath: session.sourcePath,
           sourceMtimeMs: session.sourceMtimeMs,
           nativeHistoryCoverage: session.nativeHistoryCoverage || "full",
-          ownerConfirmed
+          ownerConfirmed,
+          // (NATIVE-TURN-SIGNAL) Pass the provider's own turn-terminal records through
+          // untouched. Readers that surface none simply omit the field.
+          ...Array.isArray(session.turnTerminalMarkers) && session.turnTerminalMarkers.length > 0 ? { turnTerminalMarkers: session.turnTerminalMarkers } : {}
         };
       };
     }
@@ -107023,8 +107441,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         }
         registerProviderScriptRootSafely(path45.dirname(path45.dirname(providerDir)));
-        const cached4 = this.scriptsCache.get(dir);
-        if (cached4) return cached4;
+        const cached5 = this.scriptsCache.get(dir);
+        if (cached5) return cached5;
         const scriptsJs = path45.join(dir, "scripts.js");
         if (fs41.existsSync(scriptsJs)) {
           try {
@@ -114912,8 +115330,8 @@ ${e?.stderr || ""}`;
       const repoRootBaseRef = /* @__PURE__ */ new Map();
       const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
       const resolveBaseRef = async (repoRoot) => {
-        const cached4 = repoRootBaseRef.get(repoRoot);
-        if (cached4) return cached4;
+        const cached5 = repoRootBaseRef.get(repoRoot);
+        if (cached5) return cached5;
         let baseBranch = "main";
         try {
           const { stdout } = await execFileAsync6("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
@@ -116218,13 +116636,13 @@ ${e?.stderr || ""}`;
       };
     }
     function getCachedAggregateMeshStatus(self, meshId, mesh, options) {
-      const cached4 = self.aggregateMeshStatusCache.get(meshId);
-      if (!cached4?.snapshot || cached4.snapshot.success !== true || !Array.isArray(cached4.snapshot.nodes)) return null;
-      if (cached4.queueRevision !== getMeshQueueRevision(meshId)) return null;
-      let snapshot = cloneJsonValue(cached4.snapshot);
+      const cached5 = self.aggregateMeshStatusCache.get(meshId);
+      if (!cached5?.snapshot || cached5.snapshot.success !== true || !Array.isArray(cached5.snapshot.nodes)) return null;
+      if (cached5.queueRevision !== getMeshQueueRevision(meshId)) return null;
+      let snapshot = cloneJsonValue(cached5.snapshot);
       snapshot = hydrateCachedAggregateMeshStatusFromInline(self, snapshot, mesh, options);
       if (!options?.allowStalePending && shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-      const ageMs2 = Math.max(0, Date.now() - cached4.builtAt);
+      const ageMs2 = Math.max(0, Date.now() - cached5.builtAt);
       const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
       snapshot.sourceOfTruth = {
         ...sourceOfTruth,
@@ -116235,7 +116653,7 @@ ${e?.stderr || ""}`;
           source: "memory",
           refreshReason: "memory_cache_hit",
           ageMs: ageMs2,
-          cachedAt: new Date(cached4.builtAt).toISOString(),
+          cachedAt: new Date(cached5.builtAt).toISOString(),
           returnedAt: (/* @__PURE__ */ new Date()).toISOString()
         }
       };
@@ -116291,8 +116709,8 @@ ${e?.stderr || ""}`;
     }
     function collectMeshSessionOwnerCandidateNodes(self) {
       const nodes = self.getCachedInlineMeshNodes();
-      for (const cached4 of self.aggregateMeshStatusCache.values()) {
-        const snapshotNodes = cached4?.snapshot?.nodes;
+      for (const cached5 of self.aggregateMeshStatusCache.values()) {
+        const snapshotNodes = cached5?.snapshot?.nodes;
         if (Array.isArray(snapshotNodes)) nodes.push(...snapshotNodes);
       }
       return nodes;
@@ -116613,9 +117031,9 @@ ${e?.stderr || ""}`;
           meshId,
           sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
         );
-        const cached4 = this.inlineMeshCache.get(meshId);
-        if (cached4) {
-          const merged = reconcileInlineMeshCache(cached4, sanitizedInlineMesh, this.removedInlineMeshNodeIds.get(meshId));
+        const cached5 = this.inlineMeshCache.get(meshId);
+        if (cached5) {
+          const merged = reconcileInlineMeshCache(cached5, sanitizedInlineMesh, this.removedInlineMeshNodeIds.get(meshId));
           this.inlineMeshCache.set(meshId, merged);
           return merged;
         }
@@ -116625,18 +117043,18 @@ ${e?.stderr || ""}`;
       async getMeshForCommand(meshId, inlineMesh, options) {
         const preferInline = options?.preferInline !== false;
         if (preferInline) {
-          const cached5 = this.getCachedInlineMesh(meshId);
-          if (cached5) {
+          const cached6 = this.getCachedInlineMesh(meshId);
+          if (cached6) {
             if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
               const merged = reconcileInlineMeshCache(
-                cached5,
+                cached6,
                 this.applyInlineMeshNodeTombstones(meshId, inlineMesh),
                 this.removedInlineMeshNodeIds.get(meshId)
               );
               this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
               return { mesh: merged, inline: true, source: "inline_cache" };
             }
-            return { mesh: cached5, inline: true, source: "inline_cache" };
+            return { mesh: cached6, inline: true, source: "inline_cache" };
           }
           if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
             this.warmInlineMeshCache(meshId, inlineMesh);
@@ -116649,8 +117067,8 @@ ${e?.stderr || ""}`;
           if (mesh) return { mesh, inline: false, source: "local_config" };
         } catch {
         }
-        const cached4 = this.getCachedInlineMesh(meshId);
-        if (cached4) return { mesh: cached4, inline: true, source: "inline_cache" };
+        const cached5 = this.getCachedInlineMesh(meshId);
+        if (cached5) return { mesh: cached5, inline: true, source: "inline_cache" };
         const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
         return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
       }
@@ -116789,13 +117207,13 @@ ${e?.stderr || ""}`;
         };
         let changed = false;
         try {
-          const cached4 = this.getCachedInlineMesh(meshId);
-          if (cached4 && stamp(cached4)) {
-            cached4.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.inlineMeshCache.set(meshId, cached4);
+          const cached5 = this.getCachedInlineMesh(meshId);
+          if (cached5 && stamp(cached5)) {
+            cached5.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            this.inlineMeshCache.set(meshId, cached5);
             changed = true;
-          } else if (!cached4 || !(Array.isArray(cached4.nodes) && cached4.nodes.some((entry) => meshNodeIdMatches(entry, nodeId)))) {
-            const shell = cached4 && typeof cached4 === "object" ? cached4 : { id: meshId, nodes: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          } else if (!cached5 || !(Array.isArray(cached5.nodes) && cached5.nodes.some((entry) => meshNodeIdMatches(entry, nodeId)))) {
+            const shell = cached5 && typeof cached5 === "object" ? cached5 : { id: meshId, nodes: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
             if (!Array.isArray(shell.nodes)) shell.nodes = [];
             const hydratedNode = {
               id: nodeId,
@@ -117376,6 +117794,59 @@ ${e?.stderr || ""}`;
     init_track_identity();
     init_normalize();
     init_logger();
+    var UNICODE_SYMBOLS = {
+      ok: "\u2713",
+      fail: "\u2717",
+      warn: "\u26A0",
+      info: "\u2022"
+    };
+    var ASCII_SYMBOLS = {
+      ok: "[OK]",
+      fail: "[X]",
+      warn: "[!]",
+      info: "-"
+    };
+    function supportsUnicodeSymbols(probe) {
+      const forced = probe.env.ADHDEV_ASCII_SYMBOLS;
+      if (forced === "1") return false;
+      if (forced === "0") return true;
+      if (probe.platform !== "win32") return true;
+      if (probe.env.WT_SESSION) return true;
+      if (probe.env.TERM_PROGRAM) return true;
+      const codePageHints = [probe.env.ADHDEV_CONSOLE_CODEPAGE, probe.env.LC_ALL, probe.env.LANG];
+      for (const hint of codePageHints) {
+        if (!hint) continue;
+        if (hint === "65001" || /utf-?8/i.test(hint)) return true;
+      }
+      return false;
+    }
+    function resolveConsoleSymbols(probe) {
+      return supportsUnicodeSymbols(probe) ? UNICODE_SYMBOLS : ASCII_SYMBOLS;
+    }
+    var cached4 = null;
+    function consoleSymbols() {
+      if (!cached4) {
+        cached4 = resolveConsoleSymbols({ platform: process.platform, env: process.env });
+      }
+      return cached4;
+    }
+    function resetConsoleSymbolsCache() {
+      cached4 = null;
+    }
+    var SYM = {
+      get ok() {
+        return consoleSymbols().ok;
+      },
+      get fail() {
+        return consoleSymbols().fail;
+      },
+      get warn() {
+        return consoleSymbols().warn;
+      },
+      get info() {
+        return consoleSymbols().info;
+      }
+    };
     init_debug_config();
     init_debug_trace();
     init_ipc_protocol();