@adhdev/daemon-core 0.9.82-rc.457 → 0.9.82-rc.459

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "29441f596e5efe1972b874e0fb5b3d380c9d9bda" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "29441f59" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.457" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-04T08:51:27.287Z" : void 0);
+  const commit = readInjected(true ? "7f95d1c8a5f682abdc7de49343d5bee688a9f16f" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7f95d1c8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.459" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-04T13:20:51.551Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3701,7 +3701,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
-- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially the oss submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
+- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
@@ -8924,12 +8924,15 @@ var worktree_bootstrap_config_exports = {};
 __export(worktree_bootstrap_config_exports, {
   MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
+  SUBMODULE_DEFAULT_BRANCH_FALLBACK: () => SUBMODULE_DEFAULT_BRANCH_FALLBACK,
   WORKTREE_BOOTSTRAP_STALE_RUNNING_MS: () => WORKTREE_BOOTSTRAP_STALE_RUNNING_MS,
   computeStaleInputsDigest: () => computeStaleInputsDigest,
   evaluateWorktreeBootstrapState: () => evaluateWorktreeBootstrapState,
   getRegisteredSubmodulePaths: () => getRegisteredSubmodulePaths,
+  getSubmoduleConfiguredBranches: () => getSubmoduleConfiguredBranches,
   isWorktreeBootstrapStaleRunning: () => isWorktreeBootstrapStaleRunning,
   loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
+  resolveSubmoduleDefaultBranch: () => resolveSubmoduleDefaultBranch,
   runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
   shouldDeferDispatchForBootstrap: () => shouldDeferDispatchForBootstrap,
   validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
@@ -8960,6 +8963,81 @@ function getRegisteredSubmodulePaths(workspace) {
   }
   return paths;
 }
+function getSubmoduleConfiguredBranches(workspace) {
+  const branchesByPath = /* @__PURE__ */ new Map();
+  try {
+    const out = execFileSync2(
+      resolveWin32Executable("git"),
+      ["config", "--file", ".gitmodules", "--list"],
+      { cwd: workspace, encoding: "utf8", timeout: 1e4, windowsHide: true }
+    );
+    const pathByName = /* @__PURE__ */ new Map();
+    const branchByName = /* @__PURE__ */ new Map();
+    for (const line of String(out).split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq < 0) continue;
+      const key2 = trimmed.slice(0, eq);
+      const value = trimmed.slice(eq + 1).trim();
+      const match = /^submodule\.(.+)\.(path|branch)$/.exec(key2);
+      if (!match) continue;
+      const name = match[1];
+      if (match[2] === "path") {
+        const norm = value.replace(/\\/g, "/").replace(/\/+$/, "");
+        if (norm) pathByName.set(name, norm);
+      } else if (value) {
+        branchByName.set(name, value);
+      }
+    }
+    for (const [name, submodulePath] of pathByName) {
+      const branch = branchByName.get(name);
+      if (branch && branch !== ".") branchesByPath.set(submodulePath, branch);
+    }
+  } catch {
+  }
+  return branchesByPath;
+}
+function isPlausibleBranchName(name) {
+  return typeof name === "string" && name.length > 0 && !/\s/.test(name) && name !== "HEAD";
+}
+async function resolveSubmoduleDefaultBranch(opts) {
+  const remote = opts.remote?.trim() || "origin";
+  const localTimeout = opts.timeoutMs ?? 1e4;
+  const git = resolveWin32Executable("git");
+  const execFileAsync4 = promisify3(execFile3);
+  if (opts.superprojectWorkspace && opts.submodulePath) {
+    try {
+      const normalized = opts.submodulePath.replace(/\\/g, "/").replace(/\/+$/, "");
+      const configured = getSubmoduleConfiguredBranches(opts.superprojectWorkspace).get(normalized);
+      if (isPlausibleBranchName(configured)) return configured;
+    } catch {
+    }
+  }
+  try {
+    const { stdout } = await execFileAsync4(
+      git,
+      ["symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`],
+      { cwd: opts.submoduleRepoPath, encoding: "utf8", timeout: localTimeout, windowsHide: true }
+    );
+    const short = String(stdout || "").trim();
+    const prefix = `${remote}/`;
+    const branch = short.startsWith(prefix) ? short.slice(prefix.length) : short;
+    if (isPlausibleBranchName(branch)) return branch;
+  } catch {
+  }
+  try {
+    const { stdout } = await execFileAsync4(
+      git,
+      ["ls-remote", "--symref", remote, "HEAD"],
+      { cwd: opts.submoduleRepoPath, encoding: "utf8", timeout: Math.max(localTimeout, 3e4), windowsHide: true }
+    );
+    const match = /^ref:\s+refs\/heads\/(\S+)\s+HEAD/m.exec(String(stdout || ""));
+    if (match && isPlausibleBranchName(match[1])) return match[1];
+  } catch {
+  }
+  return SUBMODULE_DEFAULT_BRANCH_FALLBACK;
+}
 function isCleanIgnoringSubmoduleGitlinks(porcelain, submodulePaths) {
   const lines = porcelain.split(/\r?\n/).filter((line) => line.length > 0);
   for (const line of lines) {
@@ -9202,13 +9280,14 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
   }
   return state;
 }
-var WORKTREE_BOOTSTRAP_STALE_RUNNING_MS, MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA, DEFAULT_TIMEOUT_MS2, DEFAULT_OUTPUT_LIMIT_BYTES, OUTPUT_SUMMARY_CHARS;
+var WORKTREE_BOOTSTRAP_STALE_RUNNING_MS, SUBMODULE_DEFAULT_BRANCH_FALLBACK, MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA, DEFAULT_TIMEOUT_MS2, DEFAULT_OUTPUT_LIMIT_BYTES, OUTPUT_SUMMARY_CHARS;
 var init_worktree_bootstrap_config = __esm({
   "src/mesh/worktree-bootstrap-config.ts"() {
     "use strict";
     init_resolve_executable();
     init_refine_config();
     WORKTREE_BOOTSTRAP_STALE_RUNNING_MS = 10 * 60 * 1e3;
+    SUBMODULE_DEFAULT_BRANCH_FALLBACK = "main";
     MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
       ".adhdev/worktree_bootstrap.json",
       ".adhdev/worktree_bootstrap.yaml",
@@ -9825,15 +9904,24 @@ async function resolveSubmodulePushes(status, options, execute, timeoutMs) {
       results.push({ ...base, code: "submodule_status_incomplete" });
       continue;
     }
+    const remoteBranch = await resolveSubmoduleDefaultBranch({
+      submoduleRepoPath: repoPath,
+      superprojectWorkspace: status.repoRoot ?? status.workspace,
+      submodulePath: submodule.path,
+      timeoutMs
+    });
+    base.remoteBranch = remoteBranch;
+    const remoteRef = `refs/remotes/origin/${remoteBranch}`;
+    const fetchRefspec = `refs/heads/${remoteBranch}:${remoteRef}`;
     try {
-      await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", "refs/heads/main:refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 3e4 });
+      await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", fetchRefspec], { timeoutMs: timeoutMs ?? 3e4 });
     } catch (error) {
       results.push({ ...base, code: "submodule_fetch_failed", error: formatGitError2(error) });
       continue;
     }
     let alreadyReachable = false;
     try {
-      await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, "refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 15e3 });
+      await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, remoteRef], { timeoutMs: timeoutMs ?? 15e3 });
       alreadyReachable = true;
     } catch {
     }
@@ -9842,20 +9930,20 @@ async function resolveSubmodulePushes(status, options, execute, timeoutMs) {
       continue;
     }
     try {
-      await runGit(repoPath, ["merge-base", "--is-ancestor", "refs/remotes/origin/main", submodule.commit], { timeoutMs: timeoutMs ?? 15e3 });
+      await runGit(repoPath, ["merge-base", "--is-ancestor", remoteRef, submodule.commit], { timeoutMs: timeoutMs ?? 15e3 });
     } catch (error) {
       results.push({ ...base, pushed: false, skipped: false, code: "submodule_non_fast_forward", error: formatGitError2(error) });
       continue;
     }
-    const refspec = `${submodule.commit}:refs/heads/main`;
+    const refspec = `${submodule.commit}:refs/heads/${remoteBranch}`;
     if (!execute) {
       results.push({ ...base, pushed: false, skipped: false, code: "submodule_push_available", refspec });
       continue;
     }
     try {
       await runGit(repoPath, ["push", "origin", refspec], { timeoutMs: timeoutMs ?? 3e4 });
-      await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", "refs/heads/main:refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 3e4 });
-      await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, "refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 15e3 });
+      await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", fetchRefspec], { timeoutMs: timeoutMs ?? 3e4 });
+      await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, remoteRef], { timeoutMs: timeoutMs ?? 15e3 });
       results.push({ ...base, pushed: true, skipped: false, code: "submodule_pushed", refspec });
     } catch (error) {
       results.push({ ...base, pushed: false, skipped: false, code: "submodule_push_failed", refspec, error: formatGitError2(error) });
@@ -10123,6 +10211,7 @@ var init_mesh_fast_forward = __esm({
     "use strict";
     init_git_status();
     init_git_executor();
+    init_worktree_bootstrap_config();
     STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3, forceFresh: true };
   }
 });
