@wrongstack/cli 1.1.2 → 1.1.5

package/dist/hq-server/sweeps.d.ts

@@ -0,0 +1,28 @@
+import type { createHqPersistence, HqCommandAuditLog, HqEventEnvelope } from '@wrongstack/core/hq';
+import type { WebSocket } from '../ws-runtime.js';
+import type { LoginAttemptStore } from './login-attempt-store.js';
+import type { ConnectedClient, HqSessionEntry } from './types.js';
+export declare const HQ_SESSION_CLEANUP_INTERVAL_MS = 60000;
+/**
+ * Expire browser sessions (absolute max age, idle timeout, abandoned 2FA) and
+ * forget login-attempt counters older than 15 minutes.
+ */
+export declare function sweepHqBrowserSessions(sessions: Map<string, HqSessionEntry>, loginAttempts: LoginAttemptStore, socketCredentials: {
+    closeSessionSockets(sessionId: string, reason: string): void;
+}): void;
+export interface StaleHqClientSweep {
+    clients: Map<WebSocket, ConnectedClient>;
+    browsers: Set<WebSocket>;
+    auditLog: HqCommandAuditLog;
+    eventLog: HqEventEnvelope[];
+    persistence: ReturnType<typeof createHqPersistence>;
+    clientTtlMs: number;
+    sessionSnapshotTtlMs: number;
+}
+/**
+ * Drop clients that stopped heartbeating, expire their stale session
+ * snapshots (and the fleets bound to them), and reap session-summary clients
+ * that have held no session past the TTL. Returns whether anything changed.
+ */
+export declare function sweepStaleHqClients({ clients, browsers, auditLog, eventLog, persistence, clientTtlMs, sessionSnapshotTtlMs, }: StaleHqClientSweep): boolean;
+//# sourceMappingURL=sweeps.d.ts.map

package/dist/{hq-server-BI23EPM7.js → hq-server-YK7FBLL6.js}

@@ -10,9 +10,9 @@ import {
   readLocalSubagentTranscript,
   sanitizeApiError,
   startHqServer
-} from "./chunk-AWRZWPJ3.js";
+} from "./chunk-JFYQGMMM.js";
 import "./chunk-QVITQ425.js";
-import "./chunk-3EXRPTAU.js";
+import "./chunk-5TQ65PXQ.js";
 import "./chunk-OGVSKS4Q.js";
 import "./chunk-OZCYZYN2.js";
 import "./chunk-W23PY4IJ.js";
@@ -29,4 +29,4 @@ export {
   sanitizeApiError,
   startHqServer
 };
-//# sourceMappingURL=hq-server-BI23EPM7.js.map
+//# sourceMappingURL=hq-server-YK7FBLL6.js.map

package/dist/index.js

@@ -5,7 +5,10 @@ import {
 } from "./chunk-CVVQ5NCN.js";
 import {
   parseArgs
-} from "./chunk-75OLD563.js";
+} from "./chunk-M7PSENGF.js";
+import {
+  closeAcpLeaderSessions
+} from "./chunk-LUEO5HLZ.js";
 import {
   CLI_VERSION
 } from "./chunk-HKMOIIPQ.js";
@@ -122,7 +125,7 @@ async function main(argv) {
     applyAsciiMode(earlyFlags);
   }
   if (earlyFlags["help"] === true || earlyFlags["version"] === true) {
-    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-CPCT5MWB.js");
+    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-AGHURHMQ.js");
     const earlyExit = await handleHelpVersionShortCircuit(argv);
     if (earlyExit !== null) return earlyExit;
   }
