@sayknow-cli/coding-agent 0.4.2 → 0.4.4

package/dist/types/cli/initial-message.d.ts

@@ -0,0 +1,17 @@
+import type { ImageContent } from "@sayknow-cli/ai";
+import type { Args } from "./args";
+export interface InitialMessageInput {
+    parsed: Args;
+    fileText?: string;
+    fileImages?: ImageContent[];
+    stdinContent?: string;
+}
+export interface InitialMessageResult {
+    initialMessage?: string;
+    initialImages?: ImageContent[];
+}
+/**
+ * Combine stdin content, @file text, and the first CLI message into a single
+ * initial prompt for non-interactive mode.
+ */
+export declare function buildInitialMessage({ parsed, fileText, fileImages, stdinContent, }: InitialMessageInput): InitialMessageResult;

package/dist/types/cli/launch-disposition.d.ts

@@ -0,0 +1,23 @@
+export type LaunchMode = "text" | "json" | "acp";
+export interface LaunchDisposition {
+    autoPrint: boolean;
+    isInteractive: boolean;
+    /** Set when an interactive launch is impossible (non-TTY stdin, nothing to run). */
+    nonInteractiveError?: string;
+}
+/**
+ * Decides between interactive, auto-print, and fail-fast launches.
+ *
+ * A non-TTY stdin means the TUI can never receive input, so an interactive
+ * launch would execute the initial prompt and then block in the event loop
+ * forever. Prepared command-line input degrades to print mode; without any
+ * input to run we fail fast instead of hanging. Explicit `--print` and
+ * `--mode` launches are left untouched.
+ */
+export declare function resolveLaunchDisposition(args: {
+    stdinIsTTY: boolean | undefined;
+    pipedInput: string | undefined;
+    hasPreparedInput: boolean;
+    print: boolean;
+    mode: LaunchMode | undefined;
+}): LaunchDisposition;

package/dist/types/cli/list-models.d.ts

@@ -0,0 +1,36 @@
+import type { ModelRegistry } from "../config/model-registry";
+import { type ExtensionFactory } from "../extensibility/extensions";
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export declare function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void>;
+/**
+ * Options for the `--list-models` command entry point.
+ */
+export interface RunListModelsOptions {
+    modelRegistry: ModelRegistry;
+    cwd: string;
+    /** CLI-supplied extension paths (e.g. from `-e <path>`). */
+    additionalExtensionPaths?: string[];
+    /** In-process extension factories to load without filesystem discovery. */
+    extensionFactories?: Array<{
+        factory: ExtensionFactory;
+        name: string;
+    }>;
+    /** Extension paths configured under `extensions:` in user settings. */
+    settingsExtensions?: string[];
+    /** Disabled extension ids from settings (`disabledExtensions`). */
+    disabledExtensionIds?: string[];
+    /** When true, skip discovery and only load `additionalExtensionPaths`. */
+    disableExtensionDiscovery?: boolean;
+    searchPattern?: string;
+}
+/**
+ * Loads extensions (CLI `-e` paths and `settings.extensions`) and surfaces
+ * any provider/model registrations on the supplied `modelRegistry` before
+ * delegating to {@link listModels}. This is the single entry point used by
+ * `--list-models` and exists to ensure extension-contributed providers are
+ * visible in the listing (issue #905). The load is intentionally narrow:
+ * no agent loop, no MCP servers, no custom-tool registration.
+ */
+export declare function runListModelsCommand(options: RunListModelsOptions): Promise<void>;

package/dist/types/cli/local-provider-smoke.d.ts

