@sayknow-cli/coding-agent 0.4.2 → 0.4.4

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

@@ -0,0 +1,108 @@
+import { type AuthCredential, type AuthCredentialStore, type StoredAuthCredential } from "@sayknow-cli/ai";
+import type { RawSettings as Settings } from "../config/settings";
+/**
+ * Unified SQLite storage for agent settings, model usage, and auth credentials.
+ * Delegates auth credential operations to AuthCredentialStore from @sayknow-cli/ai.
+ * Uses singleton pattern per database path; access via AgentStorage.open().
+ */
+export declare class AgentStorage {
+    #private;
+    private constructor();
+    /**
+     * Returns singleton instance for the given database path, creating if needed.
+     * Retries on SQLITE_BUSY with exponential backoff.
+     * @param dbPath - Path to the SQLite database file (defaults to config path)
+     * @returns AgentStorage instance for the given path
+     */
+    static open(dbPath?: string): Promise<AgentStorage>;
+    /**
+     * Retrieves all settings from storage (legacy, for migration only).
+     * Settings are now stored in config.yml. This method is only used
+     * during migration from agent.db to config.yml.
+     * @returns Settings object, or null if no settings are stored
+     * @deprecated Use config.yml instead. This is only for migration.
+     */
+    getSettings(): Settings | null;
+    /**
+     * @deprecated Settings are now stored in config.yml, not agent.db.
+     * This method is kept for backward compatibility but does nothing.
+     */
+    saveSettings(settings: Settings): void;
+    /**
+     * Records model usage, updating the last-used timestamp.
+     * @param modelKey - Model key in "provider/modelId" format
+     */
+    recordModelUsage(modelKey: string): void;
+    /**
+     * Gets model keys ordered by most recently used.
+     * Results are cached until recordModelUsage is called.
+     * @returns Array of model keys ("provider/modelId") in MRU order
+     */
+    getModelUsageOrder(): string[];
+    /**
+     * Checks if any auth credentials exist in storage.
+     * @returns True if at least one credential is stored
+     */
+    hasAuthCredentials(): boolean;
+    /**
+     * Returns the underlying {@link AuthCredentialStore} so callers that need
+     * the lower-level pi-ai abstraction (e.g. `findAnthropicAuth(store)`) can
+     * reuse this storage's open database connection instead of opening their
+     * own.
+     */
+    get authStore(): AuthCredentialStore;
+    /**
+     * Lists auth credentials, optionally filtered by provider.
+     * Only returns active (non-disabled) credentials by default.
+     * @param provider - Optional provider name to filter by
+     * @param includeDisabled - If true, includes disabled credentials
+     * @returns Array of stored credentials with their database IDs
+     */
+    listAuthCredentials(provider?: string, includeDisabled?: boolean): StoredAuthCredential[];
+    /**
+     * Atomically replaces all credentials for a provider.
+     * Useful for OAuth token refresh where old tokens should be discarded.
+     * @param provider - Provider name (e.g., "anthropic", "openai")
+     * @param credentials - New credentials to store
+     * @returns Array of newly stored credentials with their database IDs
+     */
+    replaceAuthCredentialsForProvider(provider: string, credentials: AuthCredential[]): StoredAuthCredential[];
+    /**
+     * Updates an existing auth credential by ID.
+     * @param id - Database row ID of the credential to update
+     * @param credential - New credential data
+     */
+    updateAuthCredential(id: number, credential: AuthCredential): void;
+    /**
+     * Disables an auth credential by ID with a persisted cause.
+     * @param id - Database row ID of the credential to disable
+     * @param disabledCause - Human-readable cause stored with the disabled row
+     */
+    deleteAuthCredential(id: number, disabledCause: string): void;
+    /**
+     * Disables all auth credentials for a provider with a persisted cause.
+     * @param provider - Provider name whose credentials should be disabled
+     * @param disabledCause - Human-readable cause stored with the disabled rows
+     */
+    deleteAuthCredentialsForProvider(provider: string, disabledCause: string): void;
+    /**
+     * Gets a cached value by key. Returns null if not found or expired.
+     */
+    getCache(key: string): string | null;
+    /**
+     * Sets a cached value with expiry time (unix seconds).
+     */
+    setCache(key: string, value: string, expiresAtSec: number): void;
+    deleteCachePrefix(prefix: string): void;
+    /**
+     * Deletes expired cache entries. Call periodically for cleanup.
+     */
+    cleanExpiredCache(): void;
+    /**
+     * Release prepared statements and the shared SQLite handle.
+     *
+     * AgentStorage instances are cached by path, so closing also evicts this
+     * instance and allows a later open() to create a fresh handle.
+     */
+    close(): void;
+}

