@sayknow-cli/coding-agent 0.3.12 → 0.3.15

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

@@ -138,6 +138,10 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "boolean";
         readonly default: false;
     };
+    readonly "notifications.telegram.topics.nameTemplate": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
     readonly "notifications.discord.botToken": {
         readonly type: "string";
         readonly default: undefined;
@@ -163,6 +167,11 @@ export declare const SETTINGS_SCHEMA: {
         readonly default: "lean";
         readonly validate: (value: string) => value is "lean" | "verbose";
     };
+    readonly "notifications.sessionScope": {
+        readonly type: "string";
+        readonly default: "all";
+        readonly validate: (value: string) => value is "primary" | "all";
+    };
     readonly "notifications.daemon.idleTimeoutMs": {
         readonly type: "number";
         readonly default: 60000;
@@ -366,23 +375,23 @@ export declare const SETTINGS_SCHEMA: {
                 readonly description: "English";
             }, {
                 readonly value: "ko";
-                readonly label: "\uD55C\uAD6D\uC5B4";
+                readonly label: "한국어";
                 readonly description: "Korean";
             }, {
                 readonly value: "zh";
-                readonly label: "\u4E2D\u6587 (\u7B80\u4F53)";
+                readonly label: "中文 (简体)";
                 readonly description: "Chinese (Simplified)";
             }, {
                 readonly value: "ja";
-                readonly label: "\u65E5\u672C\u8A9E";
+                readonly label: "日本語";
                 readonly description: "Japanese";
             }, {
                 readonly value: "es";
-                readonly label: "Espa\u00F1ol";
+                readonly label: "Español";
                 readonly description: "Spanish";
             }, {
                 readonly value: "fr";
-                readonly label: "Fran\u00E7ais";
+                readonly label: "Français";
                 readonly description: "French";
             }, {
                 readonly value: "de";
@@ -491,6 +500,25 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Use the session name color for the editor border and status line gap";
         };
     };
+    readonly "pet.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "red", "blue"];
+        readonly default: "off";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Sayknow Pet";
+            readonly description: "16x16 real-pixel sayknow living beside the composer (sixel/kitty terminals)";
+            readonly options: readonly [{
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "No pet";
+            }, ...{
+                value: "red" | "blue";
+                label: string;
+                description: string;
+            }[]];
+        };
+    };
     readonly "statusLine.maxRows": {
         readonly type: "number";
         readonly default: 1;
@@ -679,7 +707,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "tools";
             readonly label: "Artifact head size (KB)";
-            readonly description: "Amount of head content kept inline alongside the tail when output spills to artifact (middle elision). 0 disables \u2014 keep tail only.";
+            readonly description: "Amount of head content kept inline alongside the tail when output spills to artifact (middle elision). 0 disables — keep tail only.";
             readonly options: readonly [{
                 readonly value: "0";
                 readonly label: "0 KB";
@@ -1172,7 +1200,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "model";
             readonly label: "Service Tier";
-            readonly description: 'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.';
+            readonly description: "Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: \"fast\"` on supported Opus models. Scoped values target one family.";
             readonly options: readonly [{
                 readonly value: "none";
                 readonly label: "None";
@@ -1215,7 +1243,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "tasks";
             readonly label: "Subagent Service Tier";
-            readonly description: 'Service tier applied to task-tool subagents only. "inherit" copies the main session tier; any explicit value overrides it for subagents without touching the main session.';
+            readonly description: "Service tier applied to task-tool subagents only. \"inherit\" copies the main session tier; any explicit value overrides it for subagents without touching the main session.";
             readonly options: readonly [{
                 readonly value: "inherit";
                 readonly label: "Inherit";
@@ -1477,7 +1505,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "interaction";
             readonly label: "Check for Updates";
-            readonly description: "If false, skip update check";
+            readonly description: "At interactive startup, notify of newer versions; never install. Use `skc update` only for recognized Bun global, Windows npm, or bundled-installer binaries; source, linked, and unrecognized installs use their original method.";
         };
     };
     readonly "starReminder.enabled": {
@@ -2012,11 +2040,11 @@ export declare const SETTINGS_SCHEMA: {
             readonly options: readonly [{
                 readonly value: "global";
                 readonly label: "Global";
-                readonly description: "One shared bank \u2014 every project sees the same memories";
+                readonly description: "One shared bank — every project sees the same memories";
             }, {
                 readonly value: "per-project";
                 readonly label: "Per project";
-                readonly description: "Isolated bank per cwd basename \u2014 projects cannot see each other's memories";
+                readonly description: "Isolated bank per cwd basename — projects cannot see each other's memories";
             }, {
                 readonly value: "per-project-tagged";
                 readonly label: "Per project (tagged)";
@@ -2116,7 +2144,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "memory";
             readonly label: "Hindsight Mental Models";
-            readonly description: "Read curated reflect summaries (mental models) into developer instructions at boot. Loads existing models on the bank \u2014 does not write. Pair with hindsight.mentalModelAutoSeed to also auto-create the built-in seed set.";
+            readonly description: "Read curated reflect summaries (mental models) into developer instructions at boot. Loads existing models on the bank — does not write. Pair with hindsight.mentalModelAutoSeed to also auto-create the built-in seed set.";
             readonly condition: "hindsightActive";
         };
     };
@@ -2154,7 +2182,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "context";
             readonly label: "TTSR Context Mode";
-            readonly description: "What to do with partial output when TTSR triggers. 'discard' (recommended) drops the aborted partial turn so it never accumulates in context. 'keep' retains every aborted partial turn, which grows the token footprint each time a rule fires \u2014 prefer 'discard' unless you specifically need the partial output.";
+            readonly description: "What to do with partial output when TTSR triggers. 'discard' (recommended) drops the aborted partial turn so it never accumulates in context. 'keep' retains every aborted partial turn, which grows the token footprint each time a rule fires — prefer 'discard' unless you specifically need the partial output.";
         };
     };
     readonly "ttsr.interruptMode": {
@@ -2637,6 +2665,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable agent-to-agent IRC messaging via the irc tool";
         };
     };
+    readonly "irc.sidebar.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "IRC Sidebar";
+            readonly description: "Enable the IRC message sidebar (opens with the toggle key; starts closed)";
+        };
+    };
     readonly "renderMermaid.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -3102,7 +3139,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "tasks";
             readonly label: "Isolation Mode";
-            readonly description: 'Isolation backend for subagents. "auto" lets the native PAL pick the best available backend (CoW-aware filesystems, then overlayfs/ProjFS, then a git worktree / recursive-copy fallback).';
+            readonly description: "Isolation backend for subagents. \"auto\" lets the native PAL pick the best available backend (CoW-aware filesystems, then overlayfs/ProjFS, then a git worktree / recursive-copy fallback).";
             readonly options: readonly [{
                 readonly value: "none";
                 readonly label: "None";
@@ -3457,7 +3494,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "duckduckgo";
                 readonly label: "DuckDuckGo";
-                readonly description: "Keyless default \u2014 no API key or OAuth required";
+                readonly description: "Keyless default — no API key or OAuth required";
             }, {
                 readonly value: "insane";
                 readonly label: "Insane";
@@ -3773,7 +3810,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "interaction";
             readonly label: "Plugin Security Risk Threshold";
-            readonly description: "Score threshold (0\u2013100) above which block mode denies install. Default 60.";
+            readonly description: "Score threshold (0–100) above which block mode denies install. Default 60.";
         };
     };
     readonly "telegram.enabled": {
@@ -4116,6 +4153,9 @@ export interface NotificationsSettings {
         richDraft: {
             enabled: boolean;
         };
+        topics: {
+            nameTemplate: string | undefined;
+        };
     };
     discord: {
         botToken: string | undefined;

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

@@ -115,6 +115,8 @@ export declare class Settings {
      * Set a model role (helper for modelRoles record).
      */
     setModelRole(role: ModelRole | string, modelId: string): void;
+    setGlobalModelRole(role: ModelRole | string, modelId: string | undefined): void;
+    setGlobalModelRoleAndFlush(role: ModelRole | string, modelId: string | undefined): Promise<void>;
     /**
      * Set an agent model override while keeping any live runtime override aligned.
      *

package/dist/types/coordinator/contract.d.ts

@@ -1,4 +1,4 @@
 export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
 export declare const COORDINATOR_MCP_SERVER_NAME = "skc-coordinator-mcp";
-export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["skc_coordinator_list_sessions", "skc_coordinator_read_status", "skc_coordinator_read_tail", "skc_coordinator_list_questions", "skc_coordinator_list_artifacts", "skc_coordinator_read_artifact", "skc_coordinator_read_coordination_status", "skc_coordinator_watch_events", "skc_coordinator_register_session", "skc_coordinator_start_session", "skc_coordinator_send_prompt", "skc_coordinator_submit_question_answer", "skc_coordinator_read_turn", "skc_coordinator_await_turn", "skc_coordinator_report_status", "skc_delegate_plan", "skc_delegate_execute", "skc_delegate_team"];
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["skc_coordinator_list_sessions", "skc_coordinator_read_status", "skc_coordinator_read_tail", "skc_coordinator_list_questions", "skc_coordinator_list_artifacts", "skc_coordinator_read_artifact", "skc_coordinator_read_coordination_status", "skc_coordinator_watch_events", "skc_coordinator_register_session", "skc_coordinator_start_session", "skc_coordinator_stop_session", "skc_coordinator_send_prompt", "skc_coordinator_submit_question_answer", "skc_coordinator_read_turn", "skc_coordinator_await_turn", "skc_coordinator_report_status", "skc_delegate_plan", "skc_delegate_execute", "skc_delegate_team"];
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/coordinator-mcp/model-preset.d.ts

@@ -0,0 +1,45 @@
+import { type ModelProfileDefinition } from "../config/model-profiles";
+/**
+ * Loads the merged built-in + custom model-profile registry the way the `skc`
+ * CLI resolves `--mpreset`, so coordinator MCP launches select the same
+ * authoritative profile the spawned child will activate. Custom profiles live
+ * in the shared models config, which the child inherits, so both sides agree.
+ */
+export type CoordinatorModelProfileLoader = () => Map<string, ModelProfileDefinition> | Promise<Map<string, ModelProfileDefinition>>;
+/**
+ * Thrown by the default loader when `models.yml` exists but is invalid or
+ * unreadable. This lets the resolver fail closed with a distinct, stable reason
+ * instead of silently collapsing a broken registry to the built-ins-only set
+ * (which would misreport a caller's valid custom profile as unknown).
+ */
+export declare class CoordinatorModelProfileRegistryError extends Error {
+    constructor(cause?: unknown);
+}
+export declare const loadCoordinatorModelProfiles: CoordinatorModelProfileLoader;
+export type CoordinatorMpresetResolution = {
+    ok: true;
+    mpreset: string | null;
+} | {
+    ok: false;
+    reason: "unknown_model_profile";
+    mpreset: string;
+    available_profiles: string[];
+} | {
+    ok: false;
+    reason: "model_profile_registry_error";
+    mpreset: string;
+    available_profiles: string[];
+};
+/**
+ * Resolve a coordinator `mpreset` argument against the merged profile registry.
+ *
+ * Only an absent (`undefined`/`null`) value is a no-op (`mpreset: null`); an
+ * explicit empty/whitespace string is a caller error and is rejected rather
+ * than silently launching at the default tier. Legacy aliases are canonicalized
+ * exactly like the CLI (e.g. `codex-standard` -> `codex-medium`) so coordinator
+ * selection stays in parity with `skc --mpreset <profile>`; the resolved value
+ * is the canonical profile name. Unknown names are rejected with the
+ * available-profile listing and never reach a spawned child command, and a
+ * broken registry fails closed with `model_profile_registry_error`.
+ */
+export declare function resolveCoordinatorMpreset(raw: unknown, loadProfiles: CoordinatorModelProfileLoader): Promise<CoordinatorMpresetResolution>;

package/dist/types/coordinator-mcp/policy.d.ts

@@ -10,6 +10,9 @@ export interface CoordinatorMcpConfig {
     namespace: CoordinatorNamespace;
     stateRoot: string;
     sessionCommand: string | null;
+    sessionIdleTtlMs: number;
+    sessionSweepIntervalMs: number;
+    forceStopEnabled: boolean;
 }
 export interface CoordinatorMutationRequest {
     allow_mutation?: boolean;

package/dist/types/coordinator-mcp/server.d.ts

@@ -1,5 +1,8 @@
 import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
+import { type OwnerIsolationProbe } from "../skc-runtime/tmux-owner-isolation";
+import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
+import { type SessionReaper } from "./session-reaper";
 export type { CoordinatorToolName };
 export { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES };
 interface JsonRpcRequest {
@@ -22,20 +25,32 @@ interface JsonRpcResponse {
 interface SessionStartInput {
     cwd: string;
     prompt?: string;
+    mpreset?: string | null;
     namespace: {
         profile: string | null;
         repo: string | null;
     };
     worktree: true;
+    sessionId: string;
+    launchId: string;
+    /** Canonical, coordinator-owned immutable readiness marker path. */
+    readinessMarkerFile: string;
+    /** @deprecated Compatibility alias for injected launch providers. */
+    readinessFile: string;
 }
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type CommandRunner = (command: string[], stdinLine?: string) => Promise<CommandResult>;
 interface CoordinatorServices {
     listSessions?: () => unknown[] | Promise<unknown[]>;
     startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
-    commandRunner?: (command: string[]) => Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
+    commandRunner?: CommandRunner;
+    forceCloseSession?: (sessionName: string, env: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string) => Promise<unknown>;
+    ownerIsolationProbe?: OwnerIsolationProbe;
+    resolveModelProfiles?: CoordinatorModelProfileLoader;
 }
 interface CoordinatorMcpServerOptions {
     env?: NodeJS.ProcessEnv;
@@ -43,16 +58,35 @@ interface CoordinatorMcpServerOptions {
 }
 interface LegacyHandlerOptions {
     env?: NodeJS.ProcessEnv;
-    createSession?: () => unknown;
+    createSession?: (input: SessionStartInput) => unknown;
 }
+/**
+ * Append an authoritative `--mpreset <profile>` to the coordinator child launch
+ * command so the spawned SKC session activates the selected profile from its
+ * first turn. The profile name is validated against the merged registry before
+ * reaching here; it is still shell-quoted as defense in depth.
+ *
+ * Precedence note: this matches `skc --mpreset <profile>` semantics exactly, so
+ * an explicit model-affecting flag already present in the operator-configured
+ * `sessionCommand` (e.g. a `--model`/`--thinking` baked into the launch command)
+ * follows the same CLI precedence as a direct `skc --mpreset ... --model ...`
+ * invocation. The effective profile recorded on the session is the
+ * coordinator-resolved request, not a child-attested activation receipt; a
+ * cross-process activation receipt is a possible future enhancement and is out
+ * of scope for the per-session selection contract here.
+ */
+export declare function buildCoordinatorSessionCommand(sessionCommand: string, mpreset: string | null | undefined): string;
 export declare const COORDINATOR_AWAIT_TURN_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_RUNTIME_PROMPT_ACK_TIMEOUT_MAX_MS: number;
+export declare const COORDINATOR_RUNTIME_READINESS_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30000;
 export declare const COORDINATOR_POLL_INTERVAL_MAX_MS = 10000;
 export declare function boundedAwaitTurnTimeoutMs(value: unknown): number;
 export declare function boundedRuntimePromptAckTimeoutMs(value: unknown): number;
+export declare function boundedRuntimeReadinessTimeoutMs(value: unknown): number;
 export declare function boundedEventWatchTimeoutMs(value: unknown): number;
 export declare function boundedPollIntervalMs(value: unknown): number;
+export declare function coordinatorOwnerIsolationProbe(runner: CommandRunner): Promise<OwnerIsolationProbe>;
 export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
     path: unknown;
 }): Promise<Record<string, unknown>>;
@@ -61,6 +95,45 @@ export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServe
     callTool: (name: string, args?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
     handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    reapSession: (rawId: unknown, opts?: {
+        force?: boolean;
+        reason?: string;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+        killed: boolean;
+        active_turn_id?: string;
+        detail?: string;
+    }>;
+    sessionReaper: SessionReaper;
 };
 export declare function handleCoordinatorMcpRequest(request: JsonRpcRequest, options?: LegacyHandlerOptions): Promise<JsonRpcResponse>;
+export interface PumpCoordinatorOptions {
+    /** Max concurrent in-flight *data* (non-control) handlers. Control frames (ping) bypass this. */
+    maxDataConcurrency?: number;
+    /** Max data requests queued waiting for a slot before overflow is rejected as server_busy. */
+    maxQueueDepth?: number;
+    /** Bounded wait for in-flight handlers/writes to settle after input ends. */
+    drainTimeoutMs?: number;
+}
+/**
+ * Pump a newline-delimited JSON-RPC stream with BOUNDED concurrent dispatch.
+ *
+ * A long-running tool call (e.g. skc_coordinator_await_turn, which polls for
+ * minutes) must not block the read loop from answering keepalive pings on the
+ * same stdio channel. But naive unbounded concurrency reintroduces its own
+ * hazards, so this pump enforces the safety envelope the coordinator needs:
+ *
+ *  - Control frames (ping) bypass the data-concurrency cap → keepalive is always
+ *    answerable even while data handlers saturate.
+ *  - Data handlers are capped at `maxDataConcurrency`; excess is queued up to
+ *    `maxQueueDepth`, then rejected as `server_busy` (bounded memory / fanout).
+ *  - A coded local `EPIPE` terminalizes writer and dispatch together; other
+ *    writer faults reject the pump without poisoning the serialized write chain.
+ *  - On EOF or a closed peer the pump drains already-running handlers (bounded
+ *    by `drainTimeoutMs`) and never promotes queued work.
+ *  - Byte chunks are decoded with a streaming decoder so multibyte characters
+ *    split across chunks are not corrupted.
+ */
+export declare function pumpCoordinatorMcpStream(handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>, input: AsyncIterable<string | Uint8Array>, writeLine: (line: string) => void | Promise<void>, options?: PumpCoordinatorOptions): Promise<void>;
 export declare function runCoordinatorMcpStdio(options?: CoordinatorMcpServerOptions): Promise<void>;

package/dist/types/coordinator-mcp/session-reaper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Idle reaper for coordinator-managed SKC worker sessions.
+ *
+ * Every `skc_delegate_*` call that omits `session_id` starts a fresh tmux worker
+ * session. Nothing in the coordinator ever tore those down, so completed/crashed
+ * sessions accumulated (RAM + worktrees) until something killed them by hand.
+ *
+ * This is the automatic backstop (defense-in-depth): a periodic sweep force-closes
+ * sessions that are (a) ephemeral — coordinator delegate-created, never a user's
+ * registered resident session, (b) not mid-turn, and (c) idle past a TTL.
+ *
+ * The controller is pure + fully injectable (clock / list / reap side-effects) so
+ * it is unit-testable without tmux, the filesystem, or wall-clock waits. The
+ * scheduling mirrors the proven resource-gc controller: a recursive setTimeout
+ * with a generation guard so a stop()+start() can never leak a duplicate timer.
+ */
+export declare const DEFAULT_SESSION_IDLE_TTL_MS: number;
+export declare const DEFAULT_SESSION_SWEEP_INTERVAL_MS: number;
+export declare const MIN_SESSION_IDLE_TTL_MS = 60000;
+export declare const MIN_SESSION_SWEEP_INTERVAL_MS = 30000;
+/** Minimal projection of a coordinator session the reaper needs to decide. */
+export interface ReapableSession {
+    sessionId: string;
+    /** True only for coordinator delegate-created sessions. User-registered resident sessions are false and never reaped. */
+    ephemeral: boolean;
+    /** Epoch ms of last observed activity (turn update / session-state write / session creation). */
+    lastActivityMs: number;
+    /** True while a turn is active — never reap mid-turn. */
+    hasActiveTurn: boolean;
+}
+export interface SessionReaperPolicy {
+    idleTtlMs: number;
+    sweepIntervalMs: number;
+}
+/**
+ * Pure selection: which sessions are safe to reap at `now`.
+ * A session is reapable iff ephemeral AND not mid-turn AND idle ≥ (clamped) TTL.
+ */
+export declare function selectReapableSessions(sessions: readonly ReapableSession[], now: number, idleTtlMs: number): ReapableSession[];
+/** Injectable side-effects so the controller runs in tests without tmux/fs/real time. */
+export interface SessionReaperDeps {
+    listSessions: () => Promise<ReapableSession[]>;
+    reapSession: (sessionId: string) => Promise<void>;
+    now: () => number;
+}
+export interface SessionReaper {
+    /** Run one sweep; returns the number of sessions successfully reaped. */
+    sweepOnce: () => Promise<number>;
+    start: () => void;
+    stop: () => void;
+    readonly running: boolean;
+}
+export declare function createSessionReaper(deps: SessionReaperDeps, policy: SessionReaperPolicy): SessionReaper;

package/dist/types/daemon/control-types.d.ts

@@ -40,6 +40,14 @@ export interface DaemonOperationOptions {
     /** For reload: spawn a fresh owner even when none is currently running. */
     spawnIfStopped?: boolean;
 }
+export interface DaemonRecovery {
+    /** Machine-readable recovery category for automation branching. */
+    reason: "ownership_mismatch";
+    /** One-line human summary of why the operation could not proceed. */
+    summary: string;
+    /** Ordered, copy-pasteable remediation steps. */
+    steps: string[];
+}
 export interface DaemonOperationResult {
     kind: DaemonKind;
     action: Exclude<DaemonAction, "list">;
@@ -48,6 +56,8 @@ export interface DaemonOperationResult {
     after?: DaemonStatus;
     warnings: string[];
     message: string;
+    /** Present when the operation was refused with an actionable recovery path (e.g. ownership mismatch). */
+    recovery?: DaemonRecovery;
 }
 export interface BuiltInDaemonController {
     readonly kind: DaemonKind;

package/dist/types/daemon/operator-contract.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared operator contract for the `skc daemon` command surface.
+ *
+ * One source of truth for the beginner-safe operational vocabulary so the
+ * guided human surface and the machine-readable JSON never drift:
+ * - the terse action verbs plus operator aliases (e.g. `restart` -> `reload`),
+ * - process exit codes,
+ * - concise vs. `--verbose` human rendering of statuses and results, and
+ * - actionable recovery guidance for a token/chat ownership mismatch.
+ *
+ * The full roots/debug payload lives behind `--verbose` (human) or `--json`
+ * (automation); the default human output stays a concise per-daemon result.
+ */
+import type { DaemonAction, DaemonOperationResult, DaemonRecovery, DaemonStatus } from "./control-types";
+/** Canonical daemon actions accepted as the leading verb. */
+export declare const DAEMON_CANONICAL_ACTIONS: readonly DaemonAction[];
+/**
+ * Operator-friendly aliases resolved to a canonical action. `restart` is the
+ * routine "reload if running, otherwise start" verb; it maps onto `reload`,
+ * whose default already spawns a fresh owner when none is running.
+ */
+export declare const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction>>;
+/** Every token accepted in the leading action position (canonical + aliases). */
+export declare const DAEMON_ACTION_TOKENS: readonly string[];
+/** Resolve a leading verb (canonical or alias) to its canonical action. */
+export declare function resolveDaemonAction(token: string | undefined): DaemonAction | undefined;
+/** Exit codes for `skc daemon`. Backward compatible: success 0, any failure 1. */
+export declare const DAEMON_EXIT: {
+    readonly ok: 0;
+    readonly failure: 1;
+};
+/** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
+export declare const OWNERSHIP_MISMATCH_MESSAGE = "refused: a live Telegram daemon with a different bot token or chat already owns this workspace";
+/** Structured, actionable recovery for a token/chat ownership mismatch. */
+export declare function ownershipMismatchRecovery(): DaemonRecovery;
+/**
+ * Render one daemon status. Concise by default (single head line + any
+ * actionable warning); `--verbose` adds runtime detail and the full roots list.
+ */
+export declare function formatDaemonStatus(status: DaemonStatus, opts?: {
+    verbose?: boolean;
+}): string;
+/**
+ * Render one operation result. Keeps the stable `<kind> <action>: ok|failed —
+ * <message>` head line, then any warnings, then actionable recovery steps.
+ */
+export declare function formatDaemonResult(result: DaemonOperationResult): string;

package/dist/types/defaults/skc/extensions/grok-cli-vendor/src/models/catalog.d.ts

@@ -1,6 +1,7 @@
 /**
  * Model definitions for Grok CLI's API.
  */
+import { Effort } from '@sayknow-cli/ai/model-thinking';
 export interface GrokCliModelConfig {
     id: string;
     name: string;
@@ -14,9 +15,12 @@ export interface GrokCliModelConfig {
     };
     contextWindow: number;
     maxTokens: number;
+    /** Highest reasoning effort supported by this model. */
+    maxReasoningEffort?: Effort;
     /** Models that don't support reasoning.effort get a thinkingLevelMap. */
     thinkingLevelMap?: Record<string, string | null>;
 }
+export declare function getMaxReasoningEffort(modelId: string): Effort | undefined;
 export declare function supportsReasoningEffort(modelId: string): boolean;
 /**
  * Resolve the active model list. If `SKC_GROK_CLI_MODELS` is set,

package/dist/types/defaults/skc/extensions/grok-cli-vendor/src/shared/errors.d.ts

@@ -12,27 +12,27 @@ export declare class XaiOAuthError extends Error {
 /** Well-known error codes. */
 export declare const XaiErrorCode: {
     /** OIDC discovery failed (network, invalid response). */
-    readonly DISCOVERY_FAILED: 'discovery_failed';
+    readonly DISCOVERY_FAILED: "discovery_failed";
     /** Discovery endpoint returned a non-xAI origin. */
-    readonly DISCOVERY_INVALID_ORIGIN: 'discovery_invalid_origin';
+    readonly DISCOVERY_INVALID_ORIGIN: "discovery_invalid_origin";
     /** Authorization was denied or errored in the browser. */
-    readonly AUTHORIZATION_FAILED: 'authorization_failed';
+    readonly AUTHORIZATION_FAILED: "authorization_failed";
     /** CSRF state mismatch between request and callback. */
-    readonly STATE_MISMATCH: 'state_mismatch';
+    readonly STATE_MISMATCH: "state_mismatch";
     /** Callback did not include an authorization code. */
-    readonly CODE_MISSING: 'code_missing';
+    readonly CODE_MISSING: "code_missing";
     /** Token exchange failed (network, invalid response). */
-    readonly TOKEN_EXCHANGE_FAILED: 'token_exchange_failed';
+    readonly TOKEN_EXCHANGE_FAILED: "token_exchange_failed";
     /** Token exchange returned an invalid payload. */
-    readonly TOKEN_EXCHANGE_INVALID: 'token_exchange_invalid';
+    readonly TOKEN_EXCHANGE_INVALID: "token_exchange_invalid";
     /** Refresh token is missing or empty. */
-    readonly REFRESH_MISSING: 'refresh_missing';
+    readonly REFRESH_MISSING: "refresh_missing";
     /** Token refresh failed (expired, revoked). */
-    readonly REFRESH_FAILED: 'refresh_failed';
+    readonly REFRESH_FAILED: "refresh_failed";
     /** No credentials stored. */
-    readonly AUTH_MISSING: 'auth_missing';
+    readonly AUTH_MISSING: "auth_missing";
     /** Loopback callback server could not bind. */
-    readonly CALLBACK_BIND_FAILED: 'callback_bind_failed';
+    readonly CALLBACK_BIND_FAILED: "callback_bind_failed";
     /** Loopback callback timed out. */
-    readonly CALLBACK_TIMEOUT: 'callback_timeout';
+    readonly CALLBACK_TIMEOUT: "callback_timeout";
 };

package/dist/types/discovery/helpers.d.ts

@@ -11,7 +11,7 @@ export declare const SOURCE_PATHS: {
     readonly native: {
         readonly userBase: string;
         readonly userAgent: string;
-        projectDir: string;
+        readonly projectDir: string;
     };
     readonly claude: {
         readonly userBase: ".claude";

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -1,5 +1 @@
-/**
- * Recursively substitute ${ANTHROPIC_MODEL_PLUGIN_ROOT} and ${SKC_PLUGIN_ROOT}
- * with the actual plugin root path in strings, arrays, and plain objects.
- */
 export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;

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

@@ -63,8 +63,8 @@ export declare function computePatchDiff(input: PatchInput, cwd: string, options
 }>;
 export declare const patchEditEntrySchema: z.ZodObject<{
     op: z.ZodOptional<z.ZodEnum<{
-        create: "create";
         delete: "delete";
+        create: "create";
         update: "update";
     }>>;
     rename: z.ZodOptional<z.ZodString>;
@@ -74,8 +74,8 @@ export declare const patchEditSchema: z.ZodObject<{
     path: z.ZodString;
     edits: z.ZodArray<z.ZodObject<{
         op: z.ZodOptional<z.ZodEnum<{
-            create: "create";
             delete: "delete";
+            create: "create";
             update: "update";
         }>>;
         rename: z.ZodOptional<z.ZodString>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -176,11 +176,13 @@ export interface ExtensionUIContext {
     setToolsExpanded(expanded: boolean): void;
 }
 export interface ContextUsage {
-    /** Estimated context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
+    /** Context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
     tokens: number | null;
     contextWindow: number;
     /** Context usage as percentage of context window, or null if tokens is unknown. */
     percent: number | null;
+    /** Provenance: "provider_anchor" = anchored on provider-reported usage (+ heuristic trailing delta); "heuristic" = no provider anchor available, full estimate; "unknown" = post-compaction, no post-compaction provider response yet. */
+    source: "provider_anchor" | "heuristic" | "unknown";
 }
 export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;