@@ -11447,7 +11536,154 @@ var init_mesh_events_pending = __esm({
   }
 });
 
+// src/logging/debug-config.ts
+function isAlwaysOnTraceCategory(category) {
+  return !!category && ALWAYS_ON_TRACE_CATEGORIES.includes(category);
+}
+function normalizeCategories(categories) {
+  if (!Array.isArray(categories)) return [];
+  return categories.map((category) => String(category || "").trim()).filter(Boolean);
+}
+function resolveDebugRuntimeConfig(options = {}) {
+  const dev = options.dev === true;
+  return {
+    logLevel: options.logLevel || (dev ? "debug" : DEFAULT_CONFIG2.logLevel),
+    collectDebugTrace: typeof options.trace === "boolean" ? options.trace : dev,
+    traceContent: options.traceContent === true,
+    traceBufferSize: Number.isFinite(options.traceBufferSize) ? Math.max(10, Math.floor(options.traceBufferSize)) : dev ? DEV_TRACE_BUFFER_SIZE : DEFAULT_CONFIG2.traceBufferSize,
+    traceCategories: normalizeCategories(options.traceCategories)
+  };
+}
+function setDebugRuntimeConfig(config) {
+  currentConfig = {
+    ...config,
+    traceCategories: normalizeCategories(config.traceCategories),
+    traceBufferSize: Math.max(10, Math.floor(config.traceBufferSize || DEFAULT_CONFIG2.traceBufferSize))
+  };
+}
+function getDebugRuntimeConfig() {
+  return { ...currentConfig, traceCategories: [...currentConfig.traceCategories] };
+}
+function resetDebugRuntimeConfig() {
+  currentConfig = { ...DEFAULT_CONFIG2 };
+}
+function shouldCollectTraceCategory(category) {
+  const config = currentConfig;
+  if (isAlwaysOnTraceCategory(category)) return true;
+  if (!config.collectDebugTrace) return false;
+  if (!category) return true;
+  if (config.traceCategories.length === 0) return true;
+  return config.traceCategories.includes(category);
+}
+var NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, ALWAYS_ON_TRACE_CATEGORIES, DEFAULT_CONFIG2, currentConfig;
+var init_debug_config = __esm({
+  "src/logging/debug-config.ts"() {
+    "use strict";
+    NORMAL_TRACE_BUFFER_SIZE = 200;
+    DEV_TRACE_BUFFER_SIZE = 1e3;
+    ALWAYS_ON_TRACE_CATEGORIES = ["completion-gate", "fsm-transition"];
+    DEFAULT_CONFIG2 = {
+      logLevel: "info",
+      collectDebugTrace: false,
+      traceContent: false,
+      traceBufferSize: NORMAL_TRACE_BUFFER_SIZE,
+      traceCategories: []
+    };
+    currentConfig = { ...DEFAULT_CONFIG2 };
+  }
+});
+
+// src/logging/debug-trace.ts
+function summarizeString(value) {
+  return `[${value.length} chars]`;
+}
+function sanitizeTraceValue(value, traceContent) {
+  if (traceContent) {
+    if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
+      );
+    }
+    return value;
+  }
+  if (typeof value === "string") return summarizeString(value);
+  if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
+    );
+  }
+  return value;
+}
+function sanitizeTracePayload(payload) {
+  if (!payload) return {};
+  const { traceContent } = getDebugRuntimeConfig();
+  return sanitizeTraceValue(payload, traceContent);
+}
+function createEntry(event) {
+  return {
+    id: `trace_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+    ts: Date.now(),
+    ...event,
+    payload: sanitizeTracePayload(event.payload)
+  };
+}
+function createDebugTraceStore(options) {
+  const entries = [];
+  const capacity = Math.max(1, Math.floor(options.capacity || 100));
+  return {
+    record(event) {
+      if (!options.enabled && !isAlwaysOnTraceCategory(event.category)) return null;
+      const entry = createEntry(event);
+      entries.push(entry);
+      if (entries.length > capacity) {
+        entries.splice(0, entries.length - capacity);
+      }
+      return entry;
+    },
+    list(query = {}) {
+      const limit = Math.max(1, Math.floor(query.limit || 100));
+      return entries.filter((entry) => !query.interactionId || entry.interactionId === query.interactionId).filter((entry) => !query.category || entry.category === query.category).slice(-limit).map((entry) => ({ ...entry, payload: entry.payload ? { ...entry.payload } : {} }));
+    },
+    clear() {
+      entries.splice(0, entries.length);
+    }
+  };
+}
+function configureDebugTraceStore() {
+  const config = getDebugRuntimeConfig();
+  globalStore = createDebugTraceStore({
+    enabled: config.collectDebugTrace,
+    capacity: config.traceBufferSize
+  });
+}
+function recordDebugTrace(event) {
+  if (!shouldCollectTraceCategory(event.category)) return null;
+  return globalStore.record(event);
+}
+function getRecentDebugTrace(query = {}) {
+  return globalStore.list(query);
+}
+function clearDebugTrace() {
+  globalStore.clear();
+}
+function createInteractionId(prefix = "ix") {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+var globalStore;
+var init_debug_trace = __esm({
+  "src/logging/debug-trace.ts"() {
+    "use strict";
+    init_debug_config();
+    globalStore = createDebugTraceStore({ enabled: false, capacity: getDebugRuntimeConfig().traceBufferSize });
+  }
+});
+
 // src/mesh/mesh-events-stale.ts
+function recordSynthCompletionGateTrace(stage, payload) {
+  recordDebugTrace({ category: "completion-gate", stage, level: "debug", payload });
+}
 function findRecentTerminalLedgerEvidence(args) {
   if (!args.sessionId && !args.nodeId) return null;
   const entries = readLedgerEntries(args.meshId, { tail: 200 });
@@ -11581,6 +11817,7 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
     completedAt
   });
   const workerResult = evidence.workerResult;
+  const selfAttributing = workerResult.source === "final_summary_json";
   const dispatchTime = dispatch?.timestamp ? new Date(dispatch.timestamp).getTime() : Number.NaN;
   const transcriptTime = args.transcriptMessageAt ? new Date(args.transcriptMessageAt).getTime() : Number.NaN;
   const transcriptAfterDispatch = Number.isFinite(dispatchTime) && Number.isFinite(transcriptTime) && transcriptTime >= dispatchTime;
@@ -11613,7 +11850,9 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
         dispatchEntryId: dispatch?.id,
         dispatchTimestamp: dispatch?.timestamp,
         transcriptMessageAt: readNonEmptyString2(args.transcriptMessageAt),
-        transcriptFinalAssistantPresent: true
+        // Honestly reflect self-attribution: a plain-text tail did NOT prove a turn-final
+        // assistant message (only a self-attributing final_summary_json did).
+        transcriptFinalAssistantPresent: selfAttributing
       },
       evidence
     }
@@ -11630,6 +11869,11 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
     finalSummary,
     taskId: args.taskId,
     workerResult,
+    // EARLYNOTIFY-GATEBYPASS (c): mark a non-self-attributing synth WEAK so its pending
+    // fingerprint is `…::weak` (isWeakCompletionMetadata reads evidenceLevel), never claiming
+    // the genuine dedup slot. evidenceLevel:'weak' is deliberately NOT a false-idle marker
+    // (the transcript tail existed) — it keeps the completion superseable, not suppressed.
+    ...selfAttributing ? {} : { evidenceLevel: "weak" },
     completionDiagnostic: {
       reason: "direct_task_transcript_reconciliation",
       terminalLedgerKind: kind,
@@ -11648,6 +11892,14 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
     ...readNonEmptyString2(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString2(args.targetCoordinatorDaemonId) } : {},
     ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
   });
+  recordSynthCompletionGateTrace("synth-fire", {
+    producer: "transcript_reconcile",
+    source: args.source || "direct_task_transcript_reconciliation",
+    taskId: args.taskId,
+    kind,
+    selfAttributing,
+    evidenceLevel: selfAttributing ? "sufficient" : "weak"
+  });
   return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };
 }
 function buildNoProgressCompletionReconciliation(args) {
@@ -11659,10 +11911,20 @@ function buildNoProgressCompletionReconciliation(args) {
   const completionDiagnostic = readRecord5(args.metadataEvent.completionDiagnostic);
   const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
   const status = readNonEmptyString2(args.metadataEvent.status).toLowerCase();
+  const noProgressSelfAttributing = Boolean(
+    finalSummary || workerResult || completionDiagnostic?.finalAssistantPresent === true
+  );
   const explicitCompletionEvidence = Boolean(
-    finalSummary || workerResult || completionDiagnostic?.finalAssistantPresent === true || status === "idle" || status === "ready" || status === "completed"
+    noProgressSelfAttributing || status === "idle" || status === "ready" || status === "completed"
   );
   if (explicitCompletionEvidence) {
+    recordSynthCompletionGateTrace("synth-fire", {
+      producer: "no_progress_reconcile",
+      source: "no_progress_reconciliation",
+      taskId: readNonEmptyString2(args.metadataEvent.taskId),
+      selfAttributing: noProgressSelfAttributing,
+      evidenceLevel: noProgressSelfAttributing ? "sufficient" : "weak"
+    });
     return {
       ...args.metadataEvent,
       targetSessionId: sessionId,
@@ -11672,6 +11934,7 @@ function buildNoProgressCompletionReconciliation(args) {
       source: "no_progress_reconciliation",
       reconciledFromEvent: "monitor:no_progress",
       timestamp: args.metadataEvent.timestamp ?? Date.now(),
+      ...noProgressSelfAttributing ? {} : { evidenceLevel: "weak" },
       completionDiagnostic: {
         ...completionDiagnostic || {},
         reconciliationReason: "provider_completion_evidence"
@@ -11700,6 +11963,7 @@ var init_mesh_events_stale = __esm({
     init_mesh_delivery_policy();
     init_mesh_events_pending();
     init_mesh_events_utils();
+    init_debug_trace();
     init_dist();
     DIRECT_DISPATCH_RECONCILE_GRACE_MS = 6e4;
     DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS = 12e4;
@@ -12749,6 +13013,32 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   );
   return true;
 }
+function awaitClaimWindowMs(cycles) {
+  return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
+}
+function remoteSessionAppearsLive(meshId, sessionId) {
+  if (!sessionId) return false;
+  try {
+    return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId));
+  } catch {
+    return false;
+  }
+}
+function inWindowAutoLaunchSessionIdsForNode(meshId, nodeId) {
+  const nowMs = Date.now();
+  const out = [];
+  for (const task of getQueue(meshId, { status: ["pending"] })) {
+    const al = task.autoLaunch;
+    const sid = al ? readNonEmptyString2(al.sessionId) : "";
+    if (!al || al.status !== "started" && al.status !== "completed" || !sid) continue;
+    if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
+    const launchedAtMs = Date.parse(al.updatedAt);
+    const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
+    if (inBaseWindow || inBackoff) out.push(sid);
+  }
+  return out;
+}
 function isActionableSkipReason(reason) {
   if (!reason) return false;
   return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
@@ -12988,8 +13278,24 @@ function isSessionActivelyGenerating(components, sessionId) {
   if (!state) return false;
   return sessionStateLooksActive(state);
 }
+function resolveSessionBusyVerdict(components, sessionId) {
+  if (!sessionId) return "UNKNOWN";
+  try {
+    const instances = components.instanceManager?.getByCategory?.("cli") || [];
+    const inst = instances.find((i) => {
+      const sid = readNonEmptyString2(i?.getState?.().instanceId);
+      return sid && sessionIdsEquivalent(sid, sessionId);
+    });
+    if (!inst) return "UNKNOWN";
+    const state = inst.getState?.();
+    if (!state) return "UNKNOWN";
+    return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
+  } catch {
+    return "UNKNOWN";
+  }
+}
 function liveSessionCountForNode(components, meshId, nodeId) {
-  return components.instanceManager.getByCategory("cli").filter((inst) => {
+  const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
     const state = inst.getState();
     const settings = state.settings || {};
     if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
@@ -12997,9 +13303,16 @@ function liveSessionCountForNode(components, meshId, nodeId) {
     if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
     const status = readNonEmptyString2(state.status).toLowerCase();
     return !isTerminalSessionStatus(status);
-  }).length;
+  });
+  let count = localInstances.length;
+  const localSessionIds = localInstances.map((inst) => readNonEmptyString2(inst.getState().instanceId)).filter(Boolean);
+  for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
+    if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
+  }
+  return count;
 }
 function nodeHasLiveSessionPendingClaim(components, meshId, nodeId) {
+  if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
   const busySessionIds = new Set(
     getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId)).map((task) => readNonEmptyString2(task.assignedSessionId)).filter(Boolean)
   );
@@ -13110,10 +13423,54 @@ async function resolveUsableProvider(components, nodeId, node, requiredTags) {
 function readMeshNodeId(node) {
   return normalizeMeshNodeId(node) ?? "";
 }
+function driveExpiredAwaitClaim(components, meshId, task, ctx) {
+  const { sessionId, nodeId, providerType } = ctx;
+  const backoffKey = `${meshId}::${task.id}`;
+  const nowMs = Date.now();
+  const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
+  if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
+  const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+  const live = remoteSessionAppearsLive(meshId, sessionId);
+  if ((live || atCap) && nodeId && providerType) {
+    try {
+      MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
+    } catch {
+    }
+    const assigned = tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+    if (assigned) {
+      autoLaunchAwaitClaimBackoff.delete(backoffKey);
+      const isFallback = atCap && !live;
+      recordAutoLaunchEvent(meshId, {
+        phase: "completed",
+        taskId: task.id,
+        reason: isFallback ? "await_claim_direct_dispatch_fallback" : "await_claim_redriven",
+        nodeId,
+        sessionId
+      });
+      LOG.info("MeshQueue", `Auto-launch await-claim ${isFallback ? "direct-dispatch fallback" : "re-drive"} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
+      return isFallback ? "fallback" : "claimed";
+    }
+    if (atCap) {
+      autoLaunchAwaitClaimBackoff.delete(backoffKey);
+      return "respawn";
+    }
+  }
+  const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
+  autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
+  recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
+  return "backoff";
+}
 async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   const queue = getQueue(meshId);
   const statusById = new Map(queue.map((task) => [task.id, task.status]));
   const pending = queue.filter((task) => task.status === "pending");