package/dist/types/session/artifacts.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Session-scoped artifact storage for truncated tool outputs.
+ *
+ * Artifacts are stored in a directory alongside the session file,
+ * accessible via artifact:// URLs.
+ */
+import { type ManagedSessionDescendantStore } from "./internal/managed-session-storage";
+export interface ManagedOutputGeneration {
+    outputFilename: string;
+    metadataFilename: string;
+    outputSizeBytes: number;
+    outputSha256: string;
+    metadataSizeBytes: number;
+    metadataSha256: string;
+}
+export interface ArtifactSaveOptions {
+    maxBytes?: number;
+}
+/**
+ * Manages artifact storage for a session.
+ *
+ * Artifacts are stored with sequential IDs in the session's artifact directory.
+ * The directory is created lazily on first write.
+ *
+ * Subagents do not own their own `ArtifactManager`. The parent's instance is
+ * adopted via `SessionManager.adoptArtifactManager`, so the whole parent +
+ * subagent tree shares one ID space and one directory.
+ */
+export declare class ArtifactManager {
+    #private;
+    /**
+     * @param dir Directory that will hold artifact files. Created lazily on first save.
+     */
+    constructor(target: string | ManagedSessionDescendantStore);
+    /**
+     * Artifact directory path.
+     * Directory may not exist until first artifact is saved.
+     */
+    get dir(): string;
+    getManagedRootAuthority(): import("./internal/managed-session-storage").ManagedDirectoryRoot | undefined;
+    getManagedSubtreeRootAuthority(): import("./internal/managed-session-storage").ManagedDirectoryRoot | undefined;
+    getManagedStore(): ManagedSessionDescendantStore | undefined;
+    assertManagedBinding(): void;
+    replaceNamed(filename: string, content: string): Promise<void>;
+    replaceNamedBytes(filename: string, bytes: Uint8Array): Promise<void>;
+    publishManagedOutputGeneration(selectorFilename: string, outputFilenamePrefix: string, outputBytes: Uint8Array, metadataBytes: Uint8Array): Promise<void>;
+    publishNamedNoReplace(filename: string, bytes: Uint8Array): Promise<void>;
+    /**
+     * Atomically allocate next artifact ID.
+     * IDs are sequential within the session.
+     */
+    allocateId(): number;
+    /**
+     * Reserve an artifact ID without exposing a writable managed pathname.
+     *
+     * Streaming callers that only understand bare paths fail closed; use `save`
+     * for terminally published artifact content.
+     */
+    allocatePath(toolType: string): Promise<{
+        id: string;
+        path?: string;
+    }>;
+    /**
+     * Save content as an artifact and return the artifact ID.
+     * Content is written to a private temporary inode, synced, and linked into
+     * the artifact directory only after the complete terminal payload exists.
+     */
+    save(content: string, toolType: string, options?: ArtifactSaveOptions): Promise<string>;
+    /**
+     * Check if an artifact exists.
+     * @param id Artifact ID (numeric string)
+     */
+    exists(id: string): Promise<boolean>;
+    /**
+     * List all artifact files in the directory.
+     * Returns empty array if directory doesn't exist.
+     */
+    listFiles(): Promise<string[]>;
+    /**
+     * Get the full path to an artifact file.
+     * Returns null if artifact doesn't exist.
+     *
+     * @param id Artifact ID (numeric string)
+     */
+    getPath(id: string): Promise<string | null>;
+}

package/dist/types/session/auth-broker-config.d.ts

@@ -0,0 +1,13 @@
+export interface AuthBrokerClientConfig {
+    url: string;
+    token: string;
+}
+/** Path to the local bearer token file. Created on the broker host by `skc auth-broker token`. */
+export declare function getAuthBrokerTokenFilePath(): string;
+/**
+ * Read broker configuration. Returns null when the URL is missing
+ * (broker disabled — local store is used). Throws when URL is set but no
+ * token is available — the caller cannot fall back silently because the
+ * user explicitly asked to use the broker.
+ */
+export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;

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

@@ -0,0 +1,6 @@
+/**
+ * Re-exports from @sayknow-cli/ai.
+ * All credential storage types and the AuthStorage class now live in the ai package.
+ */
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialIfAbsentReason, AuthCredentialIfAbsentResult, AuthCredentialIfAbsentSnapshotResult, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, StoredAuthCredential, } from "@sayknow-cli/ai";
+export { AuthBrokerClient, AuthStorage, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, SqliteAuthCredentialStore, } from "@sayknow-cli/ai";