@@ -0,0 +1,59 @@
+import type { ModelsConfig } from "../config/models-config-schema";
+export interface LocalProviderSmokeCommandArgs {
+    model?: string;
+    modelsPath?: string;
+    timeoutMs?: number;
+    json?: boolean;
+    smoke?: boolean;
+}
+export interface LocalOpenAICompatConfig {
+    baseUrl: string;
+    apiKey?: string;
+}
+export type LocalProviderDiagnosticCheckName = "config" | "models" | "chat_stream";
+export type LocalProviderDiagnosticStatus = "ok" | "skipped" | "error";
+export type LocalProviderDiagnosticCategory = "auth" | "timeout" | "unreachable" | "not_ready" | "oom" | "malformed_response" | "http_error" | "configuration" | "empty_response";
+export interface LocalProviderDiagnosticCheck {
+    name: LocalProviderDiagnosticCheckName;
+    status: LocalProviderDiagnosticStatus;
+    message: string;
+    action?: string;
+    category?: LocalProviderDiagnosticCategory;
+    error?: string;
+    httpStatus?: number;
+}
+export interface LocalProviderSmokeResult {
+    ok: boolean;
+    baseUrl?: string;
+    model?: string;
+    message: string;
+    error?: string;
+    category?: LocalProviderDiagnosticCategory;
+    action?: string;
+}
+export interface LocalProviderDiscoveryResult {
+    ok: boolean;
+    provider: string;
+    baseUrl?: string;
+    models: string[];
+    message: string;
+    error?: string;
+    category?: LocalProviderDiagnosticCategory;
+    action?: string;
+}
+export interface LocalProviderStatusResult {
+    ok: boolean;
+    provider: "local";
+    baseUrl?: string;
+    model?: string;
+    models: string[];
+    checks: LocalProviderDiagnosticCheck[];
+    message: string;
+}
+export declare function getLocalOpenAICompatConfig(config: ModelsConfig | undefined): LocalOpenAICompatConfig | undefined;
+export declare function runLocalProviderDiscover(cmd: Omit<LocalProviderSmokeCommandArgs, "model" | "smoke">): Promise<LocalProviderDiscoveryResult>;
+export declare function runLocalProviderStatus(cmd: LocalProviderSmokeCommandArgs): Promise<LocalProviderStatusResult>;
+export declare function runLocalProviderSmoke(cmd: LocalProviderSmokeCommandArgs): Promise<LocalProviderSmokeResult>;
+export declare function runLocalProviderDiscoverCommand(cmd: Omit<LocalProviderSmokeCommandArgs, "model" | "smoke">): Promise<void>;
+export declare function runLocalProviderStatusCommand(cmd: LocalProviderSmokeCommandArgs): Promise<void>;
+export declare function runLocalProviderSmokeCommand(cmd: LocalProviderSmokeCommandArgs): Promise<void>;

package/dist/types/cli/malloc-env-guard.d.ts

