@wrongstack/cli 0.284.0 → 0.285.0

package/dist/boot/tui-project-picker-callback.d.ts

@@ -0,0 +1,30 @@
+import { type Director } from '@wrongstack/core';
+import type { TerminalRenderer } from '../renderer.js';
+import type { TuiRuntimeState } from './tui-runtime-state.js';
+import type { ProjectSwitchContext } from './tui-project-switch.js';
+export interface ProjectPickerContext {
+    state: TuiRuntimeState;
+    renderer: TerminalRenderer;
+    director: Director | null | undefined;
+    getEternalEngine: (() => {
+        currentState: string;
+    } | null) | undefined;
+    getParallelEngine: (() => {
+        currentState: string;
+    } | null) | undefined;
+    switchCtx: ProjectSwitchContext;
+    switchProjectInPlace: (targetRoot: string, displayName: string) => Promise<string | null>;
+}
+/**
+ * Load project picker items from the global manifest.
+ * Called each time the project picker panel opens (F1).
+ */
+export declare function getProjectPickerItems(ctx: ProjectPickerContext): Promise<import("../project-picker.js").PickerItem[]>;
+/**
+ * Called when the user selects a project in the picker.
+ * Re-roots the live TUI process in place: new Context root, fresh
+ * per-project session writer, rebuilt system prompt, and no spawned
+ * replacement process.
+ */
+export declare function onProjectSelect(ctx: ProjectPickerContext, slug: string, kind: 'project' | 'action'): Promise<void>;
+//# sourceMappingURL=tui-project-picker-callback.d.ts.map

package/dist/boot/tui-project-picker-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-project-picker-callback.d.ts","sourceRoot":"","sources":["../../src/boot/tui-project-picker-callback.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,gBAAgB,EAAE,CAAC,MAAM;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACtE,iBAAiB,EAAE,CAAC,MAAM;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACvE,SAAS,EAAE,oBAAoB,CAAC;IAChC,oBAAoB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC3F;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,oBAAoB,wDAMpE;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,oBAAoB,EACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,GAAG,QAAQ,GACzB,OAAO,CAAC,IAAI,CAAC,CAqDf"}

package/dist/boot/tui-project-spawn.d.ts

@@ -0,0 +1,19 @@
+export declare const PROJECT_SWITCH_EXIT_CODE = 42;
+export interface PendingProjectSwitch {
+    root: string;
+    name: string;
+    resumeSessionId?: string | undefined;
+}
+export interface ProjectSwitchSpawnOptions {
+    /** The TUI's exit code. */
+    code: number;
+    /** The pending switch info set by onProjectSelect / onSwitchToSession. */
+    pendingProjectSwitch: PendingProjectSwitch | null;
+}
+/**
+ * If the TUI exited with PROJECT_SWITCH_EXIT_CODE and a pending switch
+ * is set, spawn a new wstack in the target project and return 0.
+ * Otherwise return null (no spawn happened — caller continues cleanup).
+ */
+export declare function handleProjectSwitchSpawn(opts: ProjectSwitchSpawnOptions): Promise<number | null>;
+//# sourceMappingURL=tui-project-spawn.d.ts.map

package/dist/boot/tui-project-spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-project-spawn.d.ts","sourceRoot":"","sources":["../../src/boot/tui-project-spawn.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACxC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,oBAAoB,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACnD;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyDxB"}

package/dist/boot/tui-project-switch.d.ts

@@ -0,0 +1,26 @@
+import { type Agent, type Config, type Context, type EventBus, type MemoryStore, type ModeStore } from '@wrongstack/core';
+import type { TuiRuntimeState } from './tui-runtime-state.js';
+import type { SkillLoader } from '@wrongstack/core';
+export interface ProjectSwitchContext {
+    state: TuiRuntimeState;
+    context: Context;
+    events: EventBus;
+    agent: Agent;
+    config: Config;
+    tokenCounter: import('@wrongstack/core').TokenCounter;
+    modeId: string | undefined;
+    modeStore: ModeStore | undefined;
+    memoryStore: MemoryStore | undefined;
+    skillLoader: SkillLoader | undefined;
+    /** attachTodosCheckpoint — from execute() scope. */
+    attachTodosCheckpoint: (state: import('@wrongstack/core').ConversationState, todosPath: string, sessionId: string, events: EventBus, traceId: string | undefined) => () => void;
+}
+/**
+ * Re-root the live TUI process to a new project directory.
+ *
+ * Returns `null` on success, or an error message string on failure.
+ * Mutates `state.*` (projectRoot, wpaths, activeSessionStore,
+ * activeRecoveryLock, detachActiveTodosCheckpoint).
+ */
+export declare function switchProjectInPlace(ctx: ProjectSwitchContext, targetRoot: string, displayName: string): Promise<string | null>;
+//# sourceMappingURL=tui-project-switch.d.ts.map