package/dist/types/session/blob-store.d.ts

@@ -0,0 +1,160 @@
+export interface BlobPutResult {
+    hash: string;
+    path: string;
+    get ref(): string;
+}
+export interface CheckedBlobPutResult extends BlobPutResult {
+    bytes: number;
+}
+export declare class BlobCorruptError extends Error {
+    readonly hash: string;
+    readonly path: string;
+    constructor(hash: string, path: string);
+}
+/**
+ * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
+ *
+ * Files are stored at `<dir>/<sha256-hex>` with no extension. The SHA-256 hash is computed
+ * over the raw binary data (not base64). Content-addressing makes writes idempotent and
+ * provides automatic deduplication across sessions.
+ */
+export declare class BlobStore {
+    readonly dir: string;
+    constructor(dir: string);
+    /**
+     * Write binary data to the blob store.
+     * @returns SHA-256 hex hash of the data
+     */
+    put(data: Buffer): Promise<BlobPutResult>;
+    /**
+     * Synchronous variant of {@link put}. Use on persistence hot paths where the caller
+     * cannot afford the microtask hops of the async version (e.g. OOM-safe session writes).
+     * Returns once the bytes are in the kernel page cache.
+     */
+    putSync(data: Buffer): BlobPutResult;
+    /**
+     * Durably install binary data as an immutable content-addressed blob.
+     *
+     * Callers that persist references to this blob must mutate canonical session entries only
+     * after this method returns successfully. A corrupt pre-existing target is reported with
+     * {@link BlobCorruptError}; it is never silently overwritten or trusted.
+     */
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
+    /** Read blob by hash, returns Buffer or null if not found. */
+    get(hash: string): Promise<Buffer | null>;
+    /** Synchronously read blob by hash, returns Buffer or null if not found. */
+    getSync(hash: string): Buffer | null;
+    /** Read blob by hash and verify its content hash; returns null if not found. */
+    getChecked(hash: string): Promise<Buffer | null>;
+    /** Synchronously read blob by hash and verify its content hash; returns null if not found. */
+    getCheckedSync(hash: string): Buffer | null;
+    /** Check if a blob exists. */
+    has(hash: string): Promise<boolean>;
+}
+export declare class EphemeralBlobStore extends BlobStore {
+    #private;
+    constructor(dir: string);
+    putSync(data: Buffer): BlobPutResult;
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
+    getSync(hash: string): Buffer | null;
+    getCheckedSync(hash: string): Buffer | null;
+    clear(): void;
+    dispose(): void;
+}
+export declare class MemoryBlobStore extends BlobStore {
+    #private;
+    constructor();
+    put(data: Buffer): Promise<BlobPutResult>;
+    putSync(data: Buffer): BlobPutResult;
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
+    get(hash: string): Promise<Buffer | null>;
+    getSync(hash: string): Buffer | null;
+    getChecked(hash: string): Promise<Buffer | null>;
+    getCheckedSync(hash: string): Buffer | null;
+    has(hash: string): Promise<boolean>;
+}
+export declare class ResidentBlobMissingError extends Error {
+    readonly hash: string;
+    readonly kind: "text" | "imageUrl" | "imageData";
+    readonly sessionId?: string | undefined;
+    readonly sessionFile?: string | undefined;
+    constructor(hash: string, kind: "text" | "imageUrl" | "imageData", sessionId?: string | undefined, sessionFile?: string | undefined);
+}
+/** Check if a data string is a blob reference. */
+export declare function isBlobRef(data: string): boolean;
+/** Extract the SHA-256 hash from a blob reference string. */
+export declare function parseBlobRef(data: string): string | null;
+/** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */
+export declare function isImageDataUrl(data: string): boolean;
+/**
+ * Externalize a provider image data URL to the blob store, returning a blob reference.
+ * The full data URL string is preserved so transport-native history can be reconstructed on resume.
+ */
+export declare function externalizeImageDataUrl(blobStore: BlobStore, dataUrl: string): Promise<string>;
+/** Synchronous variant of {@link externalizeImageDataUrl}. */
+export declare function externalizeImageDataUrlSync(blobStore: BlobStore, dataUrl: string): string;
+/**
+ * Externalize an image's base64 data to the blob store, returning a blob reference.
+ * If the data is already a blob reference, returns it unchanged.
+ */
+export declare function externalizeImageData(blobStore: BlobStore, base64Data: string): Promise<string>;
+/** Synchronous variant of {@link externalizeImageData}. */
+export declare function externalizeImageDataSync(blobStore: BlobStore, base64Data: string): string;
+/**
+ * Resolve an externalized provider image data URL back to its original string.
+ * If the data is not a blob reference, returns it unchanged.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the persisted blob is missing
+ * (e.g. resuming an old session whose image blob was pruned), this warns and returns
+ * the reference as-is rather than throwing, so legacy resume degrades gracefully.
+ * New resident byte-sensitive TEXT uses the fail-closed path instead
+ * (`resolveTextBlobSync` -> `ResidentBlobMissingError`). Do NOT route new byte-sensitive
+ * resident data through this warn-and-return path.
+ */
+export declare function resolveImageDataUrl(blobStore: BlobStore, data: string): Promise<string>;
+/**
+ * Resolve a blob reference back to base64 data.
+ * If the data is not a blob reference, returns it unchanged.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the blob is missing this warns
+ * and returns the reference as-is (downstream sees an invalid base64 ref but does not
+ * crash), preserving legacy-session resume. Byte-sensitive resident TEXT is fail-closed
+ * via `resolveTextBlobSync`; do NOT route new byte-sensitive resident data here.
+ */
+export declare function resolveImageData(blobStore: BlobStore, data: string): Promise<string>;
+/** Synchronously resolve an externalized provider image data URL back to its original string. */
+export declare function resolveImageDataUrlSync(blobStore: BlobStore, data: string): string;
+/** Synchronously resolve a blob reference back to base64 data. */
+export declare function resolveImageDataSync(blobStore: BlobStore, data: string): string;
+/**
+ * Synchronously resolve a blob reference back to utf8 text.
+ *
+ * FAIL-CLOSED byte-sensitive path: a missing resident blob throws
+ * `ResidentBlobMissingError` rather than degrading, so a missing resident text blob can
+ * never silently leak a `blob:sha256:` ref into provider payloads, UI, or exports.
+ * (Contrast the legacy persisted-image warn-and-return resolvers above.)
+ */
+export declare function resolveTextBlobSync(blobStore: BlobStore, data: string, context?: {
+    kind?: "text";
+    sessionId?: string;
+    sessionFile?: string;
+}): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataUrlSync}: a missing resident
+ * image-data-url blob throws `ResidentBlobMissingError` ("imageUrl") instead of warn-returning,
+ * so resident byte-sensitive provider image data can never leak a `blob:sha256:` ref into
+ * materialized entries, context, or provider payloads. The warn-and-return `resolveImageDataUrl*`
+ * resolvers remain ONLY for legacy persisted-image resume.
+ */
+export declare function resolveResidentImageDataUrlSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataSync}: a missing resident image blob
+ * throws `ResidentBlobMissingError` ("imageData") instead of warn-returning a placeholder.
+ */
+export declare function resolveResidentImageDataSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;