@@ -0,0 +1,65 @@
+/**
+ * macOS malloc-stack-logging launch boundary.
+ *
+ * On macOS, an inherited `MallocStackLogging` / `MallocStackLoggingNoCompact`
+ * environment variable (from an Xcode scheme's malloc diagnostics, Instruments,
+ * `launchctl setenv`, or a debug-attached shell) makes libmalloc print
+ *
+ *   MallocStackLogging: can't turn off malloc stack logging because it was not enabled.
+ *
+ * to the stderr of every TTY-attached process. Bun snapshots the spawn-default
+ * environment at process startup — before any JS runs — so neither
+ * `delete process.env.X` nor a real libc `unsetenv()` cleans the environment
+ * that children inherit by default (verified on Bun 1.3.14). Inside the TUI,
+ * every PTY-spawned child then repeats the warning straight into the rendered
+ * frame and corrupts the display.
+ *
+ * The only way to hand children a clean startup snapshot is to start the primary
+ * process with a clean environment. This module re-execs the exact invocation
+ * once (darwin-only) with a `filterProcessEnv`-scrubbed environment and a
+ * `SKC_MALLOC_ENV_REEXEC` loop guard, before any fast path or subprocess spawn.
+ * The re-exec'd process — and therefore every downstream lane: `Bun.spawn`
+ * defaults, `node:child_process`, the native PTY, the tmux owner, plugin
+ * installs, and subagents — starts from a clean snapshot.
+ *
+ * The initial contaminated process's own libmalloc line is emitted by libc
+ * before any JS runs and cannot be suppressed from inside the process; it
+ * appears at most once per launch. A one-time actionable notice is written to
+ * interactive stderr (outside the rendered frame) pointing at the permanent
+ * `launchctl unsetenv` fix.
+ */
+/** Env vars that make macOS libmalloc write to a TTY when inherited. */
+export declare const MACOS_MALLOC_ENV_VARS: readonly ["MallocStackLogging", "MallocStackLoggingNoCompact"];
+/** Loop guard set on the scrubbed re-exec so it never re-execs itself again. */
+export declare const MALLOC_ENV_REEXEC_GUARD = "SKC_MALLOC_ENV_REEXEC";
+/** True when at least one macOS malloc-stack-logging var is present in `env`. */
+export declare function hasMacOSMallocEnv(env: Record<string, string | undefined>): boolean;
+/**
+ * True iff we must re-exec to escape a contaminated macOS startup snapshot:
+ * darwin, not already inside the scrubbed re-exec, and at least one malloc var
+ * present. Off darwin or on the re-exec'd child this is always false, so the
+ * common launch path pays only two cheap lookups.
+ */
+export declare function shouldReexecForMacOSMallocEnv(env: Record<string, string | undefined>, platform: NodeJS.Platform): boolean;
+/**
+ * Reconstruct the argv that re-runs the exact same program image.
+ *
+ * - Compiled single-file executable: argv[1] is the embedded virtual entry
+ *   (`/$bunfs/…` on POSIX, `B:\~BUN\…` on Windows), which must be dropped — the
+ *   executable re-embeds its own entry. Re-run `[exe, ...userArgs]`.
+ * - Source / dev-link run: argv[1] is the on-disk script that must be passed
+ *   back to the interpreter. Re-run `[interpreter, script, ...userArgs]`.
+ */
+export declare function buildMallocReexecArgv(argv: readonly string[], execPath: string): string[];
+/** One-time, human-actionable notice pointing at the permanent environment fix. */
+export declare function formatMallocEnvNotice(): string;
+/**
+ * Re-exec the current process once with a scrubbed environment and propagate the
+ * child's exit code. Callers MUST gate this behind `shouldReexecForMacOSMallocEnv`.
+ *
+ * Returns the child exit code, or `null` if the re-exec could not be spawned (in
+ * which case the caller falls back to running in the current, contaminated
+ * process — degraded but functional; the native PTY boundary and
+ * `filterProcessEnv` still keep managed children clean).
+ */
+export declare function reexecWithScrubbedMallocEnv(): Promise<number | null>;

package/dist/types/cli/malloc-env-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/mcp-cli.d.ts

@@ -0,0 +1,25 @@
+import type { MCPServerConfig } from "../runtime-mcp/types";
+export type MCPAction = "add" | "list" | "remove";
+export interface MCPCommandArgs {
+    action: MCPAction;
+    name?: string;
+    commandArgs?: string[];
+    flags: {
+        project?: boolean;
+        force?: boolean;
+        json?: boolean;
+        type?: "stdio" | "http" | "sse";
+        command?: string;
+        url?: string;
+        arg?: string[];
+        env?: string[];
+        header?: string[];
+        cwd?: string;
+        timeout?: number;
+    };
+    cwd?: string;
+}
+export declare class MCPArgsError extends Error {
+}
+export declare function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig;
+export declare function runMCPCommand(args: MCPCommandArgs): Promise<void>;

package/dist/types/cli/migrate-cli.d.ts

@@ -0,0 +1,20 @@
+import { type MigrateReport, type MigrateSource } from "../migrate/types";
+export interface MigrateCommandArgs {
+    from: string[];
+    project: boolean;
+    force: boolean;
+    dryRun: boolean;
+    json: boolean;
+    /** Test seam: override home dir for source discovery. */
+    homeDir?: string;
+    /** Test seam: override cwd for project-scope destinations. */
+    cwd?: string;
+}
+export declare class MigrateArgsError extends Error {
+}
+/** Expand `all`/repeated `--from`, validate, and return sources in canonical order. */
+export declare function resolveSources(from: string[]): MigrateSource[];
+/** Run the migration and return the report (does not set process.exitCode). */
+export declare function runMigrate(args: MigrateCommandArgs): Promise<MigrateReport>;
+/** CLI entry: run, render, and set the process exit code. */
+export declare function runMigrateCommand(args: MigrateCommandArgs): Promise<void>;