package/dist/boot/tui-project-switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-project-switch.d.ts","sourceRoot":"","sources":["../../src/boot/tui-project-switch.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,KAAK,EACV,KAAK,MAAM,EACX,KAAK,OAAO,EACZ,KAAK,QAAQ,EAGb,KAAK,WAAW,EAChB,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,kBAAkB,EAAE,YAAY,CAAC;IACtD,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,oDAAoD;IACpD,qBAAqB,EAAE,CACrB,KAAK,EAAE,OAAO,kBAAkB,EAAE,iBAAiB,EACnD,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,MAAM,GAAG,SAAS,KACxB,MAAM,IAAI,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,oBAAoB,EACzB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsHxB"}

package/dist/boot/tui-runtime-state.d.ts

@@ -0,0 +1,83 @@
+/**
+ * TuiRuntimeState — shared mutable context for TUI branch sub-modules.
+ *
+ * Phase B prerequisite. The TUI branch of `execute()` (lines 603-1905)
+ * contains ~1,200 lines of closures that read and write mutable local
+ * variables declared at the top of `execute()`:
+ *
+ *   `projectRoot`, `wpaths`, `activeSessionStore`, `activeRecoveryLock`,
+ *   `detachActiveTodosCheckpoint` (in the outer scope)
+ *   `pendingProjectSwitch`, `autonomousCoordinator`, `coordinatorRun`,
+ *   `coordinatorEvents` (in the TUI branch scope)
+ *
+ * Extracting sub-modules (coordinator setup, project switch, session
+ * resume) requires these mutable bindings to be reachable from outside
+ * the `execute()` closure. JavaScript closures can't be partially
+ * extracted — a function defined in another file can't reassign a
+ * `let` in `execute()`.
+ *
+ * The pattern is a shared mutable container: each mutable binding
+ * becomes a property on a single `TuiRuntimeState` object that the
+ * extracted function receives as a parameter. Mutations are written
+ * to `state.field = newValue`; the caller (execute) and the extracted
+ * module both hold the same object reference, so a mutation by one is
+ * visible to the other.
+ *
+ * Usage in execute():
+ *
+ *   const state: TuiRuntimeState = {
+ *     projectRoot,
+ *     wpaths,
+ *     activeSessionStore,
+ *     activeRecoveryLock,
+ *     detachActiveTodosCheckpoint,
+ *     pendingProjectSwitch: null,
+ *     autonomousCoordinator: null,
+ *     coordinatorRun: null,
+ *     coordinatorEvents: new Set(),
+ *   };
+ *
+ *   // ... extracted modules receive `state` and mutate it:
+ *   const coordinator = ensureAutonomousCoordinator(state, deps);
+ *   // coordinator wrote state.autonomousCoordinator — visible here
+ *
+ *   // After the TUI branch, sync locals back:
+ *   projectRoot = state.projectRoot;
+ *   wpaths = state.wpaths;
+ *
+ * Why not individual `{ current: T }` refs (React-style)?
+ *   The outer scope's `finally` block reads these variables (e.g.
+ *   `activeSessionStore`, `wpaths`) for cleanup. A single flat object
+ *   is simpler to sync back than 8 separate refs, and the mutation
+ *   pattern (`.field = x`) is cleaner than `.field.current = x`.
+ */
+import type { AutonomousCoordinator, CoordinatorEvent, RecoveryLock, SessionStore, WstackPaths } from '@wrongstack/core';
+import type { PendingProjectSwitch } from './tui-project-spawn.js';
+/**
+ * The shared mutable runtime state for the TUI dispatch branch.
+ *
+ * Every field is mutable — extracted modules read AND write these
+ * properties. The object is created once in `execute()` and passed
+ * to every Phase B sub-module.
+ */
+export interface TuiRuntimeState {
+    /** Current project root directory. Mutated by switchProjectInPlace. */
+    projectRoot: string;
+    /** Resolved WrongStack paths. Mutated by switchProjectInPlace. */
+    wpaths: WstackPaths;
+    /** Active session store. Mutated by switchProjectInPlace. */
+    activeSessionStore: SessionStore | undefined;
+    /** Active crash-recovery lock. Mutated by switchProjectInPlace and onResumeSession. */
+    activeRecoveryLock: RecoveryLock;
+    /** Todos checkpoint detach function. Mutated by switchProjectInPlace. */
+    detachActiveTodosCheckpoint: (() => void | Promise<void>) | undefined;
+    /** Pending project switch (F1 picker / F10 sessions). Set by onProjectSelect/onSwitchToSession. */
+    pendingProjectSwitch: PendingProjectSwitch | null;
+    /** Lazy AutonomousCoordinator. Set by ensureAutonomousCoordinator. */
+    autonomousCoordinator: AutonomousCoordinator | null;
+    /** In-flight coordinator run promise. Set/cleared by onCoordinatorStart. */
+    coordinatorRun: Promise<void> | null;
+    /** Coordinator event subscribers. Mutated by subscribeCoordinatorEvents. */
+    coordinatorEvents: Set<(event: CoordinatorEvent) => void>;
+}
+//# sourceMappingURL=tui-runtime-state.d.ts.map