package/dist/types/session/cache-economics.d.ts

@@ -0,0 +1,79 @@
+import type { Usage } from "@sayknow-cli/ai";
+export interface CacheEconomicsPricing {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface CacheEconomicsModelCost extends CacheEconomicsPricing {
+    output: number;
+}
+export type CacheEconomicsBasis = {
+    kind: "persisted-aggregate";
+    costBreakdown: Usage["cost"];
+} | {
+    kind: "current-model-estimate";
+    pricing: CacheEconomicsPricing;
+};
+export interface CacheEconomicsUsage {
+    input: number;
+    output?: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total?: number;
+    cost?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        total?: number;
+    };
+}
+export interface CacheMissCostSummary {
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    inputCostUsd: number;
+    cacheReadCostUsd: number;
+    cacheWriteCostUsd: number;
+    cacheHitRate: number | undefined;
+    missPremiumUsd: number | undefined;
+}
+/**
+ * How a detected cache-miss pattern is attributed, per issue #2020.
+ *
+ * - `actionable`: usage evidence points to a user-controllable cause and SKC
+ *   has a concrete remediation.
+ * - `diagnostic-only`: a miss pattern is observed but the cause is not
+ *   determinable from usage alone; describe what is unknown, assert no cause.
+ * - `provider-side-suspected`: the provider returned no cache activity, so the
+ *   miss cannot be attributed to the user's prompt; not user-actionable.
+ */
+export type CacheMissAttribution = "actionable" | "diagnostic-only" | "provider-side-suspected";
+export interface CacheBehaviorWarning {
+    code: "expensive_cache_miss" | "cache_write_spike" | "provider_side_cache_miss";
+    attribution: CacheMissAttribution;
+    reason: string;
+    /** Concrete remediation — present only when `attribution` is `actionable`. */
+    nextStep?: string;
+    /** What SKC cannot determine — present for non-actionable attributions. */
+    unknown?: string;
+    costUsd: number;
+}
+export interface CacheWarningBuildState {
+    warningsEmitted: number;
+}
+export declare function computeCacheMissCostSummary(usage: CacheEconomicsUsage | undefined, basis: CacheEconomicsBasis): CacheMissCostSummary | undefined;
+export declare function formatCacheMissSummaryLines(summary: CacheMissCostSummary): string[];
+export declare function buildCacheBehaviorWarning(usage: Usage | undefined, model: {
+    cost: CacheEconomicsModelCost;
+} | undefined | null): CacheBehaviorWarning | undefined;
+/**
+ * Render a cache warning as a single transcript line. Actionable attributions
+ * carry a concrete next step; non-actionable ones state what is unknown and,
+ * for provider-side patterns, that the miss is not user-actionable — never
+ * asserting a cause or blaming the provider (#2020).
+ */
+export declare function formatCacheWarningLine(warning: CacheBehaviorWarning): string;
+export declare function buildCacheEconomicsWarning(usage: Usage | undefined, model: {
+    cost: CacheEconomicsModelCost;
+} | undefined | null, state: CacheWarningBuildState): string | undefined;