@@ -131,7 +134,7 @@ async function main(argv) {
     shouldCaptureTuiStartup(parsed.flags, parsed.positional)
   );
   try {
-    const { initializeCli } = await import("./cli-context-YIT4FEDM.js");
+    const { initializeCli } = await import("./cli-context-CQYGIWOU.js");
     const cliCtx = await initializeCli(argv, {
       onNonTuiLaunch: () => startupOutput.stop()
     });
@@ -141,7 +144,7 @@ async function main(argv) {
     } else {
       startupOutput.stop();
     }
-    const { runInteractive } = await import("./cli-main-JIADJ5OL.js");
+    const { runInteractive } = await import("./cli-main-VRUJNUBX.js");
     return await runInteractive(cliCtx);
   } finally {
     startupOutput.stop();
@@ -252,7 +255,7 @@ function runCliProcess(mainFn) {
   mainFn(process.argv.slice(2)).then(
     (c) => {
       process.exitCode = c;
-      scheduleForcedExit(c);
+      void closeAcpLeaderSessions().finally(() => scheduleForcedExit(c));
     },
     (err) => {
       runFatalSalvageSync();

package/dist/mcp-22CFBX4H.js

@@ -0,0 +1,236 @@
+import {
+  serveMcpStdio
+} from "./chunk-QLYPIJ7X.js";
+import "./chunk-LYWOV4OX.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-SPSHEZ46.js";
+import {
+  restoreFlags
+} from "./chunk-QC6CLAK7.js";
+import "./chunk-W23PY4IJ.js";
+
+// src/subcommands/handlers/mcp.ts
+import { allServers, resolveMcpServerConfig } from "@wrongstack/core/infrastructure";
+import {
+  expectDefined,
+  jsonObjectFileExists,
+  readJsonObjectFile,
+  removeJsonPath,
+  setJsonPath,
+  updateJsonObjectFile
+} from "@wrongstack/core/utils";
+
+// src/mcp-serve-project.ts
+var PROJECT_MCP_SERVERS = [
+  "mailbox",
+  "kanban",
+  "codebase-index",
+  "requirement-intake",
+  "sage"
+];
+function isProjectMcpServer(value) {
+  return PROJECT_MCP_SERVERS.includes(value);
+}
+var SERVER_FLAGS = [
+  "project-root",
+  "actor",
+  "session-id",
+  "name",
+  "role",
+  "writable",
+  "admin",
+  "destructive",
+  "http",
+  "stdio",
+  "port",
+  "host",
+  "token",
+  "index-dir",
+  "origin",
+  "watch"
+];
+var SWITCHES = /* @__PURE__ */ new Set([
+  "--writable",
+  "--admin",
+  "--destructive",
+  "--http",
+  "--stdio",
+  "--watch"
+]);
+function normalizeSwitches(args) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const eq = arg.indexOf("=");
+    const flag = eq === -1 ? arg : arg.slice(0, eq);
+    if (!SWITCHES.has(flag)) {
+      out.push(arg);
+      continue;
+    }
+    const value = eq === -1 ? void 0 : arg.slice(eq + 1);
+    if (value === "false") continue;
+    out.push(flag);
+    if (eq === -1 && args[i + 1] === "true") i++;
+  }
+  return out;
+}
+function optionValue(args, name) {
+  const flag = `--${name}`;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === flag) {
+      const next = args[i + 1];
+      return next !== void 0 && !next.startsWith("--") ? next : void 0;
+    }
+    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+  }
+  return void 0;
+}
+async function serveProjectMcp(server, rawArgs, deps) {
+  const args = normalizeSwitches(restoreFlags(rawArgs, deps, SERVER_FLAGS));
+  if (server === "sage") {
+    const { serveAttachedSageMcpStdio } = await import("@wrongstack/sage-mcp");
+    await serveAttachedSageMcpStdio({
+      // A client may start this server from any directory; an explicit root wins.
+      projectRoot: optionValue(args, "project-root") ?? deps.projectRoot,
+      directory: deps.config.Sage?.storage?.directory,
+      origin: optionValue(args, "origin")?.trim() || "mcp-client"
+    });
+    return 0;
+  }
+  const argv = optionValue(args, "project-root") === void 0 ? [...args, "--project-root", deps.projectRoot] : args;
+  if (server === "mailbox") {
+    const { runMailboxMcpServer } = await import("@wrongstack/mailbox-mcp");
+    return runMailboxMcpServer(argv);
+  }
+  if (server === "kanban") {
+    const { runKanbanMcpServer } = await import("@wrongstack/kanban-mcp");
+    return runKanbanMcpServer(argv);
+  }
+  if (server === "requirement-intake") {
+    const { runRequirementIntakeMcpServer } = await import("@wrongstack/requirement-intake-mcp");
+    return runRequirementIntakeMcpServer(argv);
+  }
+  const { runCodebaseIndexMcpServer } = await import("@wrongstack/codebase-index-mcp");
+  return runCodebaseIndexMcpServer(argv);
+}
+
+// src/subcommands/handlers/mcp.ts
+var BUILT_IN_MCP = allServers();
+var mcpCmd = async (args, deps) => {
+  args = restoreFlags(args, deps, ["enable", "e", "transport", "url", "command"]);
+  const sub = args[0];
+  if (sub === "serve") {
+    if (isProjectMcpServer(args[1])) return serveProjectMcp(args[1], args.slice(2), deps);
+    return serveMcpStdio(deps, args.slice(1));
+  }
+  if (!sub || sub === "list") {
+    const servers = deps.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      deps.renderer.write("No MCP servers configured.\n");
+      deps.renderer.write("Use `wstack mcp add <name>` or set mcpServers in your config.\n");
+      return 0;
+    }
+    for (const [name, entry] of Object.entries(servers)) {
+      const cfg = resolveMcpServerConfig(name, entry);
+      const status = entry?.enabled === false ? "disabled" : "enabled";
+      const description = cfg?.description ?? entry?.description;
+      const desc = description ? `  # ${description}` : "";
+      const transport = cfg?.transport ?? "invalid (no transport)";
+      deps.renderer.write(`  ${name.padEnd(20)} ${transport.padEnd(16)} ${status}${desc}
+`);
+    }
+    return 0;
+  }
+  if (sub === "add") {
+    return addMcpServer(args, deps);
+  }
+  if (sub === "remove") {
+    const name = args[1];
+    if (!name) {
+      deps.renderer.writeError("Usage: wstack mcp remove <name>\n");
+      return 1;
+    }
+    return removeMcpServer(name, deps);
+  }
+  if (sub === "restart") {
+    deps.renderer.writeWarning(
+      "mcp restart is only available in REPL mode. Use /mcp restart instead."
+    );
+    return 0;
+  }
+  deps.renderer.writeError(`Unknown mcp subcommand: ${sub}`);
+  return 1;
+};
+async function addMcpServer(args, deps) {
+  const configPath = activeProfileConfigPath(deps.paths, deps.config);
+  const name = args[1];
+  const enable = args.includes("--enable") || args.includes("-e");
+  if (!name) {
+    deps.renderer.writeError("Usage: wstack mcp add <name>\n");
+    deps.renderer.write("Available servers:\n");
+    for (const [sname, scfg] of Object.entries(deps.config.mcpServers ?? {}))
+      deps.renderer.write(`  ${sname.padEnd(20)} ${scfg.description ?? scfg.transport}
+`);
+    if (Object.keys(deps.config.mcpServers ?? {}).length === 0)
+      for (const k of Object.keys(BUILT_IN_MCP)) {
+        const s = expectDefined(BUILT_IN_MCP[k]);
+        deps.renderer.write(`  ${k.padEnd(20)} ${s.description}
+`);
+      }
+    deps.renderer.write("\nRun `wstack mcp add <name> --enable` to enable immediately.\n");
+    return 1;
+  }
+  const factory = Object.hasOwn(BUILT_IN_MCP, name) ? BUILT_IN_MCP[name] : void 0;
+  if (!factory) {
+    deps.renderer.writeError(
+      `Unknown server "${name}". Run \`wstack mcp add\` without args to see available servers.
+`
+    );
+    return 1;
+  }
+  const serverCfg = { ...factory };
+  serverCfg.enabled = enable;
+  const existing = await readJsonObjectFile(configPath);
+  const mcpServers = isRecord(existing.mcpServers) ? existing.mcpServers : {};
+  if (Object.hasOwn(mcpServers, name))
+    deps.renderer.writeWarning(`Server "${name}" already in config. Updating.
+`);
+  await updateJsonObjectFile(configPath, (config) => {
+    setJsonPath(config, ["mcpServers", name], serverCfg);
+  });
+  const verb = enable ? "Enabled" : "Added (disabled \u2014 set enabled:true to activate)";
+  deps.renderer.writeInfo(
+    `${verb} "${name}" (${serverCfg.transport}). Config written to ${configPath}.
+`
+  );
+  return 0;
+}
+async function removeMcpServer(name, deps) {
+  const configPath = activeProfileConfigPath(deps.paths, deps.config);
+  if (!await jsonObjectFileExists(configPath)) {
+    deps.renderer.writeError("No config file found.\n");
+    return 1;
+  }
+  const existing = await readJsonObjectFile(configPath);
+  const mcpServers = isRecord(existing.mcpServers) ? existing.mcpServers : {};
+  if (!Object.hasOwn(mcpServers, name)) {
+    deps.renderer.writeError(`Server "${name}" not in config.
+`);
+    return 1;
+  }
+  await updateJsonObjectFile(configPath, (config) => {
+    removeJsonPath(config, ["mcpServers", name]);
+  });
+  deps.renderer.writeInfo(`Removed "${name}" from config.
+`);
+  return 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  mcpCmd
+};
+//# sourceMappingURL=mcp-22CFBX4H.js.map

