@sayknow-cli/coding-agent 0.5.2 → 0.5.8

package/dist/types/session-import/claude.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Claude adapter (issue #3709).
+ *
+ * Parses two first-party observable Claude transcript/export shapes:
+ *
+ * 1. `claude-code-jsonl` — Claude Code session transcripts
+ *    (`~/.claude/projects/<project-slug>/<session-uuid>.jsonl`), one JSON object
+ *    per line with `type: "user" | "assistant" | "summary" | "system" | …`.
+ * 2. `claude-export-json` — the claude.ai data export (`conversations.json`):
+ *    a JSON array of conversations (or a single conversation object) whose
+ *    `chat_messages` carry `sender: "human" | "assistant"` and `content` blocks.
+ *
+ * The same quarantine contract as the Codex adapter applies: unmappable
+ * records/messages are counted and digested, never silently dropped.
+ */
+import { type ImportedConversation, type ImportQuarantineRecord, type SessionImportCounts } from "./types";
+export interface ClaudeParseResult {
+    conversation: ImportedConversation;
+    quarantine: ImportQuarantineRecord[];
+    counts: SessionImportCounts;
+    redactionKinds: string[];
+}
+/** Parse a Claude Code session JSONL transcript. */
+export declare function parseClaudeCodeTranscript(text: string): ClaudeParseResult;
+/** Parse a claude.ai data-export conversation (array or single object). */
+export declare function parseClaudeExport(text: string): ClaudeParseResult;

package/dist/types/session-import/codex.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Codex adapter (issue #3709).
+ *
+ * Parses the Codex CLI rollout transcript: one JSON object per line
+ * (`rollout-*.jsonl`, e.g. `~/.codex/sessions/2026/08/01/rollout-….jsonl`).
+ * This is Codex's own observable transcript format; the file the user passes is
+ * treated as an explicit export and is only read.
+ *
+ * Strictness contract: records that fail to parse or lack required fields are
+ * quarantined with deterministic digests — never silently dropped. Unknown
+ * record/event types are mapped when their payload shape is recognized and
+ * quarantined otherwise.
+ */
+import { type ImportedConversation, type ImportQuarantineRecord, type SessionImportCounts } from "./types";
+export interface CodexParseResult {
+    conversation: ImportedConversation;
+    quarantine: ImportQuarantineRecord[];
+    counts: SessionImportCounts;
+    redactionKinds: string[];
+}
+/** Parse a Codex rollout JSONL transcript into the provider-neutral IR. */
+export declare function parseCodexRollout(text: string): CodexParseResult;

package/dist/types/session-import/command.d.ts

@@ -0,0 +1,20 @@
+import type { SessionImportCompleted, SessionImportProviderId } from "./types";
+export declare const IMPORT_SESSION_USAGE = "Usage: /import-session <transcript-file> [--provider codex|claude]";
+export type ParsedImportSessionArgs = {
+    kind: "ok";
+    sourcePath: string;
+    provider?: SessionImportProviderId;
+} | {
+    kind: "error";
+    message: string;
+};
+export declare function parseImportSessionArgs(args: string): ParsedImportSessionArgs;
+export type SessionImportCommandOutcome = {
+    kind: "imported";
+    result: SessionImportCompleted;
+} | {
+    kind: "error";
+    message: string;
+};
+/** Imports a new session only. The caller owns the current-session switch/resume seam. */
+export declare function runSessionImportCommand(args: string, cwd: string): Promise<SessionImportCommandOutcome>;

package/dist/types/session-import/detect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Deterministic source-format detection (issue #3709).
+ *
+ * Detection inspects only the already-read source bytes: a bounded leading
+ * sample decides JSONL-vs-JSON and provider by envelope markers. An explicit
+ * `--provider` selection narrows candidates; a sample that matches a different
+ * provider than requested fails closed with `format_mismatch`. Detection never
+ * guesses: a sample matching no supported envelope fails with
+ * `unsupported_format` rather than falling back to a speculative parse.
+ */
+import { type SessionImportFormatId, type SessionImportProviderId } from "./types";
+export interface SessionImportDetection {
+    provider: SessionImportProviderId;
+    format: SessionImportFormatId;
+}
+/**
+ * Detect the provider/format of an explicit transcript file.
+ *
+ * @param text Full source text (already size-bounded by the caller).
+ * @param requestedProvider Explicit provider selection; undefined = auto.
+ */
+export declare function detectSessionImportFormat(text: string, requestedProvider?: SessionImportProviderId): SessionImportDetection;

package/dist/types/session-import/index.d.ts

@@ -0,0 +1,7 @@
+export { type ClaudeParseResult, parseClaudeCodeTranscript, parseClaudeExport } from "./claude";
+export { type CodexParseResult, parseCodexRollout } from "./codex";
+export { IMPORT_SESSION_USAGE, type ParsedImportSessionArgs, parseImportSessionArgs, runSessionImportCommand, type SessionImportCommandOutcome, } from "./command";
+export { detectSessionImportFormat, type SessionImportDetection } from "./detect";
+export { IMPORT_SANITIZER_VERSION, redactImportedText, sanitizeImportedString } from "./redact";
+export { formatSessionImportError, formatSessionImportSummary, IMPORT_CONVERTER_VERSION, importExternalSession, materializeSessionImport, prepareSessionImport, SESSION_IMPORT_COMPLETION_CUSTOM_TYPE, SESSION_IMPORT_CONTEXT_CUSTOM_TYPE, SESSION_IMPORT_PROVENANCE_CUSTOM_TYPE, SESSION_IMPORT_QUARANTINE_CUSTOM_TYPE, SESSION_IMPORT_SOURCE_MAX_BYTES, type SessionImportRequest, type SessionImportTestProbe, } from "./service";
+export * from "./types";

package/dist/types/session-import/redact.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fail-closed secret redaction for imported session content (issue #3709).
+ *
+ * Every string that crosses the import boundary passes through
+ * {@link redactImportedText}. Patterns are conservative: a false positive costs
+ * one `[REDACTED]` span in reconstructed context, a false negative leaks a
+ * credential into a new session transcript, so the balance favors redaction.
+ */
+export declare const IMPORT_REDACTED_PLACEHOLDER = "[REDACTED]";
+/** Bumped when patterns change; persisted in import provenance. */
+export declare const IMPORT_SANITIZER_VERSION = 3;
+export interface ImportRedactionResult {
+    value: string;
+    redacted: number;
+    kinds: string[];
+}
+/**
+ * Redact every known credential shape from imported text. The same placeholder
+ * is used for all kinds so a partial pattern overlap cannot leak fragments.
+ */
+export declare function redactImportedText(input: string): ImportRedactionResult;
+/** Redact a string, returning only the sanitized value. */
+export declare function sanitizeImportedString(input: string): string;

package/dist/types/session-import/service.d.ts

@@ -0,0 +1,28 @@
+import { type SessionDestinationInput } from "../session/session-manager";
+import { type PreparedSessionImport, type SessionImportCompleted, type SessionImportProviderId } from "./types";
+export declare const IMPORT_CONVERTER_VERSION = 1;
+/** Durable metadata only; it is not added to model context. */
+export declare const SESSION_IMPORT_PROVENANCE_CUSTOM_TYPE = "session-import";
+export declare const SESSION_IMPORT_QUARANTINE_CUSTOM_TYPE = "session-import-quarantine";
+export declare const SESSION_IMPORT_COMPLETION_CUSTOM_TYPE = "session-import-complete";
+/** Displayed custom-message context reconstructed from the imported transcript. */
+export declare const SESSION_IMPORT_CONTEXT_CUSTOM_TYPE = "session-import";
+export declare const SESSION_IMPORT_SOURCE_MAX_BYTES: number;
+export interface SessionImportRequest {
+    sourcePath: string;
+    provider?: SessionImportProviderId;
+    cwd: string;
+    destination?: SessionDestinationInput;
+    now?: () => Date;
+}
+/** Invocation-scoped mutation seam used only by TOCTOU regression tests. */
+export interface SessionImportTestProbe {
+    afterSourceOpen?: (resolvedSourcePath: string) => void | Promise<void>;
+    afterSourceIdentityCheck?: (resolvedSourcePath: string) => void | Promise<void>;
+}
+/** Read, detect, parse, normalize, redact, and bound without session mutation. */
+export declare function prepareSessionImport(request: Pick<SessionImportRequest, "sourcePath" | "provider">, testProbe?: SessionImportTestProbe): Promise<PreparedSessionImport>;
+export declare function importExternalSession(request: SessionImportRequest): Promise<SessionImportCompleted>;
+export declare function materializeSessionImport(prepared: PreparedSessionImport, options: Pick<SessionImportRequest, "cwd" | "destination" | "now">): Promise<SessionImportCompleted>;
+export declare function formatSessionImportSummary(result: SessionImportCompleted): string;
+export declare function formatSessionImportError(error: unknown): string;

package/dist/types/session-import/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Provider-neutral session-import contract (issue #3709).
+ *
+ * An import accepts ONE explicit user-selected Codex or Claude transcript/export
+ * file, normalizes it into the intermediate representation below, and rebuilds a
+ * bounded, redacted continuation context in one workspace-scoped native SKC
+ * session. A verified identical import is reused; otherwise a new session is
+ * published. The source file is only ever read; provider process state is never scraped.
+ */
+/** Providers with a first-party observable transcript/export format. */
+export type SessionImportProviderId = "codex" | "claude";
+/** Concrete on-disk format variants the adapters understand. */
+export type SessionImportFormatId = "codex-rollout-jsonl" | "claude-code-jsonl" | "claude-export-json";
+/** Maximum quarantined-record digests retained in memory during import. */
+export declare const SESSION_IMPORT_QUARANTINE_MAX_RECORDS = 512;
+/** One normalized conversational unit produced by a provider adapter. */
+export interface ImportedMessage {
+    /** Conversational role. Tool evidence is attached to assistant turns. */
+    role: "user" | "assistant";
+    /** Visible text (may be empty when only tool evidence exists). */
+    text: string;
+    /** ISO-8601 source timestamp when the record carried one. */
+    timestamp?: string;
+    /**
+     * Bounded, already redacted tool/file evidence lines (e.g. `$ ls` → `ok`).
+     * Rendered inline after the text so completed work stays visible.
+     */
+    toolEvidence?: string[];
+}
+/** Provider-neutral normalized conversation. */
+export interface ImportedConversation {
+    provider: SessionImportProviderId;
+    format: SessionImportFormatId;
+    /** Source-side session/conversation identifier when the format carries one. */
+    sourceSessionId?: string;
+    /** Source title when the format carries one. */
+    title?: string;
+    /** Source workspace cwd when the format carries one. */
+    cwd?: string;
+    messages: ImportedMessage[];
+}
+/** Deterministic, actionable import failure codes. */
+export type SessionImportErrorCode = "invalid_request" | "source_not_found" | "source_unreadable" | "source_changed" | "unsupported_format" | "format_mismatch" | "malformed_input" | "content_too_large" | "destination_conflict" | "io_failed";
+/** Import pipeline phase a failure belongs to. */
+export type SessionImportPhase = "request" | "read" | "detect" | "parse" | "normalize" | "persist" | "cleanup" | "switch";
+export declare class SessionImportError extends Error {
+    readonly code: SessionImportErrorCode;
+    readonly phase: SessionImportPhase;
+    readonly retryable: boolean;
+    readonly limitBytes?: number;
+    readonly observedBytes?: number;
+    constructor(code: SessionImportErrorCode, phase: SessionImportPhase, message: string, options?: {
+        retryable?: boolean;
+        limitBytes?: number;
+        observedBytes?: number;
+    });
+}
+/** One record the adapter could not map. Never carries raw content. */
+export interface ImportQuarantineRecord {
+    /** 1-based record/line number in the source. */
+    record: number;
+    byteLength: number;
+    sha256: string;
+    reason: "invalid_json" | "unknown_record" | "missing_fields" | "oversized_record";
+}
+/** Bounded tallies reported to the user and persisted in provenance. */
+export interface SessionImportCounts {
+    /** Records successfully mapped into the normalized conversation. */
+    mapped: number;
+    /** Records quarantined (never silently dropped). */
+    quarantined: number;
+    /** Secret/credential redactions applied to imported text. */
+    redacted: number;
+    /** Messages omitted from the rendered context by head/tail bounding. */
+    omitted: number;
+}
+/** Provenance persisted as a `custom` session entry on the import target. */
+export interface SessionImportProvenance {
+    schemaVersion: 1;
+    customType: "session-import";
+    provider: SessionImportProviderId;
+    format: SessionImportFormatId;
+    /** Basename of the explicit user-selected source file (never a full path). */
+    sourceFileName: string;
+    sourceSessionId?: string;
+    sourceTitle?: string;
+    /** SHA-256 over the exact source bytes that were imported. */
+    sourceSha256: string;
+    sourceBytes: number;
+    /** RFC 4122 UUID of the SKC session that received the import. */
+    targetSessionId: string;
+    importedAt: string;
+    converterVersion: number;
+    sanitizerVersion: number;
+    counts: SessionImportCounts;
+    /** True when head/tail bounding elided part of the conversation. */
+    truncated: boolean;
+    quarantine: {
+        present: boolean;
+        truncated: boolean;
+    };
+}
+/** Fully prepared import: parsed, normalized, redacted, bounded. No session state mutated yet. */
+export interface PreparedSessionImport {
+    conversation: ImportedConversation;
+    /** Rendered continuation context for the `custom_message` entry. */
+    contextText: string;
+    provenance: Omit<SessionImportProvenance, "targetSessionId" | "importedAt">;
+    counts: SessionImportCounts;
+    /** Distinct redaction pattern ids that fired (for the user-facing summary). */
+    redactionKinds: string[];
+    /** Bounded digest-only records for durable quarantine metadata. */
+    quarantineRecords: ImportQuarantineRecord[];
+    sourceSha256: string;
+    sourceBytes: number;
+}
+/** Result of a completed or idempotently reused imported session. */
+export interface SessionImportCompleted {
+    targetSessionId: string;
+    targetPath: string;
+    title: string;
+    prepared: PreparedSessionImport;
+    /** True when the same source/version import already existed in this workspace. */
+    reused: boolean;
+}

package/dist/types/skc-runtime/launch-worktree.d.ts

@@ -20,6 +20,9 @@ export interface SkcLaunchWorktreePlan {
     detached: boolean;
     baseRef: string;
     branchName: string | null;
+    sourceCheckoutRoot: string;
+    relativeCwd: string;
+    relativeDependencyRoot: string | null;
 }
 export interface SkcLaunchWorktreeResult extends SkcLaunchWorktreePlan {
     created: boolean;
@@ -36,7 +39,19 @@ export declare function ensureLaunchWorktree(plan: SkcLaunchWorktreePlan | {
 }): SkcLaunchWorktreeResult | {
     enabled: false;
 };
-export declare function ensureReusableNodeModules(sourceRoot: string, worktreePath: string): "symlink" | "present" | "missing";
+type WorktreePackageManager = "bun" | "npm" | "pnpm";
+interface WorktreeDependencyProbes {
+    isExecutableAvailable?: (name: Exclude<WorktreePackageManager, "bun">) => boolean;
+    version?: (name: WorktreePackageManager) => string;
+    spawnInstall?: (command: readonly string[], cwd: string) => {
+        exitCode: number;
+        stderr: string;
+    };
+}
+/** Package worktrees own their complete lockfile-resolved dependency graph. */
+export declare function ensureReusableNodeModules(sourceRoot: string, worktreePath: string, probes?: WorktreeDependencyProbes): "symlink" | "present" | "missing";
+export declare function launchWorktreeCwd(plan: SkcLaunchWorktreePlan): string;
+export declare function ensureLaunchWorktreeDependencies(plan: SkcLaunchWorktreePlan): "symlink" | "present" | "missing";
 /** Result of {@link prepareLaunchWorktree}: the effective working directory, remaining args, and resolved worktree plan. */
 export interface PreparedLaunchWorktree {
     cwd: string;
@@ -46,3 +61,4 @@ export interface PreparedLaunchWorktree {
     };
 }
 export declare function prepareLaunchWorktree(cwd: string, args: string[]): PreparedLaunchWorktree;
+export {};

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/system-prompt.d.ts

@@ -83,6 +83,11 @@ export interface BuildSystemPromptOptions {
     alwaysApplyRules?: AlwaysApplyRule[];
     /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
     secretsEnabled?: boolean;
+    /**
+     * Reason through technical work in English while answering in the language the
+     * user used. Affects prompt guidance only. Default: "off".
+     */
+    reasoningLanguage?: "off" | "english";
     /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
     workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
     /**

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

@@ -250,6 +250,11 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
         }, 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/dist/types/utils/mupdf-wasm.d.ts

@@ -0,0 +1 @@
+export declare function ensureMupdfWasmResolution(): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.5.2",
+	"version": "0.5.8",
 	"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.2",
-		"@sayknow-cli/agent-core": "0.5.2",
-		"@sayknow-cli/ai": "0.5.2",
-		"@sayknow-cli/natives": "0.5.2",
-		"@sayknow-cli/tui": "0.5.2",
-		"@sayknow-cli/utils": "0.5.2",
+		"@sayknow-cli/stats": "0.5.8",
+		"@sayknow-cli/agent-core": "0.5.8",
+		"@sayknow-cli/ai": "0.5.8",
+		"@sayknow-cli/natives": "0.5.8",
+		"@sayknow-cli/tui": "0.5.8",
+		"@sayknow-cli/utils": "0.5.8",
 		"@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": {

package/scripts/compile-args.ts

@@ -18,7 +18,14 @@ const compiledDefineFlags = ['process.env.PI_COMPILED="true"'];
 const releaseDefineFlags = [...compiledDefineFlags, 'process.env.SKC_BUILD_CHANNEL="release"'];
 const devDefineFlags = [...compiledDefineFlags, 'process.env.SKC_BUILD_CHANNEL="dev"'];
 
-export const compiledExternalPackages = ["mupdf"];
+// NOTE: mupdf must NOT be marked --external here. Compiled binaries cannot
+// resolve bare "mupdf" imports (and its Emscripten loader cannot find the
+// wasm asset inside the bunfs), which broke markit PDF conversion in every
+// standalone release (upstream #5433). mupdf is bundled instead: its wasm is
+// embedded via `with { type: "file" }` and routed to the loader through the
+// hook in packages/coding-agent/src/utils/mupdf-wasm.ts, and the bundled
+// `require("mupdf")` inside markit-ai is replaced by the patch in
+// patches/markit-ai@0.5.3.patch.
 
 export const releaseEntrypoints = [
 	"./packages/coding-agent/src/cli.ts",
@@ -57,8 +64,6 @@ export function buildReleaseCompileArgs(target: string, outfile: string): string
 		outfile,
 		target,
 		defines: releaseDefineFlags,
-
-		externals: compiledExternalPackages,
 	});
 }
 
@@ -68,7 +73,6 @@ export function buildDevCompileArgs(outfile = "dist/skc"): string[] {
 		entrypoints: devEntrypoints,
 		outfile,
 		defines: devDefineFlags,
-		externals: compiledExternalPackages,
 	});
 }
 

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();

package/src/cli/config-cli.ts

@@ -88,6 +88,10 @@ function redactConfigValue(path: string, value: unknown, showSecrets?: boolean):
 	}
 	return REDACTED_SECRET_VALUE;
 }
+function reportConfigPersistenceFailure(): never {
+	console.error(chalk.red("Failed to persist configuration."));
+	process.exit(1);
+}
 
 /** Find setting definition by path */
 function findSettingDef(path: string): CliSettingDef | undefined {
@@ -223,25 +227,25 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 			const lower = trimmed.toLowerCase();
 			if (["true", "1", "yes", "on"].includes(lower)) parsedValue = true;
 			else if (["false", "0", "no", "off"].includes(lower)) parsedValue = false;
-			else throw new Error(`Invalid boolean value: ${rawValue}. Use true/false, yes/no, on/off, or 1/0`);
+			else throw new Error("Invalid boolean value. Use true/false, yes/no, on/off, or 1/0");
 			break;
 		}
 		case "number": {
 			parsedValue = Number(trimmed);
-			if (!Number.isFinite(parsedValue)) throw new Error(`Invalid number: ${rawValue}`);
+			if (!Number.isFinite(parsedValue)) throw new Error("Invalid number");
 			const validate =
 				"validate" in SETTINGS_SCHEMA[path]
 					? (SETTINGS_SCHEMA[path].validate as ((value: number) => boolean) | undefined)
 					: undefined;
 			if (validate?.(parsedValue as number) === false) {
-				throw new Error(`Invalid number for ${path}: ${rawValue}`);
+				throw new Error(`Invalid number for ${path}`);
 			}
 			break;
 		}
 		case "enum": {
 			const valid = getEnumValues(path);
 			if (valid && !valid.includes(trimmed)) {
-				throw new Error(`Invalid value: ${rawValue}. Valid values: ${valid.join(", ")}`);
+				throw new Error(`Invalid value. Valid values: ${valid.join(", ")}`);
 			}
 			parsedValue = trimmed;
 			break;
@@ -251,10 +255,10 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 			try {
 				parsed = JSON.parse(trimmed);
 			} catch {
-				throw new Error(`Invalid array JSON: ${rawValue}`);
+				throw new Error("Invalid array JSON");
 			}
 			if (!Array.isArray(parsed)) {
-				throw new Error(`Invalid array JSON: ${rawValue}`);
+				throw new Error("Invalid array JSON");
 			}
 			parsedValue = parsed;
 			break;
@@ -264,10 +268,10 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 			try {
 				parsed = JSON.parse(trimmed);
 			} catch {
-				throw new Error(`Invalid record JSON: ${rawValue}`);
+				throw new Error("Invalid record JSON");
 			}
 			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-				throw new Error(`Invalid record JSON: ${rawValue}`);
+				throw new Error("Invalid record JSON");
 			}
 			parsedValue = parsed;
 			break;
@@ -408,6 +412,11 @@ async function handleSet(
 		console.error(chalk.red(String(err)));
 		process.exit(1);
 	}
+	try {
+		await settings.flushOrThrow();
+	} catch {
+		reportConfigPersistenceFailure();
+	}
 
 	const newValue = settings.get(def.path);
 	const displayValue = redactConfigValue(def.path, newValue, flags.showSecrets);
@@ -438,6 +447,12 @@ async function handleReset(key: string | undefined, flags: { json?: boolean }):
 	if (defaultValue === undefined) settings.unset(path);
 	else settings.set(path, defaultValue as SettingValue<typeof path>);
 
+	try {
+		await settings.flushOrThrow();
+	} catch {
+		reportConfigPersistenceFailure();
+	}
+
 	if (flags.json) {
 		console.log(JSON.stringify({ key: def.path, value: defaultValue }));
 	} else {