+  {
+    const pendingIds = new Set(pending.map((t) => t.id));
+    const prefix = `${meshId}::`;
+    for (const key2 of [...autoLaunchAwaitClaimBackoff.keys()]) {
+      if (key2.startsWith(prefix) && !pendingIds.has(key2.slice(prefix.length))) autoLaunchAwaitClaimBackoff.delete(key2);
+    }
+  }
   if (!pending.length) return false;
   const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
   const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
@@ -13138,10 +13495,18 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
     }
     if (task.autoLaunch?.status === "completed" && task.autoLaunch.sessionId) {
       const launchedAtMs = Date.parse(task.autoLaunch.updatedAt);
+      const alSessionId = readNonEmptyString2(task.autoLaunch.sessionId);
+      const alNodeId = readNonEmptyString2(task.autoLaunch.nodeId);
+      const alProvider = readNonEmptyString2(task.autoLaunch.providerType);
       if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
-        recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: task.autoLaunch.nodeId, sessionId: task.autoLaunch.sessionId });
+        recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: alNodeId, sessionId: alSessionId });
         continue;
       }
+      if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
+        const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
+        if (outcome === "claimed" || outcome === "fallback") return true;
+        if (outcome === "backoff") continue;
+      }
     }
     const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
       if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
@@ -13527,7 +13892,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
+var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -13562,6 +13927,9 @@ var init_mesh_queue_assignment = __esm({
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
     AUTO_LAUNCH_AWAIT_CLAIM_MS = 9e4;
+    AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
+    AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
+    autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
     lastAutoLaunchLedgerKey = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
     ACTIONABLE_SKIP_REASON_PREFIXES = [
@@ -14589,22 +14957,26 @@ function extractFinalSummaryFromMessagesAfter(messages, minTimestampMs, maxChars
   return "";
 }
 function extractFinalAssistantSummaryEvidence(messages, maxChars = DEFAULT_FINAL_SUMMARY_MAX_CHARS) {
-  if (!Array.isArray(messages) || messages.length === 0) return { finalSummary: "" };
+  const turnEnd = selectFinalAssistantTurnEndMessage(messages);
+  if (!turnEnd) return { finalSummary: "" };
+  return {
+    finalSummary: flattenContent(turnEnd.content).trim().slice(0, maxChars),
+    transcriptMessageAt: readChatMessageTimestampIso(turnEnd)
+  };
+}
+function selectFinalAssistantTurnEndMessage(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (!msg) continue;
     const classification = classifyChatMessageVisibility(msg);
-    if (classification.isUserFacing && (msg.role === "assistant" || msg.role === "model")) {
-      const text = flattenContent(msg.content).trim();
-      if (text) {
-        return {
-          finalSummary: text.slice(0, maxChars),
-          transcriptMessageAt: readChatMessageTimestampIso(msg)
-        };
-      }
+    if (!classification.isUserFacing) continue;
+    if (msg.role === "assistant" || msg.role === "model") {
+      return flattenContent(msg.content).trim() ? msg : null;
     }
+    return null;
   }
-  return { finalSummary: "" };
+  return null;
 }
 function canonicalizeKindHint(value) {
   return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
@@ -17598,6 +17970,11 @@ function recoverStrandedAssignedDispatches(components, meshId, store) {
   const assigned = getQueue(meshId, { status: ["assigned"] });
   if (!assigned.length) return;
   const nowMs = Date.now();
+  const assignedKeys = new Set(assigned.map((r) => `${meshId}::${r.id}`));
+  const meshKeyPrefix = `${meshId}::`;
+  for (const key2 of [...deliveredNoTurnUnknownStreak.keys()]) {
+    if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) deliveredNoTurnUnknownStreak.delete(key2);
+  }
   for (const row of assigned) {
     const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
     if (!Number.isFinite(dispatchedAtMs)) continue;
@@ -17621,20 +17998,45 @@ function recoverStrandedAssignedDispatches(components, meshId, store) {
     }
     if (store.taskHasConfirmedDelivery(meshId, row.id)) {
       if (nowMs - dispatchedAtMs < DELIVERED_NO_TURN_DEADLINE_MS) continue;
-      if (row.assignedSessionId && isSessionActivelyGenerating(components, row.assignedSessionId)) continue;
+      const streakKey = `${meshId}::${row.id}`;
+      const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
+      if (verdict === "GENERATING") {
+        deliveredNoTurnUnknownStreak.delete(streakKey);
+        continue;
+      }
+      let reclaimReason;
+      if (verdict === "IDLE_CONFIRMED") {
+        deliveredNoTurnUnknownStreak.delete(streakKey);
+        reclaimReason = "delivered_no_turn_deadline";
+      } else {
+        const streak = (deliveredNoTurnUnknownStreak.get(streakKey) ?? 0) + 1;
+        deliveredNoTurnUnknownStreak.set(streakKey, streak);
+        if (streak < RECLAIM_UNKNOWN_GRACE_TICKS) {
+          traceMeshEventDrop("reclaim_deferred_unknown_verdict", {
+            taskId: row.id,
+            sessionId: row.assignedSessionId,
+            nodeId: row.assignedNodeId,
+            meshId,
+            event: "agent:generating_completed"
+          }, `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
+          continue;
+        }
+        reclaimReason = "reclaim_after_unknown_grace";
+      }
       const reclaimedLost = reclaimStrandedAssignedTask(meshId, row.id, {
-        reason: "delivered_no_turn_deadline",
+        reason: reclaimReason,
         ageMs: nowMs - dispatchedAtMs
       });
       if (reclaimedLost) {
-        LOG.warn("MeshReconcile", `Reclaimed delivered-but-lost task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, delivered but no completion in ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s, session non-generating \u2192 ${reclaimedLost.status})`);
+        deliveredNoTurnUnknownStreak.delete(streakKey);
+        LOG.warn("MeshReconcile", `Reclaimed delivered-but-lost task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, delivered but no completion in ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s, verdict ${verdict} \u2192 ${reclaimReason} \u2192 ${reclaimedLost.status})`);
         traceMeshEventDrop("assigned_stranded_delivered_no_turn", {
           taskId: row.id,
           sessionId: row.assignedSessionId,
           nodeId: row.assignedNodeId,
           meshId,
           event: "agent:generating_completed"
-        }, `delivered ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s \u2192 ${reclaimedLost.status}`);
+        }, `delivered ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s ${reclaimReason} \u2192 ${reclaimedLost.status}`);
       }
       continue;
     }
@@ -18337,7 +18739,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -18368,6 +18770,8 @@ var init_mesh_reconcile_loop = __esm({
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
     DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
+    RECLAIM_UNKNOWN_GRACE_TICKS = 3;
+    deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
     STRICT_SESSION_MATCH_TTL_MS = 6e4;
     unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
     MAX_FORWARD_REJECTIONS = 5;
@@ -18497,58 +18901,6 @@ var init_approval_utils = __esm({
   }
 });
 
-// src/logging/debug-config.ts
-function normalizeCategories(categories) {
-  if (!Array.isArray(categories)) return [];
-  return categories.map((category) => String(category || "").trim()).filter(Boolean);
-}
-function resolveDebugRuntimeConfig(options = {}) {
-  const dev = options.dev === true;
-  return {
-    logLevel: options.logLevel || (dev ? "debug" : DEFAULT_CONFIG2.logLevel),
-    collectDebugTrace: typeof options.trace === "boolean" ? options.trace : dev,
-    traceContent: options.traceContent === true,
-    traceBufferSize: Number.isFinite(options.traceBufferSize) ? Math.max(10, Math.floor(options.traceBufferSize)) : dev ? DEV_TRACE_BUFFER_SIZE : DEFAULT_CONFIG2.traceBufferSize,
-    traceCategories: normalizeCategories(options.traceCategories)
-  };
-}
-function setDebugRuntimeConfig(config) {
-  currentConfig = {
-    ...config,
-    traceCategories: normalizeCategories(config.traceCategories),
-    traceBufferSize: Math.max(10, Math.floor(config.traceBufferSize || DEFAULT_CONFIG2.traceBufferSize))
-  };
-}
-function getDebugRuntimeConfig() {
-  return { ...currentConfig, traceCategories: [...currentConfig.traceCategories] };
-}
-function resetDebugRuntimeConfig() {
-  currentConfig = { ...DEFAULT_CONFIG2 };
-}
-function shouldCollectTraceCategory(category) {
-  const config = currentConfig;
-  if (!config.collectDebugTrace) return false;
-  if (!category) return true;
-  if (config.traceCategories.length === 0) return true;
-  return config.traceCategories.includes(category);
-}
-var NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, DEFAULT_CONFIG2, currentConfig;
-var init_debug_config = __esm({
-  "src/logging/debug-config.ts"() {
-    "use strict";
-    NORMAL_TRACE_BUFFER_SIZE = 200;
-    DEV_TRACE_BUFFER_SIZE = 1e3;
-    DEFAULT_CONFIG2 = {
-      logLevel: "info",
-      collectDebugTrace: false,
-      traceContent: false,
-      traceBufferSize: NORMAL_TRACE_BUFFER_SIZE,
-      traceCategories: []
-    };
-    currentConfig = { ...DEFAULT_CONFIG2 };
-  }
-});
-
 // src/providers/sdk/v1/schemas/cli/provider.schema.json
 var provider_schema_default;
 var init_provider_schema = __esm({
@@ -30582,97 +30934,18 @@ function resolveTargetSessionActualWorkspace(h, targetSessionId) {
 
 // src/commands/chat-commands-debug-bundle.ts
 init_logger();
+init_debug_trace();
 import * as fs7 from "fs";
 import * as os10 from "os";
 import * as path17 from "path";
 import { randomUUID as randomUUID11 } from "crypto";
 
-// src/logging/debug-trace.ts
-init_debug_config();
-function summarizeString(value) {
-  return `[${value.length} chars]`;
-}
-function sanitizeTraceValue(value, traceContent) {
-  if (traceContent) {
-    if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
-    if (value && typeof value === "object") {
-      return Object.fromEntries(
-        Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
-      );
-    }
-    return value;
-  }
-  if (typeof value === "string") return summarizeString(value);
-  if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
-    );
-  }
-  return value;
-}
-function sanitizeTracePayload(payload) {
-  if (!payload) return {};
-  const { traceContent } = getDebugRuntimeConfig();
-  return sanitizeTraceValue(payload, traceContent);
-}
-function createEntry(event) {
-  return {
-    id: `trace_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    ts: Date.now(),
-    ...event,
-    payload: sanitizeTracePayload(event.payload)
-  };
-}
-function createDebugTraceStore(options) {
-  const entries = [];
-  const capacity = Math.max(1, Math.floor(options.capacity || 100));
-  return {
-    record(event) {
-      if (!options.enabled) return null;
-      const entry = createEntry(event);
-      entries.push(entry);
-      if (entries.length > capacity) {
-        entries.splice(0, entries.length - capacity);
-      }
-      return entry;
-    },
-    list(query = {}) {
-      const limit = Math.max(1, Math.floor(query.limit || 100));
-      return entries.filter((entry) => !query.interactionId || entry.interactionId === query.interactionId).filter((entry) => !query.category || entry.category === query.category).slice(-limit).map((entry) => ({ ...entry, payload: entry.payload ? { ...entry.payload } : {} }));
-    },
-    clear() {
-      entries.splice(0, entries.length);
-    }
-  };
-}
-var globalStore = createDebugTraceStore({ enabled: false, capacity: getDebugRuntimeConfig().traceBufferSize });
-function configureDebugTraceStore() {
-  const config = getDebugRuntimeConfig();
-  globalStore = createDebugTraceStore({
-    enabled: config.collectDebugTrace,
-    capacity: config.traceBufferSize
-  });
-}
-function recordDebugTrace(event) {
-  if (!shouldCollectTraceCategory(event.category)) return null;
-  return globalStore.record(event);
-}
-function getRecentDebugTrace(query = {}) {
-  return globalStore.list(query);
-}
-function clearDebugTrace() {
-  globalStore.clear();
-}
-function createInteractionId(prefix = "ix") {
-  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
 // src/commands/chat-commands-read.ts
 init_contracts();
 import * as path16 from "path";
 init_coordinator_registry();
 init_logger();
+init_debug_trace();
 
 // src/chat/source-machine.ts
 var INITIAL_CHAT_SOURCE_STATE = Object.freeze({
@@ -35907,6 +36180,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
 };
 
 // src/commands/low-family/session-host.ts
+init_debug_trace();
 function toHostedCliRuntimeDescriptor(record) {
   if (!record || typeof record !== "object") return null;
   const runtimeId = typeof record.sessionId === "string" ? record.sessionId : "";
@@ -36398,6 +36672,7 @@ var refineConfigHandlers = {
 
 // src/commands/low-family/diagnostics.ts
 init_logger();
+init_debug_trace();
 import * as fs11 from "fs";
 var diagnosticsHandlers = {
   get_logs: async (_ctx, args) => {
@@ -37910,6 +38185,7 @@ function applyPreLaunchTrust(trust, workingDir) {
 
 // src/providers/spec/fsm-driver.ts
 init_logger();
+init_debug_trace();
 init_debug_config();
 init_pty_write_chunking();
 function countNewlines(s2) {
@@ -40765,6 +41041,7 @@ function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFact
 
 // src/providers/cli-provider-instance.ts
 init_logger();
+init_debug_trace();
 init_debug_config();
 init_mesh_event_trace();
 init_control_effects();
@@ -40788,6 +41065,46 @@ function normalizeProviderSessionId(provider, providerSessionId) {
   return normalizedId;
 }
 
+// src/providers/native-history/antigravity-claim-registry.ts
+var claimsByUuid = /* @__PURE__ */ new Map();
+var CLAIM_STALE_MS = 10 * 60 * 1e3;
+function normalizeUuid(uuid) {
+  return String(uuid || "").trim().toLowerCase();
+}
+function antigravityOwnerToken(workspace, sessionStartedAtMs, instanceId) {
+  const iid = typeof instanceId === "string" ? instanceId.trim() : "";
+  if (iid) return `iid:${iid}`;
+  if (typeof sessionStartedAtMs === "number" && sessionStartedAtMs > 0) {
+    const ws = String(workspace || "").trim().toLowerCase();
+    return `spawn:${ws}:${sessionStartedAtMs}`;
+  }
+  return "";
+}
+function claimAntigravityConversation(uuid, owner, now = Date.now()) {
+  const key2 = normalizeUuid(uuid);
+  if (!key2 || !owner) return false;
+  const existing = claimsByUuid.get(key2);
+  if (existing && existing.owner !== owner && now - existing.refreshedAtMs < CLAIM_STALE_MS) {
+    return false;
+  }
+  claimsByUuid.set(key2, { owner, refreshedAtMs: now });
+  return true;
+}
+function isAntigravityConversationClaimedByOther(uuid, owner, now = Date.now()) {
+  const key2 = normalizeUuid(uuid);
+  if (!key2) return false;
+  const existing = claimsByUuid.get(key2);
+  if (!existing) return false;
+  if (existing.owner === owner) return false;
+  return now - existing.refreshedAtMs < CLAIM_STALE_MS;
+}
+function releaseAntigravityOwner(owner) {
+  if (!owner) return;
+  for (const [key2, claim] of claimsByUuid) {
+    if (claim.owner === owner) claimsByUuid.delete(key2);
+  }
+}
+
 // src/providers/cli-provider-instance.ts
 init_chat_message_normalization();
 
@@ -41720,7 +42037,20 @@ var CliProviderInstance = class _CliProviderInstance {
       if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key2);
     }
   }
+  /**
+   * Owner token for this session in the antigravity conversation-claim
+   * registry. Derived identically to the dispatcher's read-side token
+   * (workspace + spawn time) so the claims the dispatcher records under this
+   * session are the ones dispose() releases.
+   */
+  antigravityClaimOwner() {
+    return antigravityOwnerToken(this.workingDir, this.startedAt);
+  }
   dispose() {
+    if (this.type === "antigravity-cli") {
+      const owner = this.antigravityClaimOwner();
+      if (owner) releaseAntigravityOwner(owner);
+    }
     this.adapter.shutdown();
     this.monitor.reset();
     if (this.autoApproveSettleTimer) {
@@ -42475,12 +42805,21 @@ var CliProviderInstance = class _CliProviderInstance {
     if (this.isMeshWorkerSession()) {
       traceMeshEventStage("fired", this.meshTraceCtx(), `${reason} (source=${fcEvidenceSource})`);
     }
+    if (this.completionTraceOn()) this.recordCompletionGateTrace("synth-fire", {
+      path: "startup_grace_fast_collapse",
+      reason,
+      evidenceSource: fcEvidenceSource,
+      hadFinalSummary: !!fcFinalSummary,
+      missingEvidence,
+      evidenceLevel: "weak"
+    });
     this.pushEvent({
       event: "agent:generating_completed",
       chatTitle,
       duration: 0,
       timestamp: now,
       finalSummary: fcFinalSummary,
+      evidenceLevel: "weak",
       completionDiagnostic: {
         reason,
         finalAssistantEvidenceSource: fcEvidenceSource,
@@ -43207,6 +43546,10 @@ ${effect.notification.body || ""}`.trim();
     const previousHistorySessionId = this.providerSessionId || this.instanceId;
     const previousProviderSessionId = this.providerSessionId;
     this.providerSessionId = nextSessionId;
+    if (this.type === "antigravity-cli") {
+      const owner = this.antigravityClaimOwner();
+      if (owner) claimAntigravityConversation(nextSessionId, owner);
+    }
     this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
     this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
     if (this.shouldHydrateExistingProviderHistory()) {
@@ -47083,6 +47426,51 @@ function extractUserPrompt(payload) {
   if (!text) return "";
   return extractUserRequestContent(text);
 }
+function extractModelReasoning(payload) {
+  const inner = firstLenField(payload, 20);
+  if (!inner) return "";
+  const reasoning = firstLenField(inner, 3);
+  if (!reasoning || !looksLikeText(reasoning)) return "";
+  return reasoning.toString("utf-8").trim();
+}
+function topLevelFieldNumbers(payload) {
+  return decodeProtoFields(payload).map((f) => f.field);
+}
+var MIN_RECOVERED_MESSAGE_CHARS = 12;
+function extractUtf8TextRuns(buf) {
+  if (buf.length === 0) return [];
+  const decoded = buf.toString("utf-8");
+  const parts = decoded.split(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]+/);
+  const runs = [];
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.length >= MIN_PRINTABLE_RUN) runs.push(trimmed);
+  }
+  return runs;
+}
+function isPlausibleMessageText(s2) {
+  if (s2.length < MIN_RECOVERED_MESSAGE_CHARS) return false;
+  if (!/[A-Za-zÀ-￿]/.test(s2)) return false;
+  if (/^(file:\/\/|[A-Za-z]:[\\/]|\/[A-Za-z0-9._-]+\/)/.test(s2)) return false;
+  if ((s2.match(/ /g) ?? []).length < 2) return false;
+  if (/[[{]\s*"/.test(s2)) return false;
+  const structural = (s2.match(/[{}[\]":\\]/g) ?? []).length;
+  if (structural / s2.length > 0.12) return false;
+  return true;
+}
+function recoverMessageText(payload, excludeTexts) {
+  const exclusions = excludeTexts.map((t) => t.trim()).filter(Boolean);
+  let best = "";
+  for (const run of extractUtf8TextRuns(payload)) {
+    const candidate = stripAnswerMarker(run).trim();
+    if (!isPlausibleMessageText(candidate)) continue;
+    if (exclusions.some((e) => e === candidate || e.includes(candidate) || candidate.includes(e))) {
+      continue;
+    }
+    if (candidate.length > best.length) best = candidate;
+  }
+  return best;
+}
 function isSqliteBusyError(err) {
   if (!err) return false;
   const code = err.code;
@@ -47161,8 +47549,23 @@ function parseConversationDb(filePath, sessionId, workspace) {
     if (!payload || !Buffer.isBuffer(payload) || payload.length === 0) continue;
     const receivedAt = baseTs + messages.length;
     if (row.step_type === AGY_STEP_TYPE_USER) {
-      const content = extractUserPrompt(payload);
-      if (!content) continue;
+      let content = extractUserPrompt(payload);
+      if (!content) {
+        const recovered = extractUserRequestContent(recoverMessageText(payload, []));
+        if (recovered) {
+          content = recovered;
+          LOG.debug(
+            "NativeHistory",
+            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}): user prompt absent at field 19; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
+          );
+        } else {
+          LOG.debug(
+            "NativeHistory",
+            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no user prompt text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}])`
+          );
+          continue;
+        }
+      }
       const msg = {
         ts: new Date(receivedAt).toISOString(),
         receivedAt,
@@ -47175,8 +47578,24 @@ function parseConversationDb(filePath, sessionId, workspace) {
       if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
       messages.push(msg);
     } else if (row.step_type === AGY_STEP_TYPE_MODEL) {
-      const content = extractModelAnswer(payload);
-      if (!content) continue;
+      let content = extractModelAnswer(payload);
+      if (!content) {
+        const reasoning = extractModelReasoning(payload);
+        const recovered = recoverMessageText(payload, reasoning ? [reasoning] : []);
+        if (recovered) {
+          content = recovered;
+          LOG.debug(
+            "NativeHistory",
+            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}): answer absent at field 20; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
+          );
+        } else {
+          LOG.debug(
+            "NativeHistory",
+            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no answer text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}], reasoningOnly=${reasoning ? "yes" : "no"})`
+          );
+          continue;
+        }
+      }
       const msg = {
         ts: new Date(receivedAt).toISOString(),
         receivedAt,
@@ -47422,7 +47841,8 @@ function createNativeHistoryDispatcher(reader) {
     const sessionId = input.sessionId || input.historySessionId || "";
     const requestedProviderSid = input.providerSessionId || "";
     const sessionStartedAtMs = typeof input.sessionStartedAtMs === "number" ? input.sessionStartedAtMs : typeof input.args?.sessionStartedAtMs === "number" ? input.args.sessionStartedAtMs : 0;
-    const sourcePath = resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs);
+    const instanceId = typeof input.instanceId === "string" ? input.instanceId : typeof input.args?.instanceId === "string" ? input.args.instanceId : "";
+    const sourcePath = resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs, instanceId);
     if (!sourcePath) return null;
     if (input.forceRefresh === true || input.args?.forceRefresh === true) {
       try {
@@ -47450,14 +47870,14 @@ function createNativeHistoryDispatcher(reader) {
     };
   };
 }
-function resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs) {
+function resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs, instanceId) {
   switch (reader) {
     case "claude-cli":
       return resolveClaudePath(workspace, sessionId);
     case "codex-cli":
       return resolveCodexPath(workspace, sessionId, sessionStartedAtMs);
     case "antigravity-cli":
-      return resolveAntigravityPath(workspace, sessionId);
+      return resolveAntigravityPath(workspace, sessionId, sessionStartedAtMs, instanceId);
     case "hermes-cli":
       return resolveHermesPath(workspace, sessionId);
   }
@@ -47572,27 +47992,73 @@ function resolveRealPath(value) {
     return value;
   }
 }
-function resolveAntigravityPath(workspace, sessionId) {
-  void workspace;
+var AGY_SPAWN_CLAIM_GRACE_MS = 2e3;
+function resolveAntigravityPath(workspace, sessionId, sessionStartedAtMs, instanceId) {
   const agyRoot = path33.join(os24.homedir(), ".gemini", "antigravity-cli");
+  const owner = antigravityOwnerToken(workspace, sessionStartedAtMs, instanceId);
   if (sessionId && isUuidLikeSessionId2(sessionId)) {
     const dbPath = path33.join(agyRoot, "conversations", `${sessionId}.db`);
-    if (fs24.existsSync(dbPath)) return dbPath;
+    if (fs24.existsSync(dbPath)) {
+      if (owner) claimAntigravityConversation(sessionId, owner);
+      return dbPath;
+    }
   }
   const brainRoot2 = path33.join(agyRoot, "brain");
   if (fs24.existsSync(brainRoot2)) {
-    const cutoff = Date.now() - RECENT_WINDOW_MS;
-    const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+    const cutoff = spawnAwareCutoff(sessionStartedAtMs);
+    const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => ({ uuid: e.name, p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
     for (const e of entries) {
       const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
-      if (fs24.existsSync(t) && safeSize(t) > 0) return t;
+      if (fs24.existsSync(t) && safeSize(t) > 0) {
+        if (owner) claimAntigravityConversation(e.uuid, owner);
+        return t;
+      }
     }
   }
   const convRoot = path33.join(agyRoot, "conversations");
-  const newestDb = newestRecentFile2(convRoot, /^[0-9a-f-]+\.db$/i);
-  if (newestDb) return newestDb;
+  const picked = pickUnboundConversationDb(convRoot, sessionStartedAtMs, owner);
+  if (picked) {
+    if (owner) claimAntigravityConversation(picked.uuid, owner);
+    return picked.path;
+  }
   return null;
 }
+function pickUnboundConversationDb(convRoot, sessionFloorMs, owner) {
+  let entries = [];
+  try {
+    entries = fs24.readdirSync(convRoot, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const recencyCutoff = Date.now() - RECENT_WINDOW_MS;
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const match = /^([0-9a-f-]+)\.db$/i.exec(entry.name);
+    if (!match || !isUuidLikeSessionId2(match[1])) continue;
+    const uuid = match[1];
+    if (isAntigravityConversationClaimedByOther(uuid, owner)) continue;
+    const p = path33.join(convRoot, entry.name);
+    const mtime = safeMtime(p);
+    if (mtime < recencyCutoff) continue;
+    candidates.push({ path: p, uuid, mtime, birth: safeBirthtime(p) });
+  }
+  if (candidates.length === 0) return null;
+  if (sessionFloorMs > 0) {
+    const floor = sessionFloorMs - AGY_SPAWN_CLAIM_GRACE_MS;
+    const own = candidates.filter((c) => (c.birth > 0 ? c.birth : c.mtime) >= floor);
+    if (own.length === 0) return null;
+    own.sort((a, b) => (a.birth || a.mtime) - (b.birth || b.mtime));
+    return { path: own[0].path, uuid: own[0].uuid };
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  return { path: candidates[0].path, uuid: candidates[0].uuid };
+}
+function spawnAwareCutoff(sessionStartedAtMs) {
+  const recency = Date.now() - RECENT_WINDOW_MS;
+  if (sessionStartedAtMs > 0) return Math.max(recency, sessionStartedAtMs - AGY_SPAWN_CLAIM_GRACE_MS);
+  return recency;
+}
 function resolveHermesPath(workspace, sessionId) {
   void workspace;
   void sessionId;
@@ -47649,6 +48115,15 @@ function safeMtime(p) {
     return 0;
   }
 }
+function safeBirthtime(p) {
+  try {
+    const st = fs24.statSync(p);
+    const birth = Math.floor(st.birthtimeMs);
+    return birth > 0 ? birth : Math.floor(st.mtimeMs);
+  } catch {
+    return 0;
+  }
+}
 function safeSize(p) {
   try {
     return fs24.statSync(p).size;
@@ -53184,6 +53659,7 @@ function getRecentCommands(count = 50) {
 cleanOldFiles();
 
 // src/commands/router.ts
+init_debug_trace();
 init_mesh_host_ownership();
 init_mesh_work_queue();
 import * as fs33 from "fs";
@@ -54476,9 +54952,10 @@ async function resolveProviderTypeFromPriority(args) {
 
 // src/commands/router-refine.ts
 init_logger();
-import { execFileSync as execFileSync8 } from "child_process";
+init_debug_trace();
 init_dist();
 init_mesh_events();
+import { execFileSync as execFileSync8 } from "child_process";
 
 // src/mesh/mesh-refine-batch.ts
 init_resolve_executable();
@@ -55262,6 +55739,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
         commit: gitlink.commit,
         reachable: false
       };
+      let submoduleDefaultBranch = "main";
       try {
         if (!fs30.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
@@ -55314,9 +55792,14 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             entries.push(entry);
             continue;
           }
-          entry.remoteMainBranch = "main";
+          submoduleDefaultBranch = await resolveSubmoduleDefaultBranch({
+            submoduleRepoPath: submodulePath,
+            superprojectWorkspace: repoRoot,
+            submodulePath: gitlink.path
+          });
+          entry.remoteMainBranch = submoduleDefaultBranch;
           try {
-            await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, "main");
+            await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
             entry.fetchedFromOrigin = true;
             entry.remoteReachable = true;
             entry.remoteMainReachable = true;
@@ -55326,17 +55809,17 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             entry.remoteMainReachable = false;
             entry.publishRequired = true;
             const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-            entry.error = `Submodule remote main reachability check failed for origin/main: ${details}`;
+            entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
             if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
               entry.autoPublishAllowed = true;
               entry.autoPublishAttempted = true;
               try {
-                const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, "main");
+                const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, submoduleDefaultBranch);
                 entry.autoPublishRefspec = publish.refspec;
                 entry.publishStdout = truncateValidationOutput(publish.stdout);
                 entry.publishStderr = truncateValidationOutput(publish.stderr);
                 entry.autoPublishSucceeded = true;
-                await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, "main");
+                await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
                 entry.fetchedFromOrigin = true;
                 entry.remoteReachable = true;
                 entry.remoteMainReachable = true;
@@ -55348,12 +55831,12 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
                 entry.autoPublishSucceeded = false;
                 entry.autoPublishVerified = false;
                 const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
-                entry.error = `Submodule auto-publish to origin/main failed or could not be verified: ${publishDetails}`;
+                entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} failed or could not be verified: ${publishDetails}`;
               }
             } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
               entry.autoPublishAllowed = true;
               entry.autoPublishAttempted = false;
-              entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || "candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/main";
+              entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || `candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/${submoduleDefaultBranch}`;
             }
           }
         } catch (e) {
@@ -55361,7 +55844,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
           entry.remoteMainReachable = false;
           entry.publishRequired = true;
           const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-          entry.error = `Submodule remote main reachability check failed for origin/main: ${details}`;
+          entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
         }
       } catch (e) {
         entry.error = truncateValidationOutput(e?.message || String(e));
@@ -58696,6 +59179,7 @@ init_build_info();
 init_normalize();
 init_logger();
 init_debug_config();
+init_debug_trace();
 
 // src/ipc-protocol.ts
 var DEFAULT_DAEMON_PORT = 19222;
@@ -66660,6 +67144,7 @@ var V1_ALL_PRIMITIVES = Object.freeze(
 );
 var V1_CONTRACT_VERSION = "1.0.0";
 export {
+  ALWAYS_ON_TRACE_CATEGORIES,
   AcpProviderInstance,
   AgentStreamPoller,
   BUILTIN_CHAT_MESSAGE_KINDS,
@@ -66891,6 +67376,7 @@ export {
   installGlobalInterceptor,
   interactivePromptFromClaudeAskUserQuestion,
   isActivityChatMessage,
+  isAlwaysOnTraceCategory,
   isBuiltinChatMessageKind,
   isCdpConnected,
   isExtensionInstalled,