@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/dist/types/skc-runtime/session-restore.d.ts

@@ -0,0 +1,99 @@
+import { type BootGeneration, type RecordedBootGeneration } from "./boot-generation";
+export declare const RESTORE_POINTER_SCHEMA_VERSION = 1;
+export interface RestorePointer {
+    schema_version: number;
+    /** Coordinator identity: what the create fence and the sidecar are keyed by. */
+    coordinator_session_id: string;
+    state_file: string;
+    /** SKC session id whose transcript `skc --resume` would reopen. */
+    skc_session_id: string;
+    session_file: string;
+    cwd: string;
+    branch: string | null;
+    boot: RecordedBootGeneration;
+    updated_at: string;
+}
+/** Pointers live under SKC's own root so they are discoverable without scanning projects. */
+export declare function restorePointerDirectory(): string;
+export declare function restorePointerFile(coordinatorSessionId: string, stateFile: string): string;
+export declare function isRestorePointer(value: unknown): value is RestorePointer;
+/**
+ * The session id `skc --resume` resolves is the transcript header id, which is
+ * NOT the coordinator id: a normal `skc --tmux` child inherits only the
+ * coordinator identity and then mints its own session id. Reading it from the
+ * transcript is the only way a pointer can name the conversation that will
+ * actually be reopened.
+ */
+export declare function readTranscriptSessionId(sessionFile: string): string | null;
+export interface PublishRestorePointerInput {
+    coordinatorSessionId: string;
+    stateFile: string;
+    skcSessionId: string;
+    sessionFile: string;
+    cwd: string;
+    branch?: string | null;
+    bootGeneration?: BootGeneration;
+    now?: () => Date;
+}
+/**
+ * Publishes (or refreshes) the pointer for a live session.
+ *
+ * Returns false without writing when the platform cannot produce boot evidence:
+ * a pointer whose boot value is unusable could never be judged `changed`, so
+ * writing one would only add noise. Never throws — losing a pointer must not
+ * break the session that was trying to publish it.
+ */
+export declare function publishRestorePointer(input: PublishRestorePointerInput): boolean;
+/** Lists candidate pointers. Unreadable or malformed entries are skipped, never guessed at. */
+export declare function listRestorePointers(): RestorePointer[];
+/**
+ * Exact reference to one candidate, for `skc session restore --reference`.
+ *
+ * base64url of the identity pair, so a reference cannot be confused with a
+ * session id, a path, or a prefix. It selects a candidate; it never overrides
+ * any eligibility check.
+ */
+export declare function encodeRestoreReference(coordinatorSessionId: string, stateFile: string): string;
+export declare function decodeRestoreReference(reference: string): {
+    coordinatorSessionId: string;
+    stateFile: string;
+} | null;
+export type RestoreIneligibleReason = "same_boot" | "boot_unknown" | "sidecar_missing" | "sidecar_identity_mismatch" | "sidecar_terminal" | "transcript_missing" | "cwd_missing" | "live_identity_collision" | "transcript_identity_mismatch" | "unsupported_owner_proof";
+export type RestoreCandidateVerdict = {
+    eligible: true;
+    pointer: RestorePointer;
+} | {
+    eligible: false;
+    pointer: RestorePointer;
+    reason: RestoreIneligibleReason;
+    detail?: string;
+};
+/** The sidecar fields restore is allowed to trust, read fresh at decision time. */
+export interface RestoreSidecarFacts {
+    sessionId: string;
+    stateFile: string;
+    sessionFile: string | null;
+    cwd: string | null;
+    terminal: boolean;
+}
+export interface RestoreCandidateDeps {
+    currentBoot: BootGeneration;
+    /** Strict re-read of the referenced sidecar. Null when absent or unparseable. */
+    readSidecar: (pointer: RestorePointer) => RestoreSidecarFacts | null;
+    pathExists: (target: string) => boolean;
+    /** True when a live tmux session already owns this identity. */
+    hasLiveIdentity: (pointer: RestorePointer) => boolean;
+    /** Header id of the transcript the pointer names, re-read at decision time. */
+    readTranscriptSessionId: (pointer: RestorePointer) => string | null;
+    /** False when this host cannot produce the owner proof restore requires (psmux). */
+    ownerProofAvailable: () => boolean;
+}
+/**
+ * Decides whether one candidate may be restored.
+ *
+ * Order matters: the reboot proof comes first because it is the cheapest and the
+ * most restrictive gate, and the pointer's own contents are never trusted beyond
+ * naming what to re-read.
+ */
+export declare function evaluateRestoreCandidate(pointer: RestorePointer, deps: RestoreCandidateDeps): RestoreCandidateVerdict;
+export declare function evaluateRestoreCandidates(pointers: readonly RestorePointer[], deps: RestoreCandidateDeps): RestoreCandidateVerdict[];