package/dist/types/session/client-bridge.d.ts

@@ -0,0 +1,88 @@
+/**
+ * ClientBridge — abstraction over capabilities provided by an external client
+ * (e.g. ACP editor host) that the agent can route through instead of operating
+ * directly on the local filesystem / spawning local subprocesses.
+ *
+ * When `undefined`, tools fall back to local IO. When populated (currently
+ * only by `AcpAgent`), tools route requests through the client so it can
+ * surface unsaved buffer state, render terminals in the IDE, or gate
+ * destructive operations behind user permission prompts.
+ */
+export interface ClientBridgeCapabilities {
+    /** Client implements `fs/read_text_file`. */
+    readTextFile?: boolean;
+    /** Client implements `fs/write_text_file`. */
+    writeTextFile?: boolean;
+    /** Client implements the `terminal/*` family. */
+    terminal?: boolean;
+    /** Client implements `session/request_permission`. */
+    requestPermission?: boolean;
+}
+export interface ClientBridgePermissionToolCall {
+    toolCallId: string;
+    toolName: string;
+    title: string;
+    kind?: string;
+    status?: "pending" | "in_progress" | "completed" | "failed";
+    rawInput?: unknown;
+    content?: unknown[];
+    locations?: {
+        path: string;
+        line?: number;
+    }[];
+}
+export type ClientBridgePermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
+export interface ClientBridgePermissionOption {
+    optionId: string;
+    name: string;
+    kind: ClientBridgePermissionOptionKind;
+}
+export type ClientBridgePermissionOutcome = {
+    outcome: "cancelled";
+} | {
+    outcome: "selected";
+    optionId: string;
+    kind?: ClientBridgePermissionOptionKind;
+};
+export interface ClientBridgeTerminalExitStatus {
+    exitCode?: number | null;
+    signal?: string | null;
+}
+export interface ClientBridgeTerminalOutput {
+    output: string;
+    truncated: boolean;
+    exitStatus?: ClientBridgeTerminalExitStatus | null;
+}
+export interface ClientBridgeTerminalHandle {
+    terminalId: string;
+    waitForExit(): Promise<ClientBridgeTerminalExitStatus>;
+    currentOutput(): Promise<ClientBridgeTerminalOutput>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+}
+export interface ClientBridgeCreateTerminalParams {
+    command: string;
+    args?: string[];
+    env?: Array<{
+        name: string;
+        value: string;
+    }>;
+    cwd?: string;
+    outputByteLimit?: number;
+}
+export interface ClientBridge {
+    readonly capabilities: ClientBridgeCapabilities;
+    /** ACP v1 clients cannot show server-initiated turns as busy after prompt response. */
+    readonly deferAgentInitiatedTurns?: boolean;
+    readTextFile?(params: {
+        path: string;
+        line?: number;
+        limit?: number;
+    }): Promise<string>;
+    writeTextFile?(params: {
+        path: string;
+        content: string;
+    }): Promise<void>;
+    createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;
+    requestPermission?(toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal): Promise<ClientBridgePermissionOutcome>;
+}