package/dist/boot/tui-runtime-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-runtime-state.d.ts","sourceRoot":"","sources":["../../src/boot/tui-runtime-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,OAAO,KAAK,EACV,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAG9B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,MAAM,EAAE,WAAW,CAAC;IACpB,6DAA6D;IAC7D,kBAAkB,EAAE,YAAY,GAAG,SAAS,CAAC;IAC7C,uFAAuF;IACvF,kBAAkB,EAAE,YAAY,CAAC;IACjC,yEAAyE;IACzE,2BAA2B,EAAE,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;IAItE,mGAAmG;IACnG,oBAAoB,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAClD,sEAAsE;IACtE,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpD,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,4EAA4E;IAC5E,iBAAiB,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC,CAAC;CAC3D"}

package/dist/boot/tui-sdd-callback.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TUI SDD callbacks — extracted from the runTui() options literal.
+ *
+ * Phase C step 5. getSDDContext returns the active spec-driven-development
+ * context; onSDDOutput parses assistant output for spec/plan/task artifacts,
+ * auto-saves them, and returns status messages for the TUI to display.
+ *
+ * No closure dependencies — both functions are pure delegates to the
+ * slash-commands/sdd module.
+ */
+/**
+ * Get the active SDD context for the current session.
+ */
+export declare function getSDDContext(): Promise<unknown>;
+/**
+ * Parse assistant output for SDD artifacts (spec, plan, tasks), auto-save
+ * them, and return status messages for the TUI.
+ */
+export declare function onSDDOutput(output: string): Promise<string[]>;
+//# sourceMappingURL=tui-sdd-callback.d.ts.map

package/dist/boot/tui-sdd-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-sdd-callback.d.ts","sourceRoot":"","sources":["../../src/boot/tui-sdd-callback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAGtD;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkCnE"}

package/dist/boot/tui-session-resume.d.ts

@@ -0,0 +1,21 @@
+import type { Agent, TokenCounter } from '@wrongstack/core';
+import type { TuiRuntimeState } from './tui-runtime-state.js';
+export interface SessionResumeContext {
+    state: TuiRuntimeState;
+    agent: Agent;
+    tokenCounter: TokenCounter;
+    switchProviderAndModel: ((providerId: string, modelId: string) => string | null | void | Promise<unknown>) | undefined;
+}
+export interface SessionResumeResult {
+    entries: unknown[];
+    nextId: number;
+    sessionId: string;
+}
+/**
+ * Resume a past session by id.
+ *
+ * Returns the replayed history entries + new session id, or null on
+ * failure. Throws if the session is live in another process.
+ */
+export declare function resumeSession(ctx: SessionResumeContext, sessionId: string): Promise<SessionResumeResult | null>;
+//# sourceMappingURL=tui-session-resume.d.ts.map

