@wrongstack/cli 0.303.0 → 0.305.1

package/dist/diag-doctor-WTBHPOMB.js

@@ -0,0 +1,329 @@
+import {
+  API_VERSION
+} from "./chunk-XJXDOF63.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/subcommands/handlers/diag-doctor.ts
+import * as fs2 from "node:fs/promises";
+import * as os from "node:os";
+import * as path2 from "node:path";
+import { color, toErrorMessage } from "@wrongstack/core/utils";
+
+// src/subcommands/handlers/daemon-inventory.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  chronicleProjectServerEndpoint,
+  chronicleProjectServerMetadataPath
+} from "@wrongstack/core/chronicle";
+import {
+  mailboxProjectServerEndpoint,
+  mailboxProjectServerMetadataPath
+} from "@wrongstack/core/coordination";
+import {
+  sessionCatalogProjectServerEndpoint,
+  sessionCatalogProjectServerMetadataPath
+} from "@wrongstack/core/session-catalog";
+import {
+  KANBAN_PROJECT_SERVER_METADATA_FILE,
+  kanbanProjectServerEndpoint
+} from "@wrongstack/kanban";
+import { isProjectEndpointLive } from "@wrongstack/persistence";
+import { sageProjectServerEndpoint, sageProjectServerMetadataPath } from "@wrongstack/sage";
+import {
+  projectIndexServerEndpoint,
+  projectIndexServerMetadataPath
+} from "@wrongstack/tools/codebase-index";
+function describeDaemons(options) {
+  const { projectRoot, projectDir } = options;
+  return [
+    {
+      name: "kanban",
+      // In-repo `<projectRoot>/.wrongstack/`, not the global per-project state
+      // directory the other daemons use. Kanban deliberately keeps its server
+      // file next to the boards it owns.
+      metadataPath: path.join(projectRoot, ".wrongstack", KANBAN_PROJECT_SERVER_METADATA_FILE),
+      endpoint: kanbanProjectServerEndpoint(projectRoot)
+    },
+    {
+      name: "sage",
+      endpoint: sageProjectServerEndpoint(projectRoot),
+      metadataPath: sageProjectServerMetadataPath(projectRoot)
+    },
+    {
+      name: "chronicle",
+      endpoint: chronicleProjectServerEndpoint(projectDir),
+      metadataPath: chronicleProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "mailbox",
+      endpoint: mailboxProjectServerEndpoint(projectDir),
+      metadataPath: mailboxProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "session-catalog",
+      endpoint: sessionCatalogProjectServerEndpoint(projectDir),
+      metadataPath: sessionCatalogProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "codebase-index",
+      endpoint: projectIndexServerEndpoint(projectRoot),
+      metadataPath: projectIndexServerMetadataPath(projectRoot)
+    }
+  ];
+}
+async function readPid(metadataPath) {
+  if (!metadataPath) return void 0;
+  try {
+    const parsed = JSON.parse(await fs.readFile(metadataPath, "utf8"));
+    return typeof parsed.pid === "number" ? parsed.pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function endpointExists(endpoint) {
+  if (process.platform === "win32") return false;
+  try {
+    await fs.stat(endpoint);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectDaemonReports(options) {
+  return Promise.all(
+    describeDaemons(options).map(async (descriptor) => {
+      const live = await isProjectEndpointLive(descriptor.endpoint);
+      const status = live ? "live" : await endpointExists(descriptor.endpoint) ? "stale" : "stopped";
+      const pid = live ? await readPid(descriptor.metadataPath) : void 0;
+      return pid === void 0 ? { name: descriptor.name, endpoint: descriptor.endpoint, status } : { name: descriptor.name, endpoint: descriptor.endpoint, status, pid };
+    })
+  );
+}
+async function clearStaleDaemonEndpoints(options) {
+  const cleared = [];
+  for (const report of await collectDaemonReports(options)) {
+    if (report.status !== "stale") continue;
+    try {
+      await fs.rm(report.endpoint, { force: true });
+      cleared.push(report.name);
+    } catch {
+    }
+  }
+  return cleared;
+}
+
+// src/subcommands/handlers/diag-doctor.ts
+var diagCmd = async (_args, deps) => {
+  const cfg = deps.config;
+  const age = await deps.modelsRegistry.ageSeconds();
+  const lines = [
+    color.bold("WrongStack diagnostics"),
+    `  apiVersion:    ${API_VERSION}`,
+    `  cwd:           ${deps.cwd}`,
+    `  projectRoot:   ${deps.projectRoot}`,
+    `  projectHash:   ${deps.paths.projectHash}`,
+    `  projectDir:    ${deps.paths.projectDir}`,
+    `  globalRoot:    ${deps.paths.globalRoot}`,
+    `  modelsCache:   ${deps.paths.modelsCache}`,
+    `  cacheAge:      ${isFinite(age) ? `${Math.round(age / 60)}m` : "never"}`,
+    `  node:          ${process.version}`,
+    `  os:            ${os.platform()} ${os.release()}`,
+    `  provider:      ${cfg.provider ?? "<unset>"}`,
+    `  model:         ${cfg.model ?? "<unset>"}`,
+    `  tools:         ${deps.toolRegistry?.list().length ?? 0}`,
+    `  plugins:       ${cfg.plugins?.length ?? 0}`,
+    `  mcpServers:    ${Object.keys(cfg.mcpServers ?? {}).length}`
+  ];
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+};
+async function reportDaemons(deps, opts) {
+  const inventory = { projectRoot: deps.projectRoot, projectDir: deps.paths.projectDir };
+  let reports = await collectDaemonReports(inventory);
+  deps.renderer.write(color.bold("WrongStack project daemons\n\n"));
+  const icon = (status) => status === "live" ? color.green("\u2713") : status === "stale" ? color.red("\u2717") : color.dim("\xB7");
+  for (const report of reports) {
+    const suffix = report.pid === void 0 ? "" : ` pid ${report.pid}`;
+    deps.renderer.write(
+      `  ${icon(report.status)} ${report.name.padEnd(16)} ${report.status.padEnd(8)}${color.dim(report.endpoint + suffix)}
+`
+    );
+  }
+  const stale = reports.filter((report) => report.status === "stale");
+  if (stale.length === 0) {
+    deps.renderer.write(color.green("\nNo wedged endpoints.\n"));
+    return 0;
+  }
+  if (!opts.clear) {
+    deps.renderer.write(
+      color.amber(
+        `
+${stale.length} stale endpoint${stale.length === 1 ? "" : "s"}: ${stale.map((report) => report.name).join(", ")}
+`
+      )
+    );
+    deps.renderer.write(
+      color.dim(
+        "  A daemon died without releasing its endpoint. Current daemons reclaim\n  this automatically on next start; clear it now with:\n    wstack doctor --daemons --clear-stale\n"
+      )
+    );
+    return 1;
+  }
+  const cleared = await clearStaleDaemonEndpoints(inventory);
+  reports = await collectDaemonReports(inventory);
+  const remaining = reports.filter((report) => report.status === "stale");
+  if (cleared.length > 0) {
+    deps.renderer.write(color.green(`
+Cleared: ${cleared.join(", ")}
+`));
+  }
+  if (remaining.length > 0) {
+    deps.renderer.write(
+      color.red(`Still wedged: ${remaining.map((report) => report.name).join(", ")}
+`)
+    );
+    return 1;
+  }
+  deps.renderer.write(color.dim("Daemons restart on demand \u2014 no further action needed.\n"));
+  return 0;
+}
+var doctorCmd = async (args, deps) => {
+  const flagged = (name) => deps.flags?.[name] === true || deps.flags?.[name] === "true" || args.includes(`--${name}`);
+  if (flagged("daemons")) {
+    return reportDaemons(deps, { clear: flagged("clear-stale") });
+  }
+  const checks = [];
+  const cfg = deps.config;
+  if (!cfg.provider)
+    checks.push({
+      name: "provider",
+      status: "fail",
+      detail: "no provider configured \u2014 run `wstack auth` to set up"
+    });
+  else checks.push({ name: "provider", status: "ok", detail: cfg.provider });
+  if (!cfg.model)
+    checks.push({
+      name: "model",
+      status: "fail",
+      detail: "no model configured \u2014 run `wstack auth` to configure"
+    });
+  else checks.push({ name: "model", status: "ok", detail: cfg.model });
+  if (cfg.provider) {
+    const providerCfg = cfg.providers?.[cfg.provider];
+    const hasVaultKey = typeof providerCfg?.apiKey === "string" && providerCfg.apiKey.length > 0;
+    const envHit = providerCfg?.envVars?.some((v) => process.env[v]) ?? false;
+    if (hasVaultKey || envHit)
+      checks.push({
+        name: "api key",
+        status: "ok",
+        detail: hasVaultKey ? "found in vault" : "found in env"
+      });
+    else
+      checks.push({
+        name: "api key",
+        status: "fail",
+        detail: `no key for "${cfg.provider}" in vault or env \u2014 run \`wstack auth ${cfg.provider}\``
+      });
+  }
+  try {
+    const age = await deps.modelsRegistry.ageSeconds();
+    if (!isFinite(age))
+      checks.push({
+        name: "models cache",
+        status: "warn",
+        detail: "never fetched \u2014 run `wstack models refresh`"
+      });
+    else if (age > 7 * 24 * 3600)
+      checks.push({
+        name: "models cache",
+        status: "warn",
+        detail: `${Math.round(age / 86400)} days old \u2014 run \`wstack models refresh\``
+      });
+    else
+      checks.push({ name: "models cache", status: "ok", detail: `${Math.round(age / 60)}m old` });
+  } catch (err) {
+    checks.push({
+      name: "models cache",
+      status: "warn",
+      detail: `read failed: ${toErrorMessage(err)}`
+    });
+  }
+  try {
+    await fs2.access(deps.paths.secretsKey);
+    checks.push({ name: "secret vault", status: "ok", detail: deps.paths.secretsKey });
+  } catch {
+    checks.push({
+      name: "secret vault",
+      status: "warn",
+      detail: "not yet initialized (created lazily on first encrypt)"
+    });
+  }
+  try {
+    await fs2.mkdir(deps.paths.projectSessions, { recursive: true });
+    const probe = path2.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
+    await fs2.writeFile(probe, "");
+    await fs2.unlink(probe);
+    checks.push({ name: "sessions writable", status: "ok", detail: deps.paths.projectSessions });
+  } catch (err) {
+    checks.push({
+      name: "sessions writable",
+      status: "fail",
+      detail: `cannot write to ${deps.paths.projectSessions}: ${toErrorMessage(err)}`
+    });
+  }
+  const mcpEntries = Object.entries(cfg.mcpServers ?? {});
+  for (const [name, srv] of mcpEntries) {
+    if (!srv.enabled) continue;
+    if ((srv.transport === "sse" || srv.transport === "streamable-http") && !srv.url)
+      checks.push({ name: `mcp:${name}`, status: "fail", detail: "transport requires url" });
+    else if (srv.transport === "stdio" && !srv.command)
+      checks.push({
+        name: `mcp:${name}`,
+        status: "fail",
+        detail: "stdio transport requires command"
+      });
+    else
+      checks.push({
+        name: `mcp:${name}`,
+        status: "ok",
+        detail: `${srv.transport} ${srv.command ?? srv.url ?? ""}`.trim()
+      });
+  }
+  const major = Number.parseInt(process.version.replace(/^v/, "").split(".")[0] ?? "0", 10);
+  if (major < 22)
+    checks.push({ name: "node", status: "fail", detail: `${process.version} (need \u226522)` });
+  else checks.push({ name: "node", status: "ok", detail: process.version });
+  deps.renderer.write(color.bold("WrongStack doctor\n\n"));
+  let failed = 0;
+  let warned = 0;
+  for (const c of checks) {
+    const icon = c.status === "ok" ? color.green("\u2713") : c.status === "warn" ? color.amber("\u25CF") : color.red("\u2717");
+    deps.renderer.write(`  ${icon} ${c.name.padEnd(20)} ${color.dim(c.detail)}
+`);
+    if (c.status === "fail") failed++;
+    if (c.status === "warn") warned++;
+  }
+  deps.renderer.write("\n");
+  if (failed > 0) {
+    deps.renderer.write(
+      color.red(`${failed} failed, ${warned} warning${warned === 1 ? "" : "s"}
+`)
+    );
+    return 1;
+  }
+  if (warned > 0) {
+    deps.renderer.write(
+      color.amber(`All checks passed (${warned} warning${warned === 1 ? "" : "s"})
+`)
+    );
+    return 0;
+  }
+  deps.renderer.write(color.green("All checks passed.\n"));
+  return 0;
+};
+export {
+  diagCmd,
+  doctorCmd
+};
+//# sourceMappingURL=diag-doctor-WTBHPOMB.js.map

package/dist/execute-deps.d.ts

@@ -48,6 +48,7 @@ export interface ToolPickerItem {
     owner: string;
     category: string;
     enabled: boolean;
+    exposure: 'direct' | 'lazy' | 'disabled';
     mutating: boolean;
     permission: string;
     descMode: 'extend' | 'simple';
@@ -89,6 +90,21 @@ export interface CoreDeps {
     positional: string[];
     slashRegistry: SlashCommandRegistry;
     tokenCounter: TokenCounter;
+    /**
+     * Forward-declared session ref owned by the host (cli-main). When an
+     * in-process `/resume` swaps the agent's active writer, the resume
+     * handler repoints `sessionRef.current` so provider-side
+     * `getSessionId: () => sessionRef.current?.id` callbacks and the
+     * record-mode `bindReplayToContainer` binding follow the resumed
+     * session instead of staying pinned to the boot session.
+     *
+     * Optional: hosts that don't need post-resume propagation (or tests
+     * that predate the refactor) can omit it; provider calls then stay
+     * pinned to the boot session — same behavior as before this existed.
+     */
+    sessionRef?: {
+        current: import('@wrongstack/core/types').SessionWriter | undefined;
+    } | undefined;
     /** Atomically move this process's SessionRegistry ownership after explicit resume. */
     activateSessionIdentity?: ((sessionId: string, target?: import('./wiring/session-registry.js').SessionIdentityTarget) => Promise<void>) | undefined;
     /**

package/dist/{execution-MVOH6PAQ.js → execution-QYFWDD3Y.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-V3XH6XBJ.js";
 import {
   startCliHqConnection
-} from "./chunk-JW75HY4F.js";
+} from "./chunk-FKWHSFX4.js";
 import "./chunk-WHOIR577.js";
 import {
   advanceToNextTask,
@@ -25,17 +25,17 @@ import {
   trySaveSpecFromAIOutput,
   trySaveTasksFromAIOutput
 } from "./chunk-DGXNL7OT.js";
-import {
-  WEBUI_SESSION_CHILD_CAPABILITIES,
-  writeWebuiSessionChildError,
-  writeWebuiSessionChildReady
-} from "./chunk-3JPTNADJ.js";
 import {
   theme
 } from "./chunk-QD544J2B.js";
 import {
   fmtTok
 } from "./chunk-TYO2OVAD.js";
+import {
+  WEBUI_SESSION_CHILD_CAPABILITIES,
+  writeWebuiSessionChildError,
+  writeWebuiSessionChildReady
+} from "./chunk-3JPTNADJ.js";
 import {
   resolveActiveApiKey
 } from "./chunk-SZ42FYPT.js";
@@ -203,7 +203,7 @@ async function runWebUIDispatch(ctx) {
   const isSimpleUi = !isSessionChild && flags["simpleui"] === true;
   agent.disableInteractiveConfirmation();
   renderer.setSilent(true);
-  const { runWebUI } = await import("./webui-server-E3OPEKU5.js");
+  const { runWebUI } = await import("./webui-server-FTG7JAZU.js");
   const flagValue = (names) => {
     for (const name of names) {
       if (!Object.hasOwn(flags, name)) continue;
@@ -985,8 +985,13 @@ import {
   DefaultSystemPromptBuilder,
   setQueuedMessagesSnapshot
 } from "@wrongstack/core/agent";
+import { TOKENS } from "@wrongstack/core/kernel";
 import { DefaultSessionStore } from "@wrongstack/core/storage";
-import { resolveWstackPaths, sessionScopedPath } from "@wrongstack/core/utils";
+import {
+  activateProjectStateGuard,
+  resolveWstackPaths,
+  sessionScopedPath
+} from "@wrongstack/core/utils";
 async function switchProjectInPlace(ctx, targetRoot, displayName) {
   const {
     state,
@@ -1064,6 +1069,7 @@ async function switchProjectInPlace(ctx, targetRoot, displayName) {
     });
     targetActivated = true;
     await state.activateSessionIdentity(nextWriter.id, target);
+    await activateProjectStateGuard(resolved);
   } catch (err) {
     if (!targetActivated) await targetClaim?.cancel().catch(() => void 0);
     else if (oldWriter) {
@@ -1124,6 +1130,13 @@ async function switchProjectInPlace(ctx, targetRoot, displayName) {
       modeStore,
       modeId: modeId ?? "default",
       modePrompt: switchMode?.prompt ?? "",
+      tokenSavingMode: config.features.tokenSavingMode,
+      modelCapabilities: {
+        maxContextTokens: context.provider.capabilities.maxContext,
+        supportsTools: !!context.provider.capabilities.tools,
+        supportsVision: !!context.provider.capabilities.vision,
+        supportsReasoning: !!context.provider.capabilities.reasoning
+      },
       instructionPaths: {
         globalDir: nextWpaths.globalInstructions,
         projectDir: nextWpaths.inProjectInstructions,
@@ -1138,6 +1151,11 @@ async function switchProjectInPlace(ctx, targetRoot, displayName) {
       provider: context.provider.id,
       model: context.model
     });
+    if (agent.container.has(TOKENS.SystemPromptBuilder)) {
+      agent.container.override(TOKENS.SystemPromptBuilder, () => switchBuilder, {
+        owner: "tui-project-switch"
+      });
+    }
   } catch (err) {
     console.error(
       JSON.stringify({
@@ -1298,6 +1316,7 @@ async function resumeSession(ctx, sessionId) {
       throw err;
     }
     writerSwapped = true;
+    state.sessionRef && (state.sessionRef.current = resumed.writer);
     await agent.ctx.flushConversationJournal().catch((err) => {
       console.error(
         JSON.stringify({
@@ -1854,24 +1873,9 @@ function createSettingsAdapter(ctx) {
 // src/boot/tui-theme-adapter.ts
 import * as fs4 from "node:fs/promises";
 import * as path9 from "node:path";
+import { THEME_PRESET_IDS } from "@wrongstack/core/types";
 import { atomicWrite as atomicWrite2 } from "@wrongstack/core/utils";
-var VALID_PRESETS = /* @__PURE__ */ new Set([
-  "catppuccin",
-  "tokyo-night",
-  "nord",
-  "cyberpunk",
-  "dracula",
-  "gruvbox-dark",
-  "solarized-dark",
-  "one-dark",
-  "monokai",
-  "rose-pine",
-  "kanagawa",
-  "ayu-dark",
-  "everforest",
-  "night-owl",
-  "synthwave"
-]);
+var VALID_PRESETS = new Set(THEME_PRESET_IDS);
 function createThemeAdapter({ configStore, wpaths }) {
   return {
     getThemePreset: () => {
@@ -2319,7 +2323,9 @@ async function finalizeExecutionCleanup(input) {
 
 // src/execution-kanban-dispatch.ts
 import { randomUUID } from "node:crypto";
+import { missingRequiredRuntimeTools } from "@wrongstack/core/agent-catalog";
 import { WIDE_SUBAGENT_CAPABILITIES } from "@wrongstack/core/security";
+import { stripFrontmatter } from "@wrongstack/core/skills";
 
 // src/kanban-dispatch-route.ts
 import { fallbackProfileChain, parseModelRef as parseModelRef2 } from "@wrongstack/core/agent";
@@ -2358,21 +2364,43 @@ function createKanbanDispatchHandler({
     } = resolveKanbanDispatchRoute(config, spawnOpts);
     let agentDescription = description;
     if (spawnOpts?.skills?.length && skillLoader) {
-      const loaded = await Promise.all(
-        spawnOpts.skills.map(async (skillName) => {
+      const availableToolNames = spawnOpts.tools;
+      const loaded = [];
+      for (const skillName of spawnOpts.skills) {
+        try {
           const manifest = await skillLoader.find(skillName);
-          if (!manifest) throw new Error(`Kanban skill not found: ${skillName}`);
-          const body = await skillLoader.readBody(skillName);
-          return `## Required skill: ${skillName}
+          if (!manifest) {
+            process.emitWarning(`Kanban dispatch skill not found, skipped: ${skillName}`, {
+              code: "WRONGSTACK_KANBAN_SKILL_SKIPPED"
+            });
+            continue;
+          }
+          if (availableToolNames !== void 0 && missingRequiredRuntimeTools(manifest.requiredTools, availableToolNames).length > 0) {
+            process.emitWarning(
+              `Kanban dispatch skill "${skillName}" needs tools this worker does not have, skipped.`,
+              { code: "WRONGSTACK_KANBAN_SKILL_SKIPPED" }
+            );
+            continue;
+          }
+          const body = stripFrontmatter(await skillLoader.readBody(skillName)).trim();
+          if (!body) continue;
+          loaded.push(`## Required skill: ${skillName}
 
-${body}`;
-        })
-      );
-      agentDescription = `${description}
+${body}`);
+        } catch (err) {
+          process.emitWarning(
+            `Kanban dispatch skill "${skillName}" could not be loaded, skipped: ${err instanceof Error ? err.message : String(err)}`,
+            { code: "WRONGSTACK_KANBAN_SKILL_SKIPPED" }
+          );
+        }
+      }
+      if (loaded.length > 0) {
+        agentDescription = `${description}
 
 # Required agentic skill instructions
 
 ${loaded.join("\n\n")}`;
+      }
     }
     void (async () => {
       const built = await sddSubagentFactory({
@@ -4738,6 +4766,7 @@ async function execute(deps) {
       positional,
       slashRegistry,
       tokenCounter,
+      sessionRef,
       activateSessionIdentity,
       updateInfo: initialUpdateInfo,
       webuiSessionChild
@@ -4934,6 +4963,12 @@ async function execute(deps) {
         activeSessionStore,
         activateSessionIdentity,
         detachActiveTodosCheckpoint,
+        // Plumbed from cli-main.ts so `resumeSession` can repoint the ref
+        // when an in-process `/resume` swaps the active writer. Optional
+        // on TuiRuntimeState; tests/hosts that omit it revert to the
+        // pre-refactor behavior where provider calls stay pinned to the
+        // boot session.
+        sessionRef,
         pendingProjectSwitch: null,
         autonomousCoordinator: null,
         coordinatorRun: null,
@@ -5312,4 +5347,4 @@ export {
   execute,
   resolveReviewerFallbackModels
 };
-//# sourceMappingURL=execution-MVOH6PAQ.js.map
+//# sourceMappingURL=execution-QYFWDD3Y.js.map

package/dist/fleet/host-context.d.ts

@@ -6,6 +6,8 @@ export interface SkillResolutionReport {
     selected: string[];
     /** skill → why it was dropped, so the omission is never silent. */
     dropped: Record<string, 'not-found' | 'missing-capability' | 'missing-tool' | 'budget' | 'empty'>;
+    /** Skills kept under budget by shortening their bundled body. */
+    trimmed: string[];
 }
 export declare function resolveHostSubagentSkillResolution(deps: MultiAgentDeps, roster: Record<string, SubagentConfig>, subCfg: SubagentConfig, availableToolNames?: readonly string[]): Promise<SkillResolutionReport>;
 /** Backwards-compatible wrapper for callers that only need the prompt text. */

package/dist/fleet/host-session-writer.d.ts

@@ -1,3 +1,36 @@
 import type { SessionWriter } from '@wrongstack/core/types';
+/**
+ * Session writer for a subagent that has no journal of its own: its events are
+ * interleaved into the parent's JSONL.
+ *
+ * Lifecycle and rewind *control* stay no-ops — `writeCheckpoint`,
+ * `writeInFlightMarker`, `truncateToCheckpoint`, `clearSession` and `close`
+ * belong to the parent, and a subagent driving them would corrupt the parent's
+ * checkpoint chain and crash-recovery markers.
+ *
+ * Rewind *evidence* is a different thing and is forwarded. A subagent's file
+ * mutations are real edits to the user's working tree, made under the parent
+ * prompt that spawned it; dropping their `file_snapshot` records left `/rewind`
+ * quietly unable to undo them, with nothing in the transcript saying so. The
+ * parent writer files them against its own `activePromptIndex`, which is
+ * exactly the prompt a user rewinding this work would target.
+ */
 export declare function createParentSubagentSessionWriter(parentSession: SessionWriter): SessionWriter;
+/**
+ * Wrap a subagent's own `SessionWriter` so its file mutations are ALSO recorded
+ * against the parent session.
+ *
+ * When a subagent gets a real per-subagent JSONL, its `file_snapshot` events
+ * land in that file — under the director run directory, which
+ * `DefaultSessionRewinder` never reads: it resolves one path, the session being
+ * rewound. So the richer, "proper" subagent-session path was the one that lost
+ * rewind coverage entirely, while the fallback shim above at least had the
+ * parent handle in reach.
+ *
+ * Recording to the parent as well keeps one authority for undo (the session the
+ * user actually rewinds) without taking anything away from the subagent's own
+ * transcript, which still receives every other event including the conversation
+ * that produced the edit.
+ */
+export declare function withParentFileSnapshots(subagentSession: SessionWriter, parentSession: SessionWriter): SessionWriter;
 //# sourceMappingURL=host-session-writer.d.ts.map

package/dist/fleet/host.d.ts

@@ -211,6 +211,16 @@ export declare class MultiAgentHost {
      * Returns null when auto-optimization is switched off.
      */
     private getLearningOptimizer;
+    /**
+     * Break a dispatch tie with a model when the keyword heuristic is ambiguous.
+     *
+     * Routes through the `dispatcher` model-matrix slot when one is configured —
+     * picking a role is a short classification, so it belongs on a cheap fast
+     * model rather than the leader's — and the session default otherwise.
+     * Returning `null` on any failure leaves the dispatcher on its heuristic
+     * result, so routing degrades rather than breaking a spawn.
+     */
+    private classifyDispatch;
     /**
      * Resolve a model for the distillation pass. Uses the `memory-curator` slot
      * of the model matrix when one is configured — curating learned knowledge is

package/dist/{hq-CD77GVSS.js → hq-5G6D5YIU.js}

@@ -47,7 +47,7 @@ var hqCmd = async (args, deps) => {
   return 1;
 };
 async function startServer(deps) {
-  const { startHqServer } = await import("./hq-server-DME6EWIO.js");
+  const { startHqServer } = await import("./hq-server-IVZLVCFV.js");
   const dataDir = resolveDataDir(deps);
   const flags = deps.flags ?? {};
   const host = typeof flags["host"] === "string" ? flags["host"] : HQ_CLI_DEFAULT_HOST;
@@ -612,4 +612,4 @@ export {
   hqCmd,
   resolveAuditActor
 };
-//# sourceMappingURL=hq-CD77GVSS.js.map
+//# sourceMappingURL=hq-5G6D5YIU.js.map

package/dist/{hq-server-DME6EWIO.js → hq-server-IVZLVCFV.js}

@@ -15,7 +15,7 @@ import {
   readLocalSubagentTranscript,
   sanitizeApiError,
   startHqServer
-} from "./chunk-LUAFQIXT.js";
+} from "./chunk-RHLQT3EV.js";
 import "./chunk-KE7E7DPX.js";
 import "./chunk-Q5GTM25S.js";
 import "./chunk-7OCVIDC7.js";
@@ -37,4 +37,4 @@ export {
   sanitizeApiError,
   startHqServer
 };
-//# sourceMappingURL=hq-server-DME6EWIO.js.map
+//# sourceMappingURL=hq-server-IVZLVCFV.js.map