@sayknow-cli/coding-agent 0.6.5 → 0.6.7

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.6.7] - 2026-09-28
+
+### Added
+
+- Launch card sessions open from the card: press `↓` in the empty composer to highlight a recent session, `↑`/`↓` to move, `Enter` to open it (`Esc` returns to typing), or click it. Until the first prompt SKC captures the mouse so the click reaches the card, then hands it back to the terminal; `startup.welcomeMouse` (Settings → Interaction → Clickable Launch Card) turns that off.
+- `locate` tool: find code by describing what it does. Jev (TypeSafe) judges relevance while walking the tree: large folders are split and only plausible subfolders are entered, then candidate files are ranked from their outlines. Only folder paths, file names and declaration lines are sent (no bodies, comments, imports or literal values; initialisers are cut). Offered only when a TypeSafe key is stored; `locate.enabled` turns it off. The six best files are then compared in one question to settle their order. A local keyword score over each file's full text (read on this machine, never sent) is blended in. On 154 held-out commit questions from 8 public repositories (Python, TypeScript, Go, Rust), an answer file ranked first 51% of the time, in the top five 78% and in the top ten 86%, against 27%, 58% and 69% for keyword grep; a search returns about 5 KB. Block comments, docstrings, multi-line strings, trailing comments and string-literal lines are kept out of what is sent. See `docs/tools/locate.md`.
+- Automatic model fallback. When the default model is blocked — no credentials, quota, auth or server errors — the session now continues on a model from another provider you are logged in to instead of stopping. The chain is the configured default (a single model or a `modelRoles` array), then `fallback.models`, then one model per other logged-in provider (the one you used most recently there, else the provider's curated default; up to three). A missing login is skipped before any request; failures during a turn retry `fallback.maxAttempts` times, rotate to the provider's next logged-in account, then move on, and the status line shows each switch. Automatic picks are never added under an `enabledModels` allow-list, for keyless local providers, for an explicit `--model`, or for subagent chains, and they are not written into the session's configured chain. Turn it off with `fallback.auto` (Settings → Model → Automatic Model Fallback).
+- `/fallback` shows the chain the next prompt walks — where each model came from (`default`, `chain`, `added`, `auto`) and which is in use — and edits it: `/fallback add <model>`, `remove <n|model>`, `clear`, `auto on|off`. Added models are kept when you pick another default in `/model`.
+- Settings → Providers → **Multi-Account Order** (`auth.credentialRankingMode`: `balanced` or `earliest-reset`) chooses which logged-in account of a provider a new session uses; it applies immediately. The existing `SKC_CREDENTIAL_RANKING_MODE` env var still overrides it per machine. Settings → Model also shows **Fallback Attempts per Model** (`fallback.maxAttempts`).
+
+### Fixed
+
+- Answers no longer drift into English after long tool work. The system prompt now always carries a reply-language rule (the language the user writes in, or the one they asked for, for the whole turn including the final report; English tool output, logs, skills and summaries never change it); `reasoningLanguage: english` only changes reasoning. When a message is clearly written in a non-Latin script (Korean, Japanese, Chinese, Russian, Arabic, Hebrew, Thai, Hindi, Greek), the turn starts with a one-line reminder naming that language. Code blocks, inline code, quotes and links are ignored when detecting it, so a pasted English log with one Korean word does not count. Compaction and handoff summaries now record the reply language, so it survives a context compaction.
+- Typed decisions (Jev) kept failing with 401 in every session that was already open when the TypeSafe key was replaced, because a session reads stored credentials once at startup and kept sending the revoked key; routing then fell back to an uncalibrated model. On 401/403 the TypeSafe backend now reloads stored credentials and retries once if the key changed; an unchanged key is not retried.
+- SDK background processes no longer live forever. A broker now stops after 30 minutes with no client connection, no request in flight and no live session host (the next client starts a fresh one; chat daemons now start one when the discovery file is missing). A session host stops once its ownership marker or worktree has been gone for three checks in a row. A broker or host run from TypeScript source kills itself as soon as its entry script disappears, so ejecting the drive that holds a checkout no longer leaves a process spinning at 100% CPU in Bun's fault handler on the unmapped native addon. Found after brokers and hosts left behind by SDK tests stayed up for two days and one pinned a core when the external drive disconnected.
+- A missing-credential error no longer opens with "For MiniMax/GLM presets…" whatever provider was called. It names the provider that lacks credentials and its `/login <provider>` (or env var) first, then lists other ways to add a provider. Preset lists in these messages, `/provider`, and `skc setup provider` come from the bundled preset catalog instead of a hand-kept `minimax|minimax-cn|glm`, so `alibaba-token-plan` is no longer missing from them.
+
+## [0.6.6] - 2026-09-28
+
+### Added
+
+- `ctrl+q` (`app.session.continue`) continues the most recent saved session in one keystroke, from the launch card or mid-session; it never resumes the live session into itself and refuses while a turn is running. The launch card marks that session with `›` and names the key next to `alt+r` for the full list. It is a Control chord on purpose: many macOS terminals turn Option into composed text, so Option shortcuts such as `alt+r` only work where the terminal sends Option as Meta.
+
+### Changed
+
+- Launch card redesign: the SAYKNOW CLI wordmark with a small version of the pet (8×4, drawn for the size) beside it, tagline and version under the wordmark, model and project/branch aligned in the same column (the place moves to its own row instead of being cut off). The release line and the recent-sessions heading are rule headers (`label ──── hints`) that divide the card, and the keys row uses accent keys with `·` separators.
+- The composer's input rows sit on a background band (`userMessageBg`) with the rail, so the line being typed is distinct from the transcript.
+- The launch screen is a compact card instead of the two-column ledger. The Sayknow pet — the same octopus sprite as the composer pet, drawn in half blocks so it needs no image protocol — sits beside four lines — version, tagline, model with reasoning level, and project path with branch and change counts — followed by one line after an update with the new version and its first note (pointing at `/changelog`), the three most recent sessions (with the key that opens the full list), and a single row of keys. Commits, preset, role models, MCP/skill/rule/LSP status, workflows, and the full keymap are no longer on it; they are one key or command away. The card stays within 76 columns on wide terminals and, when rows run short, drops the keys row first, then the release line, then the sessions. The pet is the one you keep beside the composer (`pet.mode`), or, with the pet off, blue on `blue-octopus` and red elsewhere. The intro has the pet sway its tentacles and lets color spread for about half a second; every fact is readable from the first frame, and `startup.skipLogoAnimation` still turns it off.
+
 ## [0.6.5] - 2026-09-26
 
 ### Added

package/dist/types/config/keybindings.d.ts

@@ -30,6 +30,7 @@ interface AppKeybindings {
     "app.session.tree": true;
     "app.session.fork": true;
     "app.session.resume": true;
+    "app.session.continue": true;
     "app.session.observe": true;
     "app.session.dashboard": true;
     "app.jobs.open": true;
@@ -167,6 +168,10 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: "alt+r";
         readonly description: "Resume session";
     };
+    readonly "app.session.continue": {
+        readonly defaultKeys: "ctrl+q";
+        readonly description: "Continue the most recent session";
+    };
     readonly "app.session.observe": {
         readonly defaultKeys: "ctrl+s";
         readonly description: "Observe subagent sessions";

package/dist/types/config/settings-schema.d.ts

@@ -1456,6 +1456,43 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "number";
         readonly default: 3;
         readonly validate: (value: number) => boolean;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Fallback Attempts per Model";
+            readonly description: "Tries on each model in the fallback chain (including the first) before moving to the next one. Missing credentials skip a model immediately.";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "1 try";
+            }, {
+                readonly value: "2";
+                readonly label: "2 tries";
+            }, {
+                readonly value: "3";
+                readonly label: "3 tries";
+            }, {
+                readonly value: "5";
+                readonly label: "5 tries";
+            }];
+        };
+    };
+    /**
+     * When the default model is blocked, keep going on another logged-in provider
+     * after the configured chain and `fallback.models` run out. The extra entries
+     * are computed per session and never written into the configured chain.
+     */
+    readonly "fallback.auto": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Automatic Model Fallback";
+            readonly description: "When the default model is blocked (no login, quota, auth or server errors), continue on a model from another logged-in provider. /fallback shows the chain.";
+        };
+    };
+    /** Models to try, in order, after the default chain. Edited with `/fallback`. */
+    readonly "fallback.models": {
+        readonly type: "array";
+        readonly default: string[];
     };
     readonly "retry.enabled": {
         readonly type: "boolean";
@@ -1691,6 +1728,15 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "startup.welcomeMouse": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Clickable Launch Card";
+            readonly description: "Until the first prompt, capture the mouse so a recent session on the launch card opens with one click. Terminal text selection needs Shift held meanwhile. Off: open sessions with ↓ and Enter.";
+        };
+    };
     readonly "startup.skipLogoAnimation": {
         readonly type: "boolean";
         readonly default: false;
@@ -3587,6 +3633,20 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Hide non-essential built-in tools behind a search tool to save tokens.";
         };
     };