package/dist/boot/tui-session-resume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-session-resume.d.ts","sourceRoot":"","sources":["../../src/boot/tui-session-resume.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,YAAY,CAAC;IAC3B,sBAAsB,EAClB,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAClF,SAAS,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,oBAAoB,EACzB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAsKrC"}

package/dist/boot/tui-settings-adapter.d.ts

@@ -0,0 +1,23 @@
+import { type ConfigStore, type WstackPaths } from '@wrongstack/core';
+import type { LiveSettingsInput } from '../execution.js';
+export interface SettingsAdapterContext {
+    configStore: ConfigStore;
+    wpaths: WstackPaths;
+    fleetStreamController: {
+        setEnabled: (enabled: boolean) => void;
+    } | undefined;
+    applyLiveSettings: ((s: LiveSettingsInput) => void) | undefined;
+}
+export interface SettingsAdapter {
+    getSettings: () => Record<string, unknown>;
+    saveSettings: (s: LiveSettingsInput) => Promise<string | null>;
+}
+/**
+ * Build the getSettings/saveSettings pair for the TUI SettingsPicker.
+ *
+ * `getSettings` reads from the live ConfigStore on every call.
+ * `saveSettings` persists to disk (global or project-local config),
+ * syncs the in-memory store, and applies runtime effects immediately.
+ */
+export declare function createSettingsAdapter(ctx: SettingsAdapterContext): SettingsAdapter;
+//# sourceMappingURL=tui-settings-adapter.d.ts.map

package/dist/boot/tui-settings-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-settings-adapter.d.ts","sourceRoot":"","sources":["../../src/boot/tui-settings-adapter.ts"],"names":[],"mappings":"AAcA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,WAAW,EAMjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,qBAAqB,EAAE;QAAE,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;KAAE,GAAG,SAAS,CAAC;IAC9E,iBAAiB,EAAE,CAAC,CAAC,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,YAAY,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAChE;AAYD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,sBAAsB,GAAG,eAAe,CAgalF"}

package/dist/boot-config.d.ts

@@ -0,0 +1,26 @@
+import { type Config, bootConfig as coreBootConfig, type WstackPaths } from '@wrongstack/core';
+import type { DefaultPathResolver } from '@wrongstack/core/infrastructure';
+export interface BootPaths {
+    cwd: string;
+    projectRoot: string;
+    userHome: string;
+    wpaths: WstackPaths;
+    pathResolver: DefaultPathResolver;
+}
+export interface BootConfigResult {
+    paths: BootPaths;
+    config: Config;
+    vault: BootConfigVault;
+}
+/** The concrete vault type returned by the core boot routine. */
+type BootConfigVault = Awaited<ReturnType<typeof coreBootConfig>>['vault'];
+/**
+ * Thin CLI wrapper over the canonical `bootConfig` in `@wrongstack/core`.
+ * Re-shapes the core result into the CLI's historical `{ paths, config, vault }`
+ * return type. All real boot behavior (path resolution, vault, secret
+ * migration, config + sync loading) lives in core so the CLI and the WebUI
+ * server can't drift.
+ */
+export declare function bootConfig(flags: Record<string, string | boolean>): Promise<BootConfigResult>;
+export {};
+//# sourceMappingURL=boot-config.d.ts.map

package/dist/boot-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-config.d.ts","sourceRoot":"","sources":["../src/boot-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EACX,UAAU,IAAI,cAAc,EAC5B,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,YAAY,EAAE,mBAAmB,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,iEAAiE;AACjE,KAAK,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GACtC,OAAO,CAAC,gBAAgB,CAAC,CAc3B"}

package/dist/boot.d.ts