package/dist/types/cli/nofile-limit.d.ts

@@ -0,0 +1,11 @@
+import { execFileSync } from "node:child_process";
+export declare const RECOMMENDED_MACOS_NOFILE_LIMIT = 4096;
+export declare function parseNoFileLimit(text: string): number | undefined;
+export declare function buildMacOSNoFileLimitWarning(currentLimit: number): string;
+export interface WarnIfMacOSNoFileLimitTooLowDeps {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    execFileSync?: typeof execFileSync;
+    writeStderr?: (text: string) => void;
+}
+export declare function warnIfMacOSNoFileLimitTooLow(deps?: WarnIfMacOSNoFileLimitTooLowDeps): void;

package/dist/types/cli/notify-cli.d.ts

@@ -0,0 +1,64 @@
+import { Settings } from "../config/settings";
+import { type EnsureChatDaemonResult } from "../sdk/bus/chat-daemon-control";
+import { type EnsureTelegramDaemonDetailedResult } from "../sdk/bus/telegram-daemon";
+import { type TelegramSetupPreflight, type TelegramSetupTimers } from "../sdk/bus/telegram-setup";
+export type NotifyAction = "setup" | "status" | "health" | "test" | "recovery" | "daemon-internal";
+export type NotifySetupProvider = "telegram" | "discord" | "slack";
+export interface NotifyCommandArgs {
+    action: NotifyAction;
+    smoke?: boolean;
+    rawArgs: string[];
+    provider?: NotifySetupProvider;
+    token?: string;
+    chatId?: string;
+    discordBotToken?: string;
+    discordApplicationId?: string;
+    discordGuildId?: string;
+    discordParentChannelId?: string;
+    slackBotToken?: string;
+    slackAppToken?: string;
+    slackWorkspaceId?: string;
+    slackChannelId?: string;
+    slackAuthorizedUserId?: string;
+    redact?: boolean;
+    probe?: boolean;
+    message?: string;
+}
+export interface NotifyCommandDeps {
+    fetchImpl?: typeof fetch;
+    apiBase?: string;
+    settings?: Settings;
+    setupToken?: string;
+    pollTimeoutMs?: number;
+    pollIntervalMs?: number;
+    setupChatId?: string;
+    setupRedact?: boolean;
+    setupInteractive?: boolean;
+    threadedModePrompt?: (message: string) => Promise<string>;
+    tokenPrompt?: () => Promise<string>;
+    setExitCode?: (code: number) => void;
+    exitProcess?: (code: number) => void;
+    valuePrompt?: (label: string, masked: boolean) => Promise<string>;
+    /** Optional daemon ownership facts collected by an embedding host. */
+    setupPreflight?: TelegramSetupPreflight;
+    /** Injectable timers and cancellation for setup pairing. */
+    setupTimers?: TelegramSetupTimers;
+    setupAbortSignal?: AbortSignal;
+    setupPidAlive?: (pid: number) => boolean;
+    /** Injectable process-start provenance reader for ambient Telegram setup preflight. */
+    setupPidIncarnation?: (pid: number) => string | undefined;
+    ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<EnsureChatDaemonResult>;
+    ensureTelegramDaemon?: (settings: Settings) => Promise<EnsureTelegramDaemonDetailedResult>;
+}
+export declare function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined;
+export declare function runNotifyCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
+export declare function runNotifyCliCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
+type TokenPromptInput = NodeJS.ReadStream & {
+    isRaw?: boolean;
+    setRawMode?: (mode: boolean) => unknown;
+    pause?: () => unknown;
+};
+type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
+export declare function promptForToken(input?: TokenPromptInput, output?: TokenPromptOutput): Promise<string>;
+export declare function printNotifyHelp(): void;
+export {};