package/dist/mcp-serve-project.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `wstack mcp serve <mailbox|kanban|codebase-index|requirement-intake|sage>` — run one of
+ * WrongStack's project MCP servers from inside `wstack` itself.
+ *
+ * Mailbox, Kanban, Codebase Index and Requirements Intake also ship as their own npm bins
+ * (`wstack-mailbox-mcp`, …), but the standalone binary carries none of them,
+ * so this is the launch path that works in every install. Each server is bound
+ * to one project: `--project-root` defaults to the project this command runs
+ * in, and every server only attaches to that project's running owner.
+ *
+ * stdout is the JSON-RPC channel; everything else goes to stderr.
+ */
+import type { SubcommandDeps } from './subcommands/contracts.js';
+export declare const PROJECT_MCP_SERVERS: readonly ['mailbox', 'kanban', 'codebase-index', 'requirement-intake', 'sage'];
+export type ProjectMcpServer = (typeof PROJECT_MCP_SERVERS)[number];
+export declare function isProjectMcpServer(value: string | undefined): value is ProjectMcpServer;
+export declare function serveProjectMcp(server: ProjectMcpServer, rawArgs: string[], deps: SubcommandDeps): Promise<number>;
+//# sourceMappingURL=mcp-serve-project.d.ts.map

package/dist/mcp-serve.d.ts