@@ -0,0 +1,30 @@
+import { type Config, DefaultLogger, type ModelsRegistry, type SecretVault, type WstackPaths } from '@wrongstack/core';
+import { ReadlineInputReader } from './input-reader.js';
+import { TerminalRenderer } from './renderer.js';
+import type { UpdateInfo } from './update-check.js';
+export interface BootContext {
+    config: Config;
+    vault: SecretVault;
+    wpaths: WstackPaths;
+    cwd: string;
+    projectRoot: string;
+    userHome: string;
+    flags: Record<string, string | boolean>;
+    positional: string[];
+    modelsRegistry: ModelsRegistry;
+    renderer: TerminalRenderer;
+    reader: ReadlineInputReader;
+    logger: DefaultLogger;
+    /** Set by background update check — if outdated, index.ts shows notification */
+    updateInfo?: UpdateInfo | undefined;
+    /** True when running in --webui/--no-interactive mode but provider/model not configured */
+    needsSetup?: boolean | undefined;
+}
+/**
+ * Boot the CLI: parse args, load config, handle subcommand dispatch
+ * (early exit), run interactive prompts (project check, provider picker,
+ * mode/yolo). Returns a BootContext for the wiring phase, or an exit
+ * code when the run should stop here.
+ */
+export declare function boot(argv: string[]): Promise<BootContext | number>;
+//# sourceMappingURL=boot.d.ts.map

package/dist/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../src/boot.ts"],"names":[],"mappings":"AAiCA,OAAO,EACL,KAAK,MAAM,EAEX,aAAa,EAGb,KAAK,cAAc,EACnB,KAAK,WAAW,EAGhB,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAYxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA0CpD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;IACxC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,aAAa,CAAC;IACtB,gFAAgF;IAChF,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,2FAA2F;IAC3F,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC;AAsBD;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,CAoaxE"}

package/dist/cli-bundled-prompts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolves the bundled `<pkg>/data/prompts/` dataset shipped with the installed
+ * `@wrongstack/core` package. Used by the CLI/WebUI to discover the curated
+ * builtin prompt library without the user pointing at a path manually.
+ *
+ * The directory lives at a sibling of `dist/` (in development: `src/`) so the
+ * resolution walks one level up from the core package's `package.json` and
+ * joins with `data/prompts`. Returns `undefined` if the lookup fails — the
+ * caller treats that as "no bundled prompts this run" and continues.
+ */
+export declare function resolveBundledPromptsDir(): string | undefined;
+//# sourceMappingURL=cli-bundled-prompts.d.ts.map

package/dist/cli-bundled-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-bundled-prompts.d.ts","sourceRoot":"","sources":["../src/cli-bundled-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,SAAS,CAQ7D"}

package/dist/cli-bundled-skills.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resolves the bundled `<pkg>/skills/` directory shipped with the installed
+ * `@wrongstack/core` package. Used by the CLI to discover the curated skill
+ * set without making the user point at a path manually.
+ *
+ * The directory lives at a sibling of `dist/` (in development: `src/`) so
+ * the resolution walks one level up from the core package's `package.json`
+ * and joins with `skills`. Returns `undefined` if the lookup fails for any
+ * reason — the caller should treat that as "no bundled skills this run"
+ * and continue without error.
+ */
+export declare function resolveBundledSkillsDir(): string | undefined;
+//# sourceMappingURL=cli-bundled-skills.d.ts.map

package/dist/cli-bundled-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-bundled-skills.d.ts","sourceRoot":"","sources":["../src/cli-bundled-skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,SAAS,CAQ5D"}

package/dist/cli-context.d.ts

@@ -0,0 +1,30 @@
+/**
+ * cli-context — Boot context initialization for the CLI main entry point.
+ *
+ * Consolidates the first ~150 lines of the monolithic main() function:
+ *   - Pre-boot side effects (NODE_ENV, shell default)
+ *   - Short-circuits (--help, --version, --desktop, --hq)
+ *   - Boot() call + preflight
+ *   - OAuth token persistence
+ *   - Container wiring (EventBus, DI container)
+ *   - Replay/record mode wiring
+ *
+ * Returns a `CliContext` object with all the dependencies the rest of
+ * main() needs, or a numeric exit code when a short-circuit fires.
+ */
+import { wireContainer } from './boot/container-wiring.js';
+import type { EventBus, ConfigStore } from '@wrongstack/core';
+import type { BootContext } from './boot.js';
+/** All boot-phase dependencies the rest of main() needs. */
+export interface CliContext extends BootContext {
+    events: EventBus;
+    container: ReturnType<typeof wireContainer>['container'];
+    configStore: ConfigStore;
+}
+/**
+ * Run all pre-boot and boot-phase setup. Returns a `CliContext` on success,
+ * or a numeric exit code when a short-circuit flag (--help, --desktop, --hq)
+ * fires. When the return is a number the caller must return it immediately.
+ */
+export declare function initializeCli(argv: string[]): Promise<CliContext | number>;
+//# sourceMappingURL=cli-context.d.ts.map