package/dist/types/session/context-estimation.d.ts

@@ -0,0 +1,31 @@
+import type { Skill } from "../extensibility/skills";
+import type { Tool } from "../tools";
+import type { AgentSession } from "./agent-session";
+export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
+export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
+/**
+ * Compute just the NON-MESSAGE token total: system prompt (with its skills
+ * section subtracted, since skills are tokenized separately) + system context
+ * (the rest of the system-prompt array) + tools + skills.
+ *
+ * Exposed so callers like `StatusLineComponent` can cache the non-message
+ * total separately from the message total. Non-message inputs (skills,
+ * tools, system prompt) change rarely; the message list grows on every
+ * streaming turn. Splitting the two lets the caller refresh each on its own
+ * cadence — non-message recomputed only when the inputs identity changes,
+ * messages walked incrementally as new entries append.
+ */
+export declare function computeNonMessageTokens(session: AgentSession): number;
+/**
+ * Shared helper for the four non-message token totals. Single source of truth
+ * for `computeNonMessageTokens` (session estimates + status-line incremental
+ * cache) and `computeContextBreakdown` (/context panel). The split avoids
+ * drift between the surfaces — they MUST report the same numbers.
+ */
+export declare function computeNonMessageBreakdown(session: AgentSession): {
+    rulesTokens: number;
+    skillsTokens: number;
+    toolsTokens: number;
+    systemContextTokens: number;
+    systemPromptTokens: number;
+};

package/dist/types/session/contribution-prep.d.ts

@@ -0,0 +1,47 @@
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+export declare const CONTRIBUTION_PREP_SCHEMA_VERSION = 1;
+export interface ContributionPrepArtifact {
+    path: string;
+    description: string;
+}
+export interface ContributionPrepManifest {
+    schema_version: number;
+    source_session_id: string;
+    created_at: string;
+    cwd: string;
+    git_head: string | null;
+    changed_files: string[];
+    artifacts: ContributionPrepArtifact[];
+    redactions: string[];
+    recommended_output: string[];
+    worker_prompt_path: string;
+}
+export interface ContributionPrepResult {
+    manifestPath: string;
+    workerPromptPath: string;
+    artifactDir: string;
+    changedFiles: string[];
+    spawned: boolean;
+}
+export interface ContributionPrepOptions {
+    customInstructions?: string;
+    spawnWorker?: boolean;
+    artifactRoot?: string;
+    now?: Date;
+    spawn?: (args: string[], cwd: string, shell: boolean) => Promise<void>;
+}
+export interface ContributionPrepContext {
+    sessionId: string;
+    cwd: string;
+    sessionFile?: string;
+    messages: AgentMessage[];
+    customInstructions?: string;
+    now?: Date;
+}
+interface RedactionState {
+    labels: Set<string>;
+}
+export declare function redactContributionPrepText(text: string, cwd: string, state?: RedactionState): string;
+export declare function buildContributionPrepWorkerPrompt(manifestPath: string): string;
+export declare function prepareContributionPrep(context: ContributionPrepContext, options?: ContributionPrepOptions): Promise<ContributionPrepResult>;
+export {};

package/dist/types/session/default-model-selection.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedThinkingLevel } from "@sayknow-cli/agent-core";
+export type DefaultModelSelectionRollbackStage = "durable" | "session" | "live";
+export declare const DEFAULT_MODEL_SELECTION_RECOVERY_MESSAGE = "Default model selection could not be completed after durable selection.";
+export type DefaultModelSelectionRecovery = {
+    readonly message: string;
+    readonly rollback: {
+        readonly disposition: "restored" | "partial" | "unknown";
+        readonly failures: readonly {
+            readonly stage: DefaultModelSelectionRollbackStage;
+            readonly message: string;
+        }[];
+    };
+};
+export interface DefaultModelSelectionResult {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly thinkingLevel: ResolvedThinkingLevel;
+}
+export declare function parseDefaultModelSelectionRecovery(value: unknown): DefaultModelSelectionRecovery | undefined;
+export declare class DefaultModelSelectionRecoveryError extends Error {
+    readonly name = "DefaultModelSelectionRecoveryError";
+    readonly code = "default_model_selection_recovery";
+    readonly recovery: DefaultModelSelectionRecovery;
+    constructor(_message: string, recovery: DefaultModelSelectionRecovery);
+}