@@ -1,39 +1,5 @@
-import { Context } from '@wrongstack/core/agent';
-import { ToolRegistry } from '@wrongstack/core/registry';
-import { AutoApprovePermissionPolicy } from '@wrongstack/core/security';
-import type { PermissionPolicy, Tool } from '@wrongstack/core/types';
 import { type MCPServerPrompt, type MCPServerResource } from '@wrongstack/mcp';
 import type { SubcommandDeps } from './subcommands/contracts.js';
-/**
- * `--yolo` for `mcp serve`: widen the CAPABILITY allowlist, keep every guard.
- *
- * This replaced an `AllowAllPermissionPolicy extends AutoApprovePermissionPolicy`
- * whose `evaluate()` returned `{ permission: 'auto' }` unconditionally. That
- * override skipped the whole base implementation — the sensitive-read denial,
- * the leader deny rules, the destructive-command classifier, the agent-state
- * write guard, and `LOCKED_DESTRUCTIVE_KINDS`. It was the only place in the
- * codebase where `agent-state` and `credential-bind` could be un-gated, so a
- * third-party MCP client could have written `hooks` into config.json (boot-time
- * RCE) or `auto: true` into trust.json.
- *
- * It did not actually get there — but only by accident, and the accident is the
- * reason this is a rewrite rather than a patch. The override returned
- * `source: 'default'` where the base class returns `source: 'yolo'`, so
- * `ToolExecutor.capabilityDowngraded` re-armed and forced `confirm`; `mcp serve`
- * has no confirmAwaiter, so the call hard-errored. Changing that one string
- * literal to `'yolo'` — which reads as a trivial consistency cleanup — would
- * have made the bypass live. Safety must not rest on a string nobody knows is
- * load-bearing.
- *
- * Granting every capability is what `--yolo` actually means, and it is what
- * lets `ToolExecutor` trust an `auto` instead of downgrading it (see the
- * `dangerousNotAllowed` reasoning in `auto-approve-policy.ts`). The destructive
- * classifier is deliberately NOT relaxed: `yoloConfirmKinds` is left at its
- * default, which gates every destructive kind. Destructive calls therefore
- * still require a confirmation this surface cannot answer, exactly as before —
- * this change removes a latent bypass without widening anything.
- */
-export declare function yoloServePolicy(): AutoApprovePermissionPolicy;
 /**
  * Resolve the `--tools` whitelist for `mcp serve`.
  *
@@ -60,35 +26,6 @@ interface SelectedMcpServeContent {
 }
 /** Load only files explicitly named by trusted CLI flags; nothing is auto-discovered. */
 export declare function loadSelectedMcpServeContent(flags: Record<string, string | boolean>, cwd: string): Promise<SelectedMcpServeContent>;