package/dist/cli-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-context.d.ts","sourceRoot":"","sources":["../src/cli-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AASH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAM3D,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAI7C,4DAA4D;AAC5D,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,MAAM,EAAE,QAAQ,CAAC;IACjB,SAAS,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,WAAW,CAAC,CAAC;IACzD,WAAW,EAAE,WAAW,CAAC;CAC1B;AAID;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,GAAG,MAAM,CAAC,CA6FhF"}

package/dist/cli-entry-point.d.ts

@@ -0,0 +1,2 @@
+export declare function runAsMain(mainFn: (argv: string[]) => Promise<number>): void;
+//# sourceMappingURL=cli-entry-point.d.ts.map

package/dist/cli-entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-entry-point.d.ts","sourceRoot":"","sources":["../src/cli-entry-point.ts"],"names":[],"mappings":"AA2BA,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAoB3E"}

package/dist/cli-eternal-flag.d.ts

@@ -0,0 +1,66 @@
+/**
+ * One-shot launch into eternal autonomy via the `--eternal "<mission>"`
+ * CLI flag. Writes the mission as the active goal, forces YOLO on
+ * (consistent with `/autonomy eternal`), instantiates + primes the
+ * `EternalAutonomyEngine`, and flips `autonomyMode='eternal'` so the
+ * REPL's main loop drives the engine instead of reading user input.
+ *
+ * The user can still `/autonomy stop` or Ctrl+C to exit the loop normally.
+ *
+ * Extracted from `cli/index.ts` to make the contract — "given a flag
+ * string and the wired container, launch an eternal loop" — testable
+ * without spinning up the entire CLI. Returns `true` if a launch
+ * happened, `false` if the flag was empty.
+ */
+import type { Agent } from '@wrongstack/core';
+import { type Config, EternalAutonomyEngine, type JournalEntry } from '@wrongstack/core';
+import type { Token } from '@wrongstack/core/kernel';
+import type { TerminalRenderer } from './renderer.js';
+import type { AutonomyMode } from './slash-commands/autonomy.js';
+/**
+ * The container type is structural because `@wrongstack/runtime`'s `Container`
+ * is not part of the public re-export surface, and pulling the full type
+ * in from `core/kernel/container` would create an awkward cross-package
+ * import. The container's structural contract (`.resolve(token)`) is the
+ * only thing this helper actually needs; runtime callers pass a real
+ * `Container` and the cast inside the helper handles the rest.
+ */
+type ContainerLike = {
+    resolve: <T>(token: Token<T>) => T;
+};
+export interface EternalFlagDeps {
+    /** The `--eternal` flag value (already trimmed). Empty string = no-op. */
+    eternalFlag: string;
+    projectRoot: string;
+    agent: Agent;
+    container: ContainerLike;
+    renderer: TerminalRenderer;
+    /**
+     * Broadcast hook for engine iteration events. Typed as `unknown` rather
+     * than `unknown` so callers can pass a JournalEntry-typed function
+     * without contravariance noise (the engine forwards whatever it
+     * produces; the caller chooses the right shape for its listener).
+     */
+    broadcastEternalIteration: (iter: JournalEntry) => void;
+    /** Resolved max context tokens (0 = unknown; engine decides its own cap). */
+    effectiveMaxContext: number;
+    configRef: {
+        current: Config;
+    };
+    autonomyModeRef: {
+        current: AutonomyMode;
+    };
+    /**
+     * Optional sink for the constructed engine. The CLI's `index.ts` does
+     * not currently consume the engine outside the helper, so most callers
+     * can leave this off. The flag exists so a test (or a future feature
+     * that needs to keep the engine alive past the helper's return) can
+     * observe the engine the helper produced without re-deriving it.
+     */
+    eternalEngineRef?: {
+        current: EternalAutonomyEngine | undefined;
+    };
+}
+export declare function launchEternalFromFlag(deps: EternalFlagDeps): Promise<boolean>;
+export {};
+//# sourceMappingURL=cli-eternal-flag.d.ts.map