package/dist/types/skc-runtime/tmux-owner-isolation.d.ts

@@ -302,6 +302,166 @@ export declare function replaceOwnerGenerationSync(stateDir: string, sessionId:
 /** Publishes a raw-owner generation through the canonical SQLite-serialized CAS path. */
 export declare function publishOwnerGenerationSync(request: PublishGenerationRequest): PublishGenerationResult;
 export declare function createOwnerIntent(stateDir: string, input: Omit<OwnerIntent, "schema_version" | "intent_id" | "state">): Promise<OwnerIntent>;
+/**
+ * Shared identity create fence (frozen contract F1'-F9''', architect-approved).
+ *
+ * Concurrent creators of the SAME canonical `(stateDir, sessionId)` identity must
+ * not both spawn a child: `SessionManager` opens transcripts with append flags and
+ * has no inter-process single-writer lock, so two owners on one transcript is a
+ * data-integrity failure rather than a recoverable skip.
+ *
+ * The fence deliberately does NOT hold the SQLite writer transaction across the
+ * spawn. `bootstrapTmuxOwnerIsolation()` runs in a separate process and acquires
+ * this very database twice itself, and the synchronous creator blocks on that
+ * helper through `Bun.spawnSync`, so a held transaction would deadlock the helper
+ * against its own parent. A long hold would also starve the 250 ms verdict path
+ * that shares this database. Instead each transition takes a short (target 50 ms)
+ * transaction that only reads and writes a durable reservation row; mutual
+ * exclusion outlives the transaction as row state, not as a held lock.
+ */
+export type IdentityCreatePhase = "reserved" | "helper_invoked" | "spawned" | "tagged" | "published";
+/** Phases at or beyond which an untagged child may already exist on the server. */
+export declare function identityCreatePhaseMayHaveChild(phase: IdentityCreatePhase): boolean;
+export interface IdentityCreateKey {
+    stateDir: string;
+    sessionId: string;
+    stateFile: string;
+}
+export interface IdentityCreateReservation {
+    reservationId: string;
+    stateDir: string;
+    sessionId: string;
+    stateFile: string;
+    ownerPid: number;
+    ownerIncarnation: string;
+    phase: IdentityCreatePhase;
+    attemptSessionName: string | null;
+    nativeSessionId: string | null;
+    serverPid: number | null;
+    serverStartTime: string | null;
+    claimedAt: string;
+    updatedAt: string;
+    leaseDeadline: string;
+}
+export type IdentityCreateReservationResult = {
+    ok: true;
+    reservation: IdentityCreateReservation;
+    recovered: IdentityCreateReservation | null;
+} | {
+    ok: false;
+    code: "identity_reserved_live" | "identity_reserved_unknown" | "identity_fence_contended" | "identity_incarnation_unavailable" | "identity_orphan_unresolved" | "identity_existing_owner";
+    existing: IdentityCreateReservation | null;
+    diagnostic: string;
+};
+/** Owner liveness is tri-state: only a proven-dead owner may be displaced. */
+export type OwnerLiveness = "alive" | "dead" | "unknown";
+/**
+ * `processIncarnation()` returns `undefined` both for a vanished process and for a
+ * failed probe, so existence is resolved first. Signal 0 distinguishes them:
+ * `ESRCH` proves absence, `EPERM` proves a live process owned by another user, and
+ * anything else is unknown. Only then does the incarnation discriminate PID reuse.
+ */
+export declare function probeOwnerLiveness(pid: number, recordedIncarnation: string, deps?: {
+    readIncarnation?: (pid: number) => string | undefined;
+    signal?: (pid: number) => void;
+}): OwnerLiveness;
+/** @internal Test seam for the incarnation reader. */
+export declare function __setOwnerIncarnationReaderForTests(reader: ((pid: number) => string | undefined) | null): void;
+export declare function canonicalIdentityCreateKey(key: IdentityCreateKey): IdentityCreateKey;
+/**
+ * Ends the attempt while KEEPING the durable row.
+ *
+ * Used when cleanup after a spawn was uncertain: a child may survive that we
+ * could not remove, so the evidence must outlive the attempt. Unlike
+ * `releaseIdentityCreate` this leaves the row for authority-first recovery.
+ */
+export declare function abandonIdentityCreate(reservation: IdentityCreateReservation): void;
+export interface ReserveIdentityCreateOptions {
+    ttlMs?: number;
+    ownerPid?: number;
+    ownerIncarnation?: string;
+    now?: () => Date;
+    probeLiveness?: (pid: number, incarnation: string) => OwnerLiveness;
+}
+/**
+ * Claims the identity when it is free, and otherwise reports why not.
+ *
+ * A dead previous owner is deliberately NOT displaced here: authority-first
+ * recovery has to census live tmux, which shells out and must never run inside
+ * the fence window. The caller performs that census and then calls
+ * {@link reclaimIdentityCreate}.
+ *
+ * The lease deadline is diagnostic only. Expiry never authorizes takeover; only a
+ * proven-dead owner does, because real creator paths block in unbounded
+ * `Bun.spawnSync` and cannot heartbeat while blocked.
+ */
+export declare function reserveIdentityCreate(rawKey: IdentityCreateKey, options?: ReserveIdentityCreateOptions): IdentityCreateReservationResult;
+/**
+ * Completes authority-first recovery after the caller proved, outside the fence
+ * window, that the abandoned reservation left no authoritative child behind.
+ *
+ * `expectedReservationId` pins the exact abandoned row: if another process already
+ * recovered it, the row no longer matches and this fails closed rather than
+ * producing a second child.
+ */
+export declare function reclaimIdentityCreate(rawKey: IdentityCreateKey, expectedReservationId: string, options?: ReserveIdentityCreateOptions): IdentityCreateReservationResult;
+/**
+ * What a live-tmux census concluded about the child an abandoned reservation may
+ * have left behind. `unknown` is not a soft failure: it is the fail-closed case.
+ */
+export type AbandonedIdentityVerdict = {
+    kind: "authoritative";
+    nativeSessionId: string;
+} | {
+    kind: "orphan";
+    nativeSessionId: string;
+} | {
+    kind: "absent";
+} | {
+    kind: "unknown";
+    reason: string;
+};
+/**
+ * Injected so this module never imports the tmux session helpers (which already
+ * depend on it). The census shells out and therefore runs OUTSIDE the fence
+ * window, by construction.
+ */
+export interface AbandonedIdentityCensus {
+    inspect(evidence: {
+        stateDir: string;
+        sessionId: string;
+        attemptSessionName: string | null;
+        nativeSessionId: string | null;
+    }): AbandonedIdentityVerdict;
+    cleanupOrphan(nativeSessionId: string, attemptSessionName: string | null): void;
+}
+/**
+ * Authority-first recovery for a reservation whose owner is proven dead and that
+ * reached at least `helper_invoked`, so an untagged child may exist.
+ *
+ * The reservation's own `phase` is a hint, never the authority: a creator can
+ * publish its generation and die before recording `published`. The census reads
+ * the live canonical tags and the current published generation instead, so a
+ * valid child is preserved rather than killed — which is what keeps a
+ * tag-before-report crash from producing a successor.
+ */
+export declare function recoverAbandonedIdentityCreate(key: IdentityCreateKey, existing: IdentityCreateReservation, census: AbandonedIdentityCensus, options?: ReserveIdentityCreateOptions): IdentityCreateReservationResult;
+export interface IdentityCreatePhasePatch {
+    attemptSessionName?: string | null;
+    nativeSessionId?: string | null;
+    serverPid?: number | null;
+    serverStartTime?: string | null;
+}
+/**
+ * Records a create-progress transition and renews the lease.
+ *
+ * Returns `null` when the reservation is no longer ours. The caller MUST treat
+ * that as a lost fence and perform no tmux mutation: another process has already
+ * recovered this identity.
+ */
+export declare function advanceIdentityCreatePhase(reservation: IdentityCreateReservation, phase: IdentityCreatePhase, patch?: IdentityCreatePhasePatch, options?: Pick<ReserveIdentityCreateOptions, "ttlMs" | "now">): IdentityCreateReservation | null;
+/** Releases the reservation. Idempotent, and never deletes a successor's row. */
+export declare function releaseIdentityCreate(reservation: IdentityCreateReservation): void;
 /** Publish exactly one terminal verdict. Existing valid verdicts always win. */
 export declare function observeOwnerTerminal(request: ObserveTerminalRequest): Promise<OwnerVerdict>;
 /** Strictly validate the persisted authorization, optionally against its terminal observation. */

package/dist/types/skc-runtime/tmux-sessions.d.ts

@@ -1,4 +1,4 @@
-import { type OwnerIsolationProbeSync, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
+import { type AbandonedIdentityCensus, type IdentityCreateKey, type IdentityCreateReservationResult, type OwnerIsolationProbeSync, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
 export interface SkcTmuxSessionStatus {
     name: string;
     attached: boolean;
@@ -67,6 +67,17 @@ export interface ForceCloseOwnerDependencies {
 }
 export interface CreateSkcTmuxSessionOptions {
     platform?: NodeJS.Platform;
+    /**
+     * Restore only: run the child in the session's recorded directory instead of
+     * this process's cwd.
+     */
+    cwd?: string;
+    /**
+     * Restore only: argv appended to the `skc` child, e.g. `["--resume", "<id>"]`.
+     * Restore reuses this creator verbatim so it inherits the same identity fence
+     * and owner-isolation proof as an ordinary create.
+     */
+    childArgs?: string[];
 }
 export type CreateOwnerIsolationTestDependencies = {
     probe?: Partial<OwnerIsolationProbeSync>;
@@ -83,6 +94,20 @@ export declare function findSkcTmuxSessionByBranch(branch: string, env?: NodeJS.
 export declare function findSkcTmuxSessionByName(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus | undefined;
 export declare function findSkcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus | undefined;
 export declare function statusSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
+/**
+ * Live-tmux census for authority-first recovery of an abandoned reservation.
+ *
+ * Authority is the CURRENT published generation on disk compared against the
+ * live session's canonical tags — never the reservation's own `phase`, because a
+ * creator can publish and then die before recording that it published.
+ */
+/**
+ * Resolves a reservation refused because its previous owner died after reaching
+ * the helper. Shared by every producer so none of them can brick an identity by
+ * treating an abandoned row as a permanent collision.
+ */
+export declare function settleAbandonedIdentity(reserved: IdentityCreateReservationResult, identityKey: IdentityCreateKey, census: AbandonedIdentityCensus): IdentityCreateReservationResult;
+export declare function abandonedIdentityCensus(tmuxCommand: string, env: NodeJS.ProcessEnv, stateFile: string): AbandonedIdentityCensus;
 export declare function createSkcTmuxSession(env?: NodeJS.ProcessEnv, options?: CreateSkcTmuxSessionOptions): SkcTmuxSessionStatus;
 /** Proves a managed reusable name still resolves to one immutable session on one server. */
 export declare function proveSkcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv): ProvenTmuxSessionIdentity;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -1,10 +1,14 @@
 import { type ComposerSubmissionOptions } from "../modes/types";
+import { runSessionImportCommand } from "../session-import";
 import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime & {
     composer?: ComposerSubmissionOptions;
 };
+type SessionImportRunner = typeof runSessionImportCommand;
+export declare function handleImportSessionCommand(command: ParsedSlashCommand, runtime: SlashCommandRuntime, importer?: SessionImportRunner): Promise<SlashCommandResult>;
+export declare function handleImportSessionTuiCommand(command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime, importer?: SessionImportRunner): Promise<SlashCommandResult>;
 export declare function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined;
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;

package/dist/types/slash-commands/types.d.ts

@@ -81,6 +81,11 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
     aliases?: string[];
     /** When false, the dispatcher refuses to handle invocations that include arguments. */
     allowArgs?: boolean;
+    /**
+     * Whether ACP may advertise and execute this command. Commands that read
+     * caller-selected local paths must set this to false.
+     */
+    acp?: boolean;
     /**
      * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
      * when building `available_commands_update` payloads so the client receives

package/dist/types/tools/ask.d.ts

@@ -29,13 +29,92 @@ export declare const askSchema: z.ZodObject<{
         }, z.core.$strip>>;
         multi: z.ZodOptional<z.ZodBoolean>;
         recommended: z.ZodOptional<z.ZodNumber>;
-        deepInterview: z.ZodOptional<z.ZodObject<{
+        workflowGate: z.ZodOptional<z.ZodObject<{
+            stage: z.ZodEnum<{
+                "deep-interview": "deep-interview";
+                ralplan: "ralplan";
+                ultragoal: "ultragoal";
+            }>;
+            kind: z.ZodEnum<{
+                question: "question";
+                approval: "approval";
+                execution: "execution";
+            }>;
+        }, z.core.$strip>>;
+        deepInterview: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            round: z.ZodLiteral<0>;
+            component: z.ZodLiteral<"review-topology">;
+            intent_contract: z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    category: z.ZodEnum<{
+                        surface: "surface";
+                        artifact: "artifact";
+                        integration: "integration";
+                        constraint: "constraint";
+                    }>;
+                    statement: z.ZodString;
+                }, z.core.$strict>>;
+                confirmation_options: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
             round_id: z.ZodOptional<z.ZodString>;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+            confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                reference_id: z.ZodString;
+                label: z.ZodString;
+                origin: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+                excerpt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
             round: z.ZodNumber;
+            intent_review: z.ZodObject<{
+                observed_items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    category: z.ZodEnum<{
+                        surface: "surface";
+                        artifact: "artifact";
+                        integration: "integration";
+                        constraint: "constraint";
+                    }>;
+                    statement: z.ZodString;
+                }, z.core.$strict>>;
+                supporting_substitutions: z.ZodArray<z.ZodObject<{
+                    removed_id: z.ZodString;
+                    replacement_ids: z.ZodArray<z.ZodString>;
+                    rationale: z.ZodString;
+                }, z.core.$strict>>;
+                approval_options: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            round_id: z.ZodOptional<z.ZodString>;
             component: z.ZodString;
             dimension: z.ZodString;
             ambiguity: z.ZodNumber;
-        }, z.core.$strip>>;
+            confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                reference_id: z.ZodString;
+                label: z.ZodString;
+                origin: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+                excerpt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            round: z.ZodNumber;
+            component: z.ZodString;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+            confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                reference_id: z.ZodString;
+                label: z.ZodString;
+                origin: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+                excerpt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>]>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AskToolInput = z.infer<typeof askSchema>;
@@ -54,6 +133,8 @@ export interface AskToolDetails {
     multi?: boolean;
     selectedOptions?: string[];
     customInput?: string;
+    /** Set when the user answered with a clarification question instead of a choice. */
+    clarificationQuestion?: string;
     /** Multi-part question mode */
     results?: QuestionResult[];
 }
@@ -80,16 +161,100 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
             }, z.core.$strip>>;
             multi: z.ZodOptional<z.ZodBoolean>;
             recommended: z.ZodOptional<z.ZodNumber>;
-            deepInterview: z.ZodOptional<z.ZodObject<{
+            workflowGate: z.ZodOptional<z.ZodObject<{
+                stage: z.ZodEnum<{
+                    "deep-interview": "deep-interview";
+                    ralplan: "ralplan";
+                    ultragoal: "ultragoal";
+                }>;
+                kind: z.ZodEnum<{
+                    question: "question";
+                    approval: "approval";
+                    execution: "execution";
+                }>;
+            }, z.core.$strip>>;
+            deepInterview: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                round: z.ZodLiteral<0>;
+                component: z.ZodLiteral<"review-topology">;
+                intent_contract: z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        category: z.ZodEnum<{
+                            surface: "surface";
+                            artifact: "artifact";
+                            integration: "integration";
+                            constraint: "constraint";
+                        }>;
+                        statement: z.ZodString;
+                    }, z.core.$strict>>;
+                    confirmation_options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
                 round_id: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+                confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    reference_id: z.ZodString;
+                    label: z.ZodString;
+                    origin: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                    excerpt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
                 round: z.ZodNumber;
+                intent_review: z.ZodObject<{
+                    observed_items: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        category: z.ZodEnum<{
+                            surface: "surface";
+                            artifact: "artifact";
+                            integration: "integration";
+                            constraint: "constraint";
+                        }>;
+                        statement: z.ZodString;
+                    }, z.core.$strict>>;
+                    supporting_substitutions: z.ZodArray<z.ZodObject<{
+                        removed_id: z.ZodString;
+                        replacement_ids: z.ZodArray<z.ZodString>;
+                        rationale: z.ZodString;
+                    }, z.core.$strict>>;
+                    approval_options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                round_id: z.ZodOptional<z.ZodString>;
                 component: z.ZodString;
                 dimension: z.ZodString;
                 ambiguity: z.ZodNumber;
-            }, z.core.$strip>>;
+                confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    reference_id: z.ZodString;
+                    label: z.ZodString;
+                    origin: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                    excerpt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                round: z.ZodNumber;
+                component: z.ZodString;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+                confused_terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    reference_id: z.ZodString;
+                    label: z.ZodString;
+                    origin: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                    excerpt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly strict = true;
+    /**
+     * These fields are rendered to the user and carry no executable or durable
+     * meaning. IDs and workflow/deep-interview metadata remain fail-closed.
+     */
+    readonly displaySafeEscapedArgFields: readonly ["questions.question", "questions.options.label"];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): AskTool | null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.5.1",
+	"version": "0.5.6",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
@@ -33,6 +33,7 @@
 	"scripts": {
 		"build": "bun scripts/build-binary.ts",
 		"check": "biome check . && bun run check:types",
+		"check:runtime": "bun run generate-hotkeys-docs --check",
 		"check:types": "tsgo -p tsconfig.json --noEmit",
 		"lint": "biome lint .",
 		"test": "bun test --isolate",
@@ -43,6 +44,7 @@
 		"fmt": "biome format --write . && bun run format-prompts",
 		"format-prompts": "bun scripts/format-prompts.ts",
 		"generate-docs-index": "bun scripts/generate-docs-index.ts",
+		"generate-hotkeys-docs": "bun scripts/generate-hotkeys-docs.ts",
 		"prepack": "bun scripts/generate-docs-index.ts",
 		"generate-template": "bun scripts/generate-template.ts",
 		"install:defaults": "bun src/cli.ts setup defaults",
@@ -52,12 +54,12 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.5.1",
-		"@sayknow-cli/agent-core": "0.5.1",
-		"@sayknow-cli/ai": "0.5.1",
-		"@sayknow-cli/natives": "0.5.1",
-		"@sayknow-cli/tui": "0.5.1",
-		"@sayknow-cli/utils": "0.5.1",
+		"@sayknow-cli/stats": "0.5.6",
+		"@sayknow-cli/agent-core": "0.5.6",
+		"@sayknow-cli/ai": "0.5.6",
+		"@sayknow-cli/natives": "0.5.6",
+		"@sayknow-cli/tui": "0.5.6",
+		"@sayknow-cli/utils": "0.5.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -88,6 +90,10 @@
 		"README.md",
 		"CHANGELOG.md",
 		"vendor",
+		"!vendor/insane-search/engine/tests/**",
+		"!src/export/html/template.html",
+		"!src/export/html/template.css",
+		"!src/export/html/template.js",
 		"dist/types"
 	],
 	"exports": {
@@ -124,6 +130,9 @@
 		"./commands/skc-runtime-bridge": null,
 		"./capability/mcp": null,
 		"./config/mcp-schema": null,
+		"./config/model-auth": null,
+		"./config/model-bindings-applier": null,
+		"./config/model-discovery-manager": null,
 		"./discovery/mcp-json": null,
 		"./exa": null,
 		"./exa/*": null,

package/scripts/generate-sdk-operation-inventory.ts

@@ -34,6 +34,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"slash_command:pet": "visual/local-only command, not a user-facing SDK control seam",
 	"slash_command:transcript": "visual/local-only transcript viewer, not a user-facing SDK control seam",
 	"slash_command:sessions": "visual/local-only sessions dashboard, not a user-facing SDK control seam",
+	"slash_command:import-session":
+		"local transcript-file import into a new session; ACP is explicitly disabled and no SDK operation reads caller-selected host paths",
 	"agent_session:constructor": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:nextToolChoice": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:setForcedToolChoice": "internal accessor/plumbing, not a user-facing control seam",
@@ -51,6 +53,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:clearPlanCompactAbortPending": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:enqueueCustomMessageDisplay": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:runMidRunMaintenanceForTests": "test-only maintenance seam, not a user-facing SDK control seam",
+	"agent_session:runPrePromptContextCheckForTests": "test-only context check seam, not a user-facing SDK control seam",
 	"agent_session:estimateMidRunContextTokensForTests": "test-only estimator seam, not a user-facing SDK control seam",
 	"agent_session:activeMidRunBarrierCountForTests": "read-only test seam, not a user-facing SDK control seam",
 	"agent_session:activeMidRunMaintenanceCountForTests": "read-only test seam, not a user-facing SDK control seam",
@@ -58,6 +61,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:setCancelAndSubmitAbortOutcomeProviderForTests":
 		"test-only cancellation seam, not a user-facing SDK control seam",
 	"agent_session:getAgentId": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:hasExplicitlyDisabledTools":
+		"internal automatic-tool-selection predicate, not a user-facing SDK control seam",
 	"agent_session:emitNotice": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:subscribe": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:dispose": "internal accessor/plumbing, not a user-facing control seam",
@@ -275,9 +280,6 @@ const SEAM_TO_SDK: Readonly<Record<string, string>> = {
 	"slash_command:move": "session.cwd.move",
 };
 
-/** Genuine action seams awaiting a reviewed registry mapping or exclusion. */
-const PENDING_REVIEW: Readonly<Record<string, string>> = {};
-
 function lockedExclusion(sourceId: string): string | undefined {
 	return LOCKED_EXCLUSIONS[sourceId];
 }
@@ -812,7 +814,6 @@ function generatedRecords(seams: Awaited<ReturnType<typeof scanSeams>>): Invento
 	for (const seam of seams) {
 		const sdkId = SEAM_TO_SDK[seam.sourceId];
 		const rationale = lockedExclusion(seam.sourceId);
-		if (!sdkId && !rationale) continue;
 		if (!sdkId) {
 			if (!rationale) continue;
 			records.push({
@@ -877,8 +878,6 @@ export function pendingReviewErrors(seams: readonly Pick<SourceSeam, "sourceId">
 
 async function check(records: InventoryRecord[], seams: Awaited<ReturnType<typeof scanSeams>>): Promise<void> {
 	const errors = [...validateRegistry(records), ...pendingReviewErrors(seams)];
-	for (const sourceId of Object.keys(PENDING_REVIEW))
-		errors.push(`Pending review source seam: ${sourceId}. ${PENDING_REVIEW[sourceId]}`);
 	let checkedIn: InventoryRecord[];
 	try {
 		checkedIn = await Bun.file(inventoryPath).json();