-/**
- * Whether the file tools are confined to the project root for `mcp serve`.
- *
- * `mcp serve` is the one surface where the file tools are driven by a REMOTE
- * caller, so an unset config must inherit containment rather than invert it —
- * an unset value here previously became `false`, which short-circuited
- * `ensureInsideRoot` and let `tools/call read` return `~/.ssh/id_rsa`.
- *
- * This lives in one exported function rather than as a literal repeated at each
- * call site so the invariant is testable and a third call site cannot quietly
- * reintroduce the wrong default. Only a trusted user config can opt out:
- * `tools.restrictToProjectRoot` is on the in-project denylist, so a
- * checked-out repository cannot reach it.
- */
-export declare function resolveServeFsRestriction(config: {
-    tools?: {
-        restrictToProjectRoot?: boolean | undefined;
-    } | undefined;
-}): boolean;
-/** Minimal run context — tools read cwd/projectRoot/signal; provider/session are stubs. */
-export declare function makeServeContext(cwd: string, projectRoot: string, signal: AbortSignal, restrictFsToRoot?: boolean): Context;
-/**
- * Compute the set of tools an MCP-serve session exposes: a tool is included
- * only if it passes the whitelist (when set) AND the permission policy returns
- * `auto`. With `AutoApprovePermissionPolicy` this withholds shell/write/edit and
- * dangerous-capability tools; with the `--yolo` policy everything passes.
- * Exported for testing — the live path calls it inside `serveMcpStdio`.
- */
-export declare function selectExposedTools(registry: ToolRegistry, ctx: Context, policy: PermissionPolicy, whitelist: Set<string> | null): Promise<Tool[]>;
 export declare function serveMcpStdio(deps: SubcommandDeps, positional?: readonly string[]): Promise<number>;
 export {};
 //# sourceMappingURL=mcp-serve.d.ts.map

package/dist/{modeldiag-HDIKG37X.js → modeldiag-5PBB777J.js}

@@ -1,9 +1,6 @@
 import {
   applyProviderOAuthRefresh
 } from "./chunk-TXWL3BZ5.js";
-import {
-  discoverAndMergeProviders
-} from "./chunk-RBZVDWTL.js";
 import {
   checkMark,
   costLabel,
@@ -18,6 +15,9 @@ import {
   scoreBar,
   speedLabel
 } from "./chunk-FPUB5WWP.js";
+import {
+  discoverAndMergeProviders
+} from "./chunk-RBZVDWTL.js";
 import {
   mutateConfigProviders
 } from "./chunk-ZCXZGYO5.js";
@@ -844,4 +844,4 @@ var modeldiagCmd = async (args, deps) => {
 export {
   modeldiagCmd
 };
-//# sourceMappingURL=modeldiag-HDIKG37X.js.map
+//# sourceMappingURL=modeldiag-5PBB777J.js.map

package/dist/{per-subcommand-help-D6J4ZXW2.js → per-subcommand-help-MQGERD4E.js}

@@ -7,7 +7,7 @@ import {
   renderFocusedHelpToString,
   renderGenericHelp,
   subcommandsWithFocusedHelp
-} from "./chunk-3R3OADC5.js";
+} from "./chunk-P7MEEUGT.js";
 import "./chunk-ZXX3MJRL.js";
 import "./chunk-W23PY4IJ.js";
 export {
@@ -20,4 +20,4 @@ export {
   renderGenericHelp,
   subcommandsWithFocusedHelp
 };
-//# sourceMappingURL=per-subcommand-help-D6J4ZXW2.js.map
+//# sourceMappingURL=per-subcommand-help-MQGERD4E.js.map

package/dist/plugin-llm-command.d.ts

@@ -0,0 +1,9 @@
+import type { PluginManagementDeps, PluginManagementResult } from './plugin-management-types.js';
+/**
+ * `wstack plugin llm …` — per-plugin LLM routing. The chat leader's
+ * provider/model stays the DEFAULT; this stores an override under
+ * `config.extensions[<plugin>].llm = { provider?, model? }` which
+ * `api.llm` resolves ahead of the session default on every call.
+ */
+export declare function runPluginLlmCommand(args: string[], deps: PluginManagementDeps): Promise<PluginManagementResult>;
+//# sourceMappingURL=plugin-llm-command.d.ts.map

package/dist/{plugin-usage-TYF5HY4K.js → plugin-usage-UWKYMNQU.js}

@@ -1,10 +1,10 @@
 import {
   runPluginManagementCommand
-} from "./chunk-VAQXOZKP.js";
+} from "./chunk-AJM4EFCM.js";
 import {
   activeProfileConfigPath
 } from "./chunk-SPSHEZ46.js";
-import "./chunk-BIGSVBPI.js";
+import "./chunk-KNYIEQAY.js";
 import {
   restoreFlags
 } from "./chunk-QC6CLAK7.js";
@@ -42,4 +42,4 @@ export {
   pluginCmd,
   usageCmd
 };
-//# sourceMappingURL=plugin-usage-TYF5HY4K.js.map
+//# sourceMappingURL=plugin-usage-UWKYMNQU.js.map

package/dist/{plugins-XGAXDLPT.js → plugins-VP7JQH47.js}

@@ -7,10 +7,10 @@ import {
   pluginNameFromSpec,
   setupPlugins,
   warnIfDeprecatedPluginName
-} from "./chunk-TZPKOS5G.js";
+} from "./chunk-2XQ6SRKG.js";
 import "./chunk-P24ZPPYH.js";