package/dist/types/cli/plugin-cli.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Plugin CLI command handlers.
+ *
+ * Handles `skc plugin <command>` subcommands for plugin lifecycle management.
+ */
+export type PluginAction = "install" | "uninstall" | "list" | "link" | "doctor" | "features" | "config" | "enable" | "disable" | "marketplace" | "discover" | "upgrade";
+export interface PluginCommandArgs {
+    action: PluginAction;
+    args: string[];
+    flags: {
+        json?: boolean;
+        fix?: boolean;
+        force?: boolean;
+        dryRun?: boolean;
+        local?: boolean;
+        enable?: string;
+        disable?: string;
+        set?: string;
+        scope?: "user" | "project";
+        user?: boolean;
+        project?: boolean;
+    };
+}
+/**
+ * Parse plugin subcommand arguments.
+ * Returns undefined if not a plugin command.
+ */
+export declare function parsePluginArgs(args: string[]): PluginCommandArgs | undefined;
+export { classifyInstallTarget } from "./classify-install-target";
+/**
+ * Run a plugin command.
+ */
+export declare function runPluginCommand(cmd: PluginCommandArgs): Promise<void>;
+export declare function printPluginHelp(): void;

package/dist/types/cli/read-cli.d.ts

@@ -0,0 +1,4 @@
+export interface ReadCommandArgs {
+    path: string;
+}
+export declare function runReadCommand(cmd: ReadCommandArgs): Promise<void>;

package/dist/types/cli/session-picker.d.ts

@@ -0,0 +1,5 @@
+import { type SessionSelectionResult } from "../modes/components/session-selector";
+import { type SessionInfo } from "../session/session-manager";
+export declare function deleteSessionPickerCandidate(sessionPath: string, explicitSessionDir?: string): Promise<void>;
+/** Show the read-only TUI session picker and return the user's consent intent. */
+export declare function selectSession(sessions: SessionInfo[], explicitSessionDir?: string): Promise<SessionSelectionResult>;

package/dist/types/cli/setup-cli.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Setup CLI command handler.
+ *
+ * Handles `skc setup [component]` to install the normal defaults or optional feature dependencies.
+ */
+import { AuthStorage, SqliteAuthCredentialStore } from "@sayknow-cli/ai";
+import { runExternalCredentialAutoImport } from "../setup/credential-auto-import";
+export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+export interface SetupCommandArgs {
+    component: SetupComponent;
+    flags: {
+        json?: boolean;
+        check?: boolean;
+        force?: boolean;
+        preset?: string;
+        compat?: string;
+        provider?: string;
+        baseUrl?: string;
+        apiKeyEnv?: string;
+        model?: string[];
+        modelsPath?: string;
+        smoke?: boolean;
+        install?: boolean;
+        root?: string[];
+        repo?: string;
+        profile?: string;
+        sessionCommand?: string;
+        noWorktree?: boolean;
+        worktreeName?: string;
+        stateRoot?: string;
+        mutation?: string[];
+        artifactByteCap?: string;
+        serverKey?: string;
+        skcCommand?: string;
+        target?: string;
+        profileDir?: string;
+        yes?: boolean;
+        dryRun?: boolean;
+        keychain?: boolean;
+    };
+}
+/**
+ * Parse setup subcommand arguments.
+ * Returns undefined if not a setup command.
+ */
+export declare function parseSetupArgs(args: string[]): SetupCommandArgs | undefined;
+/**
+ * Install Python packages using uv (preferred) or pip.
+ */
+/**
+ * Run the setup command.
+ */
+export declare function runSetupCommand(cmd: SetupCommandArgs): Promise<void>;
+/**
+ * Discover existing Claude Code / Codex CLI credentials and import them into the
+ * skc credential store after a redacted preview + confirmation. Falls back to
+ * manual-setup guidance when nothing importable is found.
+ */
+export interface CredentialsSetupDependencies {
+    openStore?: typeof SqliteAuthCredentialStore.open;
+    createAuthStorage?: (store: SqliteAuthCredentialStore) => AuthStorage;
+    discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
+}
+export declare function handleCredentialsSetup(flags: {
+    json?: boolean;
+    yes?: boolean;
+    dryRun?: boolean;
+    keychain?: boolean;
+}, deps?: CredentialsSetupDependencies): Promise<void>;
+/**
+ * Print setup command help.
+ */
+export declare function printSetupHelp(): void;