+    /**
+     * The `locate` tool: find code by describing what it does, judged by Jev. Offered only
+     * when a TypeSafe key is stored. Sends folder paths, file names and declaration lines
+     * (never bodies or comments) to TypeSafe.
+     */
+    readonly "locate.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Locate (Jev code search)";
+            readonly description: "Offer the locate tool when a TypeSafe key is stored. It sends folder paths, file names and declaration lines (no function bodies or comments) to TypeSafe to judge relevance.";
+        };
+    };
     readonly "tools.essentialOverride": {
         readonly type: "array";
         readonly default: string[];
@@ -4002,6 +4062,25 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "boolean";
         readonly default: false;
     };
+    readonly "auth.credentialRankingMode": {
+        readonly type: "enum";
+        readonly values: readonly ["balanced", "earliest-reset"];
+        readonly default: "balanced";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Multi-Account Order";
+            readonly description: "Which logged-in account of a provider a new session uses. A blocked or exhausted account is always skipped for the next one.";
+            readonly options: readonly [{
+                readonly value: "balanced";
+                readonly label: "Balanced";
+                readonly description: "Least-used account first; spreads load and keeps headroom on every account";
+            }, {
+                readonly value: "earliest-reset";
+                readonly label: "Earliest reset";
+                readonly description: "Account whose usage window resets soonest first, so quota is not lost at reset";
+            }];
+        };
+    };
     readonly "secrets.enabled": {
         readonly type: "boolean";
         readonly default: false;

package/dist/types/i18n/messages/en.d.ts

@@ -8,41 +8,18 @@ export declare const en: {
     readonly "lang.fr": "Français";
     readonly "lang.de": "Deutsch";
     readonly "welcome.tagline": "Coding should feel like thinking.";
-    readonly "welcome.workflows": "Workflows";
-    readonly "welcome.wf.deepInterview": "scope · interview → spec";
-    readonly "welcome.wf.ralplan": "consensus plan";
-    readonly "welcome.wf.ultragoal": "autonomous build";
-    readonly "welcome.wf.team": "parallel agents";
-    readonly "welcome.flowKeys": "Flow keys";
     readonly "welcome.commands": "commands";
-    readonly "welcome.actions": "actions";
-    readonly "welcome.shell": "shell";
-    readonly "welcome.python": "python";
     readonly "welcome.keymap": "keymap";
     readonly "welcome.model": "model";
-    readonly "welcome.reasoning": "reasoning";
-    readonly "welcome.projectPulse": "Project pulse";
-    readonly "welcome.noLsp": "No LSP servers";
-    readonly "welcome.sessionTrail": "Session trail";
-    readonly "welcome.noSessions": "No saved trails";
+    readonly "welcome.sessionTrail": "Recent sessions";
+    readonly "welcome.noSessions": "No saved sessions";
     readonly "welcome.allSessions": "{key} all sessions";
+    readonly "welcome.continue": "{key} continue";
+    readonly "welcome.pick": "{key} pick";
+    readonly "welcome.pickActive": "↑↓ move · ⏎ open · esc back";
+    readonly "welcome.sessions": "sessions";
     readonly "welcome.chooseModel": "choose a model";
     readonly "welcome.modelHint": "ctrl+l to pick · / for commands";
-    readonly "welcome.label.workspace": "workspace";
-    readonly "welcome.label.branch": "branch";
-    readonly "welcome.label.commits": "commits";
-    readonly "welcome.label.model": "model";
-    readonly "welcome.label.reasoning": "reasoning";
-    readonly "welcome.label.preset": "preset";
-    readonly "welcome.label.roles": "roles";
-    readonly "welcome.label.tools": "tools";
-    readonly "welcome.noGit": "not a git repository";
-    readonly "welcome.rolesInherit": "roles follow the default model";
-    readonly "welcome.skills": "skills";
-    readonly "welcome.rules": "rules";
-    readonly "welcome.clean": "clean";
-    readonly "welcome.whatsNew": "What's new";
-    readonly "welcome.readyPrompt": "Ready for your next prompt";
     readonly "settings.tab.appearance": "Appearance";
     readonly "settings.tab.model": "Model";
     readonly "settings.tab.interaction": "Interaction";

package/dist/types/modes/components/welcome.d.ts

@@ -1,23 +1,15 @@
 import type { ThinkingLevel } from "@sayknow-cli/agent-core";
-import { type Component } from "@sayknow-cli/tui";
+import { type Component, type PetSkinId } from "@sayknow-cli/tui";
 import { type KeyDisplayContext } from "../../config/keybindings";
 export interface RecentSession {
     name: string;
     timeAgo: string;
-}
-export interface LspServerInfo {
-    name: string;
-    status: "idle" | "ready" | "error" | "connecting";
-    fileTypes: string[];
-}
-export interface WelcomeRoleBinding {
-    role: string;
-    model: string;
+    /** Session file; present when the row can be opened from the card. */
+    path?: string;
 }
 /**
- * Workspace and runtime facts shown in the launch ledger. Every field is
- * optional: the ledger renders what is known and fills the rest in as the
- * asynchronous probes (git status, context files, MCP) settle.
+ * Workspace facts on the launch card. Every field is optional: the card renders
+ * what is known and fills in git state once the asynchronous probe settles.
  */
 export interface WelcomeSnapshot {
     /** Display path of the project directory (already home-shortened). */
@@ -29,19 +21,7 @@ export interface WelcomeSnapshot {
         unstaged: number;
         untracked: number;
     } | null;
-    /** Latest commits as `<short-sha> <subject>` onelines, newest first. */
-    recentCommits?: readonly string[];
     thinkingLevel?: ThinkingLevel | string;
-    /** Display name of the active model preset. */
-    profile?: string;
-    roles?: readonly WelcomeRoleBinding[];
-    mcp?: {
-        connected: number;
-        total: number;
-    };
-    skills?: number;
-    /** Display names of the loaded project instruction files (AGENTS.md, …). */
-    contextFiles?: readonly string[];
 }
 export type WelcomeLogoMode = "unicode" | "square" | "ascii";
 export interface WelcomeComponentOptions {
@@ -49,21 +29,26 @@ export interface WelcomeComponentOptions {
     getReservedBottomRows?: (termWidth: number) => number;
     changelogMarkdown?: string;
     rightGutterWidth?: number;
+    /** Show only the version on the release line, without its first note. */
     collapseChangelog?: boolean;
     buildLabel?: string;
     keyDisplayContext?: KeyDisplayContext;
     skipLogoAnimation?: boolean;
     snapshot?: WelcomeSnapshot;
-    /** Key bound to the resume picker (`app.session.resume`); the sessions heading names it. */
+    /** Key bound to the resume picker (`app.session.resume`); the card names it. */
     resumeKey?: string;
+    /** Key bound to `app.session.continue`, which resumes the first session on the card. */
+    continueKey?: string;
+    /** Which Sayknow pet stands on the card (default red). */
+    petSkin?: PetSkinId;
+    /** Called when a session row is opened by click or Enter. */
+    onOpenSession?: (session: RecentSession) => void;
 }
 /**
- * Sayknow-CLI launch surface: an open, borderless ledger. The left column is
- * the state of this workspace — path, branch, model, reasoning, preset, role
- * agents, tooling — so the first screen answers "what am I about to run with".
- * The right column carries activity: what changed, recent sessions, workflows
- * and keys. No enclosing box and no hero wordmark: the octopus mark and the
- * facts carry the identity.
+ * Sayknow-CLI launch card: the wordmark with the pet beside it, who and where you are
+ * (version, model and reasoning, project and branch), the release line after an update,
+ * the three most recent sessions — which can be opened from the card with a click or
+ * ↓ then Enter — and a single row of keys.
  */
 export declare class WelcomeComponent implements Component {
     #private;
@@ -71,24 +56,33 @@ export declare class WelcomeComponent implements Component {
     private modelName;
     private providerName;
     private recentSessions;
-    private lspServers;
     private readonly logoMode;
     private readonly options;
-    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[], logoMode?: WelcomeLogoMode, options?: WelcomeComponentOptions);
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], logoMode?: WelcomeLogoMode, options?: WelcomeComponentOptions);
     invalidate(): void;
     /**
-     * Play a short one-shot reveal: sections appear top to bottom a few frames
-     * apart, each settling from dim into its colors. Launch happens once per
-     * session, so a sub-second reveal is affordable; it never blocks input.
-     * Safe to call multiple times — subsequent calls reset and replay.
+     * Play the short launch intro. Content is fully readable from the first frame;
+     * only color and the tentacles move. Safe to call again — it restarts.
      */
     playIntro(requestRender: () => void): void;
     dispose(): void;
     setModel(modelName: string, providerName: string): void;
     setRecentSessions(sessions: RecentSession[]): void;
-    setLspServers(servers: LspServerInfo[]): void;
-    /** Merge newly probed workspace facts into the ledger. */
+    /** Merge newly probed workspace facts into the card. */
     setSnapshot(patch: WelcomeSnapshot): void;
+    /** Rows that can be opened right now. Zero once the card stops taking input. */
+    get openableCount(): number;
+    get selectedIndex(): number | undefined;
+    /** Stop offering the session rows (after the first prompt or a session switch). */
+    endInteraction(): void;
+    get interactive(): boolean;
+    /** Highlight a row, or clear the highlight with undefined. Returns false when there is nothing to select. */
+    select(index: number | undefined): boolean;
+    /** Move the highlight; returns false when it would leave the list upward (the caller hands focus back). */
+    moveSelection(delta: number): boolean;
+    /** Open the highlighted row. */
+    openSelected(): boolean;
+    handleClick(line: number): boolean;
     render(termWidth: number): string[];
 }
 /** Resolve the intro cadence without making tests mutate global process state. */

package/dist/types/modes/interactive-mode.d.ts

@@ -22,7 +22,7 @@ import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
-import { type PetMode, SayknowPetWidget } from "./components/sayknow-pet-widget";
+import { type PetMode, type PetSkinId, SayknowPetWidget } from "./components/sayknow-pet-widget";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { StatusLineComponent } from "./components/tool-status-header";
 import { type WelcomeLogoMode } from "./components/welcome";
@@ -42,10 +42,10 @@ export declare function getComposerPlaceholder(keybindings: Pick<KeybindingsMana
 }): string;
 export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 /**
- * The composer is an open rail, not a box: every input row starts with the same
- * rail glyph a submitted prompt keeps in the transcript, colored by the editor's
- * border color (session accent, thinking level, shell/python mode).
+ * The pet on the launch card: the one the user keeps beside the composer, or —
+ * with the pet off — the skin that matches the theme (blue for blue-octopus).
  */