-import "./chunk-VAQXOZKP.js";
-import "./chunk-BIGSVBPI.js";
+import "./chunk-AJM4EFCM.js";
+import "./chunk-KNYIEQAY.js";
 import "./chunk-W23PY4IJ.js";
 export {
   BUILTIN_PLUGIN_FACTORIES,
@@ -22,4 +22,4 @@ export {
   setupPlugins,
   warnIfDeprecatedPluginName
 };
-//# sourceMappingURL=plugins-XGAXDLPT.js.map
+//# sourceMappingURL=plugins-VP7JQH47.js.map

package/dist/{sdd-runtime-6MFUXWJK.js → sdd-runtime-HIJ4Z5TF.js}

@@ -14,7 +14,7 @@ import {
   trySaveImplementationPlan,
   trySaveSpecFromAIOutput,
   trySaveTasksFromAIOutput
-} from "./chunk-WDXNBYGD.js";
+} from "./chunk-TDP7CZGE.js";
 import "./chunk-W23PY4IJ.js";
 export {
   advanceToNextTask,
@@ -32,4 +32,4 @@ export {
   trySaveSpecFromAIOutput,
   trySaveTasksFromAIOutput
 };
-//# sourceMappingURL=sdd-runtime-6MFUXWJK.js.map
+//# sourceMappingURL=sdd-runtime-HIJ4Z5TF.js.map

package/dist/services/sdd/state.d.ts

@@ -24,6 +24,8 @@ export declare class SDDState {
     getSessionElapsed(): number;
     getPhaseElapsed(): number;
     getVersioning(): SpecVersioning;
+    /** Drain fire-and-forget tracker writes before deleting or replacing the store. */
+    flushTaskWrites(): Promise<void>;
     clearTaskState(): void;
     getContext(): string | null;
     getPhase(): AISpecPhase | null;

package/dist/session-event-wiring-types.d.ts

@@ -0,0 +1,62 @@
+import type { ChronicleEventJournalHandle, ChronicleEventSink } from '@wrongstack/core/chronicle';
+import { createChronicleEventJournal } from '@wrongstack/core/chronicle';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { SessionEventBridge } from '@wrongstack/core/storage';
+export interface ErrorEntry {
+    ts: string;
+    phase: string;
+    code: string;
+    message: string;
+}
+export interface WireSessionEventsDeps {
+    evOn: (event: string, handler: (...args: any[]) => void) => void;
+    /** Concrete bus is required for Chronicle lifecycle subscriptions. */
+    events?: EventBus | undefined;
+    config: Record<string, unknown>;
+    context: Record<string, unknown>;
+    session: {
+        id: string;
+    };
+    sessionRef: {
+        current?: {
+            id: string;
+        } | undefined;
+    };
+    wpaths: {
+        globalRoot: string;
+        projectSlug: string;
+        projectHash?: string | undefined;
+        projectDir?: string | undefined;
+    };
+    projectRoot: string;
+    renderer?: {
+        writeInfo?: (msg: string) => void;
+    };
+    tuiOwnsScreen?: boolean;
+}
+export interface WireSessionEventsResult {
+    errorRing: ErrorEntry[];
+    sessionBridge: SessionEventBridge;
+    appendSessionEvent: (sessionId: string | undefined, event: Parameters<SessionEventBridge['append']>[0]) => void;
+    chronicleJournal?: ChronicleEventSink | undefined;
+    disposeChronicle: () => Promise<void>;
+}
+/** `0` disables auto-purge; positive values are floored at 7 days so a
+ *  project-committed config cannot flush recent evidence. */
+export declare function resolveChronicleRetentionDays(config: Record<string, unknown>): number;
+/** Read a positive numeric `chronicle.*` knob, or undefined to keep the default. */
+export declare function chronicleLimit(config: Record<string, unknown>, key: string): number | undefined;
+/**
+ * Open the Chronicle journal, or give up on telemetry for this session.
+ *
+ * `createChronicleEventJournal` fails closed: rather than quietly handing this
+ * process its own hash chain when the daemon build cannot be located, it
+ * raises. Chronicle is observability, though — losing it must never stop a
+ * user from working. So the failure is absorbed here, once, and reported.
+ *
+ * Note what is *not* done: no silent retry into an inline journal. Telemetry is
+ * either recorded by the project's single owner or not recorded at all, and the
+ * operator is told which.
+ */
+export declare function tryCreateChronicleJournal(options: Parameters<typeof createChronicleEventJournal>[0]): ChronicleEventJournalHandle | undefined;
+//# sourceMappingURL=session-event-wiring-types.d.ts.map

package/dist/session-event-wiring.d.ts

@@ -1,57 +1,7 @@
-/**
- * session-event-wiring — EventBus subscriptions for session audit logging,
- * error tracking, and file-author recording. Also owns the
- * SessionEventBridge and appendSessionEvent helper that gates on session
- * identity so stale sessions don't pollute the current log.
- *
- * Extracted from cli-main.ts's monolithic main() to reduce cognitive load
- * and enable focused testing.
- */
-import type { ChronicleEventSink } from '@wrongstack/core/chronicle';
-import type { EventBus } from '@wrongstack/core/kernel';
-import type { SessionEventBridge } from '@wrongstack/core/storage';
-export interface ErrorEntry {
-    ts: string;
-    phase: string;
-    code: string;
-    message: string;
-}
-interface WireSessionEventsDeps {
-    evOn: (event: string, handler: (...args: any[]) => void) => void;
-    /** Concrete bus is required for Chronicle lifecycle subscriptions. */
-    events?: EventBus | undefined;
-    config: Record<string, unknown>;
-    context: Record<string, unknown>;
-    session: {
-        id: string;
-    };
-    sessionRef: {
-        current?: {
-            id: string;
-        } | undefined;
-    };
-    wpaths: {
-        globalRoot: string;
-        projectSlug: string;
-        projectHash?: string | undefined;
-        projectDir?: string | undefined;
-    };
-    projectRoot: string;
-    renderer?: {
-        writeInfo?: (msg: string) => void;
-    };
-    tuiOwnsScreen?: boolean;
-}
-interface WireSessionEventsResult {
-    errorRing: ErrorEntry[];
-    sessionBridge: SessionEventBridge;
-    appendSessionEvent: (sessionId: string | undefined, event: Parameters<SessionEventBridge['append']>[0]) => void;
-    chronicleJournal?: ChronicleEventSink | undefined;
-    disposeChronicle: () => Promise<void>;
-}
+import type { WireSessionEventsDeps, WireSessionEventsResult } from './session-event-wiring-types.js';
+export type { ErrorEntry } from './session-event-wiring-types.js';
 /** Wire SessionEventBridge, appendSessionEvent, error ring, and tool-lifecycle
  *  session audit events. Returns the sessionBridge (for compaction / audit-level
  *  changes) and the error ring array (for /diag). */
 export declare function wireSessionEvents(deps: WireSessionEventsDeps): WireSessionEventsResult;
-export {};
 //# sourceMappingURL=session-event-wiring.d.ts.map