package/dist/cli-eternal-flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-eternal-flag.d.ts","sourceRoot":"","sources":["../src/cli-eternal-flag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAEL,KAAK,MAAM,EAEX,qBAAqB,EACrB,KAAK,YAAY,EAElB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGjE;;;;;;;GAOG;AACH,KAAK,aAAa,GAAG;IAAE,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CAAE,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;;;;OAKG;IACH,yBAAyB,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACxD,6EAA6E;IAC7E,mBAAmB,EAAE,MAAM,CAAC;IAG5B,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,eAAe,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,CAAC;IAC3C;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE;QACjB,OAAO,EAAE,qBAAqB,GAAG,SAAS,CAAC;KAC5C,CAAC;CACH;AAED,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAkDnF"}

package/dist/cli-main.d.ts

@@ -0,0 +1,13 @@
+import { CLI_VERSION } from './version.js';
+export { CLI_VERSION };
+export declare function main(argv: string[]): Promise<number>;
+/**
+ * Prompt the user about an abandoned session. The lockfile lifecycle
+ * guarantees we only get here when the previous instance died without
+ * writing `session_end` AND there's real work on disk (≥1 message).
+ *
+ * `--recover` short-circuits to "resume" without asking; piped/non-TTY
+ * input degrades to the same — the alternative is hanging on stdin or
+ * forcing the user to remember a flag they never typed.
+ */
+//# sourceMappingURL=cli-main.d.ts.map

package/dist/cli-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-main.d.ts","sourceRoot":"","sources":["../src/cli-main.ts"],"names":[],"mappings":"AAmFA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AA2B3C,OAAO,EAAE,WAAW,EAAE,CAAC;AAavB,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAgtE1D;AAED;;;;;;;;GAQG"}

package/dist/cli-recovery-prompt.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interactive prompt for an abandoned-session recovery decision.
+ *
+ * Three branches:
+ *   - `autoRecover` is true (caller passed `--recover`): resume silently.
+ *   - stdin is not a TTY (CI / piped): skip, leave the session alone.
+ *   - interactive: ask the user — y/Y/Enter resume, n/N skip, d/D delete.
+ *
+ * Exists as a free function so it can be unit-tested with a fake
+ * `ReadlineInputReader` and a renderer stub. Previously a private nested
+ * function in `index.ts`; extracted as part of the cli/index.ts decompose
+ * pass to make the recovery contract independently testable.
+ */
+import type { AbandonedSession } from '@wrongstack/core';
+import type { ReadlineInputReader } from './input-reader.js';
+import type { TerminalRenderer } from './renderer.js';
+export type RecoveryDecision = 'resume' | 'delete' | 'skip';
+export declare function promptRecovery(reader: ReadlineInputReader, renderer: TerminalRenderer, abandoned: AbandonedSession, autoRecover: boolean): Promise<RecoveryDecision>;
+//# sourceMappingURL=cli-recovery-prompt.d.ts.map

package/dist/cli-recovery-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-recovery-prompt.d.ts","sourceRoot":"","sources":["../src/cli-recovery-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5D,wBAAsB,cAAc,CAClC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,gBAAgB,EAC3B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAkC3B"}

package/dist/cli-update-notice.d.ts

@@ -0,0 +1,3 @@
+import type { UpdateInfo } from './update-check.js';
+export declare function printUpdateNotice(initialUpdateInfo?: UpdateInfo | undefined): Promise<UpdateInfo | undefined>;
+//# sourceMappingURL=cli-update-notice.d.ts.map

package/dist/cli-update-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-update-notice.d.ts","sourceRoot":"","sources":["../src/cli-update-notice.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,wBAAsB,iBAAiB,CACrC,iBAAiB,CAAC,EAAE,UAAU,GAAG,SAAS,GACzC,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAkBjC"}