package/dist/types/cli/shell-cli.d.ts

@@ -0,0 +1,8 @@
+export interface ShellCommandArgs {
+    cwd?: string;
+    timeoutMs?: number;
+    noSnapshot?: boolean;
+}
+export declare function parseShellArgs(args: string[]): ShellCommandArgs | undefined;
+export declare function runShellCommand(cmd: ShellCommandArgs): Promise<void>;
+export declare function printShellHelp(): void;

package/dist/types/cli/skills-cli.d.ts

@@ -0,0 +1,9 @@
+export type SkillsAction = "list" | "read";
+export interface SkillsCommandArgs {
+    action: SkillsAction;
+    name?: string;
+    flags?: {
+        json?: boolean;
+    };
+}
+export declare function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void>;

package/dist/types/cli/ssh-cli.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SSH CLI command handlers.
+ *
+ * Handles `skc ssh <command>` subcommands for SSH host configuration management.
+ */
+export type SSHAction = "add" | "remove" | "list";
+export interface SSHCommandArgs {
+    action: SSHAction;
+    args: string[];
+    flags: {
+        json?: boolean;
+        host?: string;
+        user?: string;
+        port?: string;
+        key?: string;
+        desc?: string;
+        compat?: boolean;
+        scope?: "project" | "user";
+    };
+}
+export declare function runSSHCommand(cmd: SSHCommandArgs): Promise<void>;

package/dist/types/cli/stats-cli.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stats CLI command handlers.
+ *
+ * Handles `skc stats` subcommand for viewing AI usage statistics.
+ */
+export interface StatsCommandArgs {
+    port: number;
+    json: boolean;
+    summary: boolean;
+}
+/**
+ * Parse stats subcommand arguments.
+ * Returns undefined if not a stats command.
+ */
+export declare function parseStatsArgs(args: string[]): StatsCommandArgs | undefined;
+export declare function runStatsCommand(cmd: StatsCommandArgs): Promise<void>;
+export declare function printStatsHelp(): void;

package/dist/types/cli/telegram-cli.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `skc telegram` command handlers — start/status/env for the Telegram Remote
+ * integration, driven entirely by the `telegram.*` settings group.
+ */
+export type TelegramAction = "start" | "status" | "env" | "__gateway";
+export interface TelegramCommandArgs {
+    action: TelegramAction;
+    flags: {
+        json?: boolean;
+    };
+}
+export declare const TELEGRAM_ACTIONS: readonly TelegramAction[];
+export declare function runTelegramCommand(cmd: TelegramCommandArgs): Promise<void>;

package/dist/types/cli/update-cli.d.ts