+export declare function resolveWelcomePetSkin(petMode: PetMode, themeName: string | undefined): PetSkinId;
 export declare function configureDefaultComposerChrome(editor: CustomEditor): void;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
@@ -276,6 +276,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showUserMessageSelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
+    /** The card stops taking input: first prompt sent, a session opened, or the UI rebuilt. */
+    endWelcomeInteraction(): void;
+    continueRecentSession(): Promise<void>;
     handleResumeSession(sessionPath: string, options?: {
         requireIdle?: boolean;
     }): Promise<boolean>;

package/dist/types/modes/types.d.ts

@@ -286,6 +286,10 @@ export interface InteractiveModeContext {
     showUserMessageSelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
+    /** Resume the most recent saved session other than this one (the launch card's first row). */
+    continueRecentSession(): Promise<void>;
+    /** The launch card stops taking ↓/Enter/clicks and releases mouse capture (first prompt sent). */
+    endWelcomeInteraction?(): void;
     showSessionsDashboard(): void;
     handleResumeSession(sessionPath: string, options?: {
         requireIdle?: boolean;

package/dist/types/sdk/broker/broker.d.ts

@@ -9,6 +9,18 @@ export interface BrokerSettings {
     packageGeneration?: string;
     port?: number;
     heartbeatTtlMs?: number;
+    /**
+     * Stop after this long with no connection, no request in flight and no live
+     * session. Clients call `ensureBroker` before use, so the next one starts a fresh
+     * broker. 0 disables. Default {@link BROKER_IDLE_SHUTDOWN_MS}.
+     */
+    idleShutdownMs?: number;
+    /**
+     * Runs at the start of every publication tick, before the tick calls into the
+     * native addon. The broker process uses it to stop at once when its source
+     * checkout has vanished (see `process-guard.ts`); return true to skip the tick.
+     */
+    beforePublicationTick?: () => boolean;
     /** Broker-owned migration policy. Client lifecycle frames cannot select it. */
     resolveDirectoryMigration?: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 }
@@ -17,6 +29,8 @@ type ResolvedBrokerSettings = {
     packageGeneration: string;
     port: number;
     heartbeatTtlMs: number;
+    idleShutdownMs: number;
+    beforePublicationTick: () => boolean;
     resolveDirectoryMigration: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 };
 export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
@@ -102,6 +116,12 @@ export type BrokerResponse = {
     durableEffects?: LifecycleDurableEffectsReceipt;
     startupFailure?: LifecycleStartupFailureReceipt;
 };
+/**
+ * A broker with nothing to serve stops after this long. Without it a broker lived
+ * until killed: one started by a test (or a crashed client) whose caller never came
+ * back stayed up for days holding a port, memory and a mapped native addon.
+ */
+export declare const BROKER_IDLE_SHUTDOWN_MS: number;
 export declare class Broker {
     #private;
     readonly settings: ResolvedBrokerSettings;
@@ -113,6 +133,8 @@ export declare class Broker {
     get ownsDiscovery(): boolean;
     get completion(): Promise<void>;
     status(): RedactedBrokerDiscovery | null;
+    /** Record client activity; an active broker never idles out. */
+    noteActivity(): void;
     heartbeat(): Promise<void>;
     stop(): Promise<void>;
     handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<BrokerResponse>;

package/dist/types/sdk/broker/process-guard.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Guards for the SDK's long-lived background processes (`sdk broker-internal`,
+ * `sdk session-host-internal`). They are spawned detached and outlive whoever
+ * started them, so each one has to notice on its own when it has no reason, or no
+ * way, to keep running.
+ */
+/** How often the guards run. Cheap: one `stat`, plus a small JSON read for hosts. */
+export declare const PROCESS_GUARD_INTERVAL_MS = 5000;
+/**
+ * The entry script of a process run from source (`bun …/src/cli.ts sdk …`), or
+ * undefined for a compiled binary, whose entry lives in Bun's virtual filesystem
+ * and cannot disappear from under it.
+ */
+export declare function sourceEntryPath(main?: string | undefined): string | undefined;
+/** Whether the source entry is still reachable. A compiled binary (no entry) always is. */
+export declare function sourceEntryAvailable(entry: string | undefined, stat?: (file: string) => unknown): boolean;
+/**
+ * End this process at once when the source it runs from has vanished — typically
+ * an external drive with the checkout was unplugged. The native addon is mapped
+ * from that checkout and paged in lazily, so the next call into it faults on a
+ * page that can no longer be read, and Bun's fault handler then spins on the same
+ * unreadable mapping at 100% CPU forever. No cleanup is safe at that point (it
+ * would call into the same addon), so the process kills itself; readers already
+ * treat its discovery and markers as stale once the pid is gone.
+ *
+ * Call this before any native call in a periodic task. Returns true if it fired.
+ */
+export declare function exitIfSourceGone(entry?: string | undefined, options?: {
+    stat?: (file: string) => unknown;
+    kill?: () => void;
+}): boolean;
+/** What a session host needs to recognise that its session is still its own. */
+export interface SessionHostAuthority {
+    /** `<stateRoot>/sdk/<sessionId>.lifecycle.json`, written once by the broker when it spawned this host. */
+    markerPath: string;
+    pid: number;
+    effectMarker: string;
+    incarnation: string;
+    /** The host's worktree. */
+    cwd: string;
+}
+/**
+ * `held`: the marker still names this process and the worktree exists. `lost`: the
+ * marker or worktree is gone, or the marker names another process — the session was
+ * deleted, taken over, or its whole state root was removed (a finished test). `unknown`:
+ * something could not be read for another reason; that is not evidence either way.
+ */
+export type SessionHostAuthorityState = "held" | "lost" | "unknown";
+export declare function checkSessionHostAuthority(authority: SessionHostAuthority, io?: {
+    readFile?: (file: string) => string;
+    stat?: (file: string) => unknown;
+}): SessionHostAuthorityState;
+/** Consecutive `lost` checks before a host gives up its session (≈15s at the default interval). */
+export declare const SESSION_HOST_LOST_CHECKS = 3;
+/**
+ * Watch a running session host. It stops (through `onLost`, the host's normal
+ * shutdown) once its ownership marker or worktree has been gone for
+ * {@link SESSION_HOST_LOST_CHECKS} checks in a row, and kills itself at once if the
+ * source checkout it runs from disappears. Before this, a host whose session state
+ * had been deleted kept running until someone killed it — for days, after tests.
+ * Returns a function that stops the watch.
+ */
+export declare function startSessionHostGuard(options: SessionHostAuthority & {
+    onLost: () => void;
+    intervalMs?: number;
+    lostChecks?: number;
+    check?: (authority: SessionHostAuthority) => SessionHostAuthorityState;
+    sourceGuard?: () => boolean;
+    setInterval?: typeof setInterval;
+    clearInterval?: typeof clearInterval;
+}): () => void;

package/dist/types/sdk/broker/transport.d.ts

@@ -3,6 +3,8 @@ import type { Broker } from "./broker";
 export declare class BrokerTransport {
     #private;
     constructor(broker: Broker, token: string, port?: number);
+    /** Client WebSockets currently open. The broker does not idle out while any is. */
+    get openConnections(): number;
     get port(): number;
     start(): Promise<number>;
     stop(): Promise<void>;

package/dist/types/sdk/bus/chat-daemon-runtime.d.ts

@@ -46,6 +46,10 @@ export interface ChatDaemonRuntimeDeps {
         url: string;
         token: string;
     }) => Promise<ChatDaemonSdkClient>;
+    /** Starts the agent broker when none is running (default: `ensureBroker`). */
+    ensureBroker?: (settings: {
+        agentDir: string;
+    }) => Promise<unknown>;
     onReconciled?: () => void;
     setInterval?: typeof setInterval;
     clearInterval?: typeof clearInterval;

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

@@ -1221,6 +1221,15 @@ export declare class AgentSession {
     setAutoCompactionEnabled(enabled: boolean): void;
     /** Whether auto-compaction is enabled */
     get autoCompactionEnabled(): boolean;
+    /**
+     * The default fallback chain the next prompt walks, automatic entries included,
+     * and the position currently in use.
+     */
+    getDefaultFallbackChain(): {
+        entries: readonly string[];
+        activeIndex: number;
+        appendedFrom: number;
+    };
     /**
      * Cancel in-progress retry.
      */

package/dist/types/session/auth-storage-discovery.d.ts

@@ -1,3 +1,4 @@
+import type { Settings } from "../config/settings";
 import { AuthStorage } from "./auth-storage";
 /**
  * Create an AuthStorage instance.
@@ -11,3 +12,17 @@ import { AuthStorage } from "./auth-storage";
  * override to re-mint access tokens when needed.
  */
 export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
+/**
+ * Per-machine multi-account ranking override from `SKC_CREDENTIAL_RANKING_MODE`.
+ * Unset/unknown → `undefined`, so the `auth.credentialRankingMode` setting (or
+ * {@link AuthStorage}'s `balanced` default) decides. `earliest-reset` switches to
+ * earliest-expiry-first selection so soon-to-reset tumbling-window quota is
+ * drained before it is lost.
+ */
+export declare function credentialRankingModeFromEnv(): "balanced" | "earliest-reset" | undefined;
+/**
+ * Apply the `auth.credentialRankingMode` setting to a credential store. The env
+ * var still wins, so a machine that pins a mode keeps it whatever config says.
+ * Returns the mode now in effect.
+ */
+export declare function applyCredentialRankingModeSetting(storage: Pick<AuthStorage, "setCredentialRankingMode">, settings: Pick<Settings, "get">): "balanced" | "earliest-reset";

package/dist/types/session/auto-fallback.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Model } from "@sayknow-cli/ai";
+/**
+ * How many other providers the automatic tail may add. Each entry can cost up to
+ * `fallback.maxAttempts` tries before the chain moves on, so the tail stays short.
+ */
+export declare const AUTO_FALLBACK_PROVIDER_LIMIT = 3;
+/** Provider of a `provider/model[:level]` selector, or undefined for bare aliases. */
+export declare function selectorProvider(selector: string): string | undefined;
+export interface AutoFallbackInput {
+    /** Models whose provider has auth configured (`ModelRegistry.getAvailable()`). */
+    available: readonly Model<Api>[];
+    /** True when the provider has a stored credential or API key (keyless local providers do not count). */
+    hasCredentials: (provider: string) => boolean;
+    /** Providers already in the chain; the tail adds a different provider or nothing. */
+    excludeProviders: ReadonlySet<string>;
+    /** Most-recently-used `provider/id` keys, newest first. */
+    usageOrder?: readonly string[];
+    limit?: number;
+}
+/**
+ * One model per other logged-in provider, for the automatic tail of the default
+ * fallback chain. Within a provider the model the user used most recently wins,
+ * then the provider's curated default; a provider with neither is skipped rather
+ * than guessed, because catalog order would land on an old model. Providers used
+ * recently come first, then the rest in curated-default order.
+ */
+export declare function autoFallbackSelectors(input: AutoFallbackInput): string[];

package/dist/types/session/fallback-chain-controller.d.ts

@@ -6,6 +6,11 @@ export interface ConfiguredFallbackChain {
     origin: string;
     identity?: string;
     explicitHead: boolean;
+    /**
+     * Index of the first entry appended at runtime after the configured intent
+     * (`fallback.models`, then automatic picks). Absent when nothing was appended.
+     */
+    appendedFrom?: number;
 }
 export interface FallbackFailure {
     selector: string;

package/dist/types/session/response-language.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which language to answer in, detected from the script of the user's message.
+ *
+ * Long tool-heavy turns drift into English: tool output, logs, skill text and context
+ * summaries are English, and the final report follows them. The system prompt states
+ * the rule once; this adds a one-line reminder at the start of each turn, naming the
+ * language, when the message is clearly written in a non-Latin script. Latin-script
+ * languages (English, Spanish, French, German, …) cannot be told apart by script alone,
+ * so they get no reminder and rely on the system prompt rule.
+ */
+export interface DetectedLanguage {
+    /** BCP 47 code. */
+    code: string;
+    /** English name, as used in the reminder. */
+    name: string;
+}
+/**
+ * The language of `text` when its prose is clearly in a non-Latin script, else
+ * undefined. "Clearly": at least two characters of the script, and — since one CJK
+ * character carries about a word — at least a quarter as many as Latin letters, so a
+ * pasted English log with one Korean word does not count.
+ */
+export declare function detectResponseLanguage(text: string): DetectedLanguage | undefined;
+/** The per-turn reminder for a detected language. */
+export declare function buildResponseLanguageReminder(language: DetectedLanguage): string;