package/dist/config-doctor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Config doctor — deterministic diagnosis and auto-repair for the standard
+ * config file (~/.wrongstack/config.json and the per-project config).
+ *
+ * Pure module: `diagnoseConfig` never touches the filesystem. The /doctor
+ * slash command owns file IO, backups, and persistence so the engine stays
+ * trivially testable.
+ *
+ * Repair philosophy: a removed key is always safe — built-in defaults (and,
+ * for `extensions`, each plugin's `defaultConfig`) are merged underneath user
+ * values at load time, so deleting an invalid value falls back to a known-good
+ * default. Values are only rewritten when the intent is unambiguous (e.g. the
+ * string "true" for a boolean field); anything ambiguous is reported as a
+ * non-fixable finding instead of guessed at.
+ */
+import type { JSONSchema } from '@wrongstack/core';
+export type DoctorSeverity = 'error' | 'warning';
+export interface DoctorFinding {
+    /** Dot path of the offending value, e.g. `autonomy.defaultMode`. */
+    path: string;
+    problem: string;
+    severity: DoctorSeverity;
+    /** Present when the finding is auto-fixable; describes the repair. */
+    fix?: string | undefined;
+}
+export interface DoctorReport {
+    findings: DoctorFinding[];
+    /** Deep copy of the input with every fixable finding repaired. */
+    fixed: Record<string, unknown>;
+    /** True when `fixed` differs from the input. */
+    changed: boolean;
+}
+/** The subset of Plugin the doctor needs to validate `extensions` sections. */
+export interface PluginSchemaInfo {
+    name: string;
+    configSchema?: JSONSchema | undefined;
+}
+export declare function diagnoseConfig(cfg: Record<string, unknown>, plugins?: PluginSchemaInfo[]): DoctorReport;
+//# sourceMappingURL=config-doctor.d.ts.map

package/dist/config-doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-doctor.d.ts","sourceRoot":"","sources":["../src/config-doctor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAQnD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,CAAC;AAEjD,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,CAAC;IACzB,sEAAsE;IACtE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACvC;AAyED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,OAAO,GAAE,gBAAgB,EAAO,GAC/B,YAAY,CA4Sd"}

package/dist/config-history.d.ts

@@ -0,0 +1,54 @@
+export declare const MAX_CONFIG_HISTORY_ENTRIES = 50;
+export interface HistoryEntry {
+    id: string;
+    timestamp: string;
+    description: string;
+    snapshotMasked: Record<string, unknown>;
+    diffSummary: string;
+}
+interface HistoryIndex {
+    version: 1;
+    entries: Array<{
+        id: string;
+        timestamp: string;
+        description: string;
+    }>;
+}
+type HomeDirFn = () => string;
+/**
+ * Backup current config.json → config.json.last and timestamped .bak files.
+ * Safe to call even if config.json doesn't exist. Never throws.
+ *
+ * IMPORTANT: config.json and .key are never deleted by this function.
+ * Only config.json.*.bak timestamped snapshots are pruned.
+ */
+export declare function backupCurrent(homeFn?: HomeDirFn): Promise<void>;
+/**
+ * Append a history entry for a config change.
+ */
+export declare function appendHistory(oldCfg: Record<string, unknown>, newCfg: Record<string, unknown>, description: string, homeFn?: HomeDirFn): Promise<string>;
+/**
+ * List all history entries (newest first).
+ */
+export declare function listHistory(homeFn?: HomeDirFn): Promise<HistoryIndex['entries']>;
+/**
+ * Get a specific history entry by ID.
+ */
+export declare function getHistoryEntry(id: string, homeFn?: HomeDirFn): Promise<HistoryEntry | null>;
+/**
+ * Restore config.json to a given history entry's snapshot.
+ */
+export declare function restoreFromHistory(id: string, homeFn?: HomeDirFn): Promise<{
+    ok: boolean;
+    backupId: string | null;
+    error?: string | undefined;
+}>;
+/**
+ * Restore config.json to the .last backup.
+ */
+export declare function restoreLast(homeFn?: HomeDirFn): Promise<{
+    ok: boolean;
+    error?: string | undefined;
+}>;
+export {};
+//# sourceMappingURL=config-history.d.ts.map