@@ -0,0 +1,108 @@
+interface ReleaseInfo {
+    tag: string;
+    version: string;
+}
+/** Result from running the installed binary and parsing its reported version. */
+export interface InstalledVersionVerification {
+    ok: boolean;
+    actual?: string;
+    path?: string;
+    smokeTestFailed?: boolean;
+    smokeTestOutput?: string;
+    cleanupWarning?: string;
+}
+export interface PackageManagerUpdateResult {
+    exitCode: number | null;
+    text: () => string;
+}
+export type PackageManagerUpdateRunner = (expectedVersion: string) => Promise<PackageManagerUpdateResult>;
+export interface PackageManagerUpdateOptions {
+    managerName: string;
+    expectedVersion: string;
+    runInstall: PackageManagerUpdateRunner;
+    verifyInstalledRuntime: (expectedVersion: string) => Promise<InstalledVersionVerification>;
+    printRecoveredVerification?: (expectedVersion: string) => void;
+}
+/** Paths and verifier used while replacing a downloaded binary update. */
+export interface BinaryReplacementOptions {
+    targetPath: string;
+    tempPath: string;
+    backupPath: string;
+    expectedVersion: string;
+    verifyInstalledVersion: (expectedVersion: string) => Promise<InstalledVersionVerification>;
+}
+/**
+ * Parse update subcommand arguments.
+ * Returns undefined if not an update command.
+ */
+export declare function parseUpdateArgs(args: string[]): {
+    force: boolean;
+    check: boolean;
+} | undefined;
+export type PackageManagerTarget = {
+    manager: "npm";
+    packageName: string;
+};
+export type UpdateTarget = {
+    method: "bun";
+} | {
+    method: "npm";
+    packageName: string;
+} | {
+    method: "binary";
+    path: string;
+};
+type PathPlatform = NodeJS.Platform;
+type PackageExists = (packageName: string, packageRoot: string) => boolean;
+export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "npm" | "binary";
+export declare function resolveNpmManagedTargetForTest(ompPath: string, platform: PathPlatform, packageExists: PackageExists): PackageManagerTarget | undefined;
+export declare function formatBinaryDownloadFailureMessageForTest(binaryName: string, url: string, status: string | number, platform?: NodeJS.Platform): string;
+export declare function buildReleaseBinaryUrlForTest(version: string, platform?: NodeJS.Platform, arch?: string): string;
+export declare function formatManualUpdateInstructionsForTest(platform?: NodeJS.Platform): string;
+export declare function formatVerificationFailureForTest(result: InstalledVersionVerification, expectedVersion: string): string;
+/**
+ * Atomically replace the installed binary and roll back if version verification fails.
+ */
+export declare function replaceBinaryForUpdate(options: BinaryReplacementOptions): Promise<InstalledVersionVerification>;
+export declare function runPackageManagerUpdateForTest(options: PackageManagerUpdateOptions): Promise<InstalledVersionVerification>;
+export declare function fsyncFileForTest(filePath: string): Promise<void>;
+/** Injectable steps of the binary update flow (seams for testing ordering). */
+export interface BinaryUpdateFlow {
+    download(url: string, tempPath: string): Promise<void>;
+    fsync(filePath: string): Promise<void>;
+    replace(options: BinaryReplacementOptions): Promise<InstalledVersionVerification>;
+    verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification>;
+    /** Best-effort cleanup of the temp file when the flow aborts before replace. */
+    removeTemp?(filePath: string): Promise<void>;
+    /** Called once fsync has succeeded, right before replacement begins. */
+    beforeReplace?(): void;
+}
+/**
+ * Orchestrate download → fsync → replace → verify with a strict ordering
+ * contract: the downloaded temp binary MUST be flushed to stable storage
+ * before it is published (renamed into place) or exec'd for verification.
+ *
+ * If fsync fails the temp bytes are not durable, so we abort before
+ * replacement/verification and clean up the temp file rather than installing a
+ * possibly-truncated binary.
+ */
+export declare function runBinaryUpdateFlow(targetPath: string, url: string, expectedVersion: string, flow: BinaryUpdateFlow): Promise<InstalledVersionVerification>;
+/**
+ * Run the update command.
+ */
+export interface UpdateCommandDependencies {
+    getLatestRelease?: () => Promise<ReleaseInfo>;
+    resolveUpdateTarget?: () => Promise<UpdateTarget>;
+    performUpdate?: (target: UpdateTarget, expectedVersion: string) => Promise<void>;
+    refreshInstalledDefaultSkills?: () => Promise<void>;
+    exit?: (code: number) => never;
+}
+export declare function runUpdateCommand(opts: {
+    force: boolean;
+    check: boolean;
+}, deps?: UpdateCommandDependencies): Promise<void>;
+/**
+ * Print update command help.
+ */
+export declare function printUpdateHelp(): void;
+export {};