@sayknow-cli/coding-agent 0.3.13 → 0.3.15

package/dist/types/capability/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Core types for the capability-based config discovery system.
+ *
+ * This architecture inverts control: instead of callers knowing provider-specific
+ * paths like `.skc`, `.gemini`, or `.vscode`, they simply ask for `load("mcps")`
+ * and get back a unified array of MCP servers.
+ */
+/**
+ * Context passed to every provider loader.
+ */
+export interface LoadContext {
+    /** Current working directory (project root) */
+    cwd: string;
+    /** User home directory */
+    home: string;
+    /** Git repository root (directory containing .git), or null if not in a repo */
+    repoRoot: string | null;
+}
+/**
+ * Result from a provider's load function.
+ */
+export interface LoadResult<T> {
+    items: T[];
+    /** Warnings encountered during loading (parse errors, etc.) */
+    warnings?: string[];
+}
+/**
+ * A provider that can load items for a capability.
+ */
+export interface Provider<T> {
+    /** Unique provider ID (e.g., "Anthropic model", "skc", "mcp-json", "agents-md") */
+    id: string;
+    /** Human-readable name for UI display (e.g., "Anthropic Code", "OpenAI code provider") */
+    displayName: string;
+    /** Short description for settings UI (e.g., "Load config from .skc/") */
+    description: string;
+    /**
+     * Priority (higher = checked first, wins on conflicts).
+     * Suggested ranges:
+     *   100+ : Primary providers (skc, pi)
+     *   50-99: Tool-specific providers (Anthropic model, OpenAI code backend, gemini)
+     *   1-49 : Shared standards (mcp-json, agents-md)
+     */
+    priority: number;
+    /**
+     * Load items for this capability.
+     * Returns items in provider's preferred order (usually project before user).
+     */
+    load(ctx: LoadContext): Promise<LoadResult<T>>;
+}
+/**
+ * Options for loading a capability.
+ */
+export interface LoadOptions {
+    /** Only use these providers (by ID). Default: all registered */
+    providers?: string[];
+    /** Exclude these providers (by ID). Default: none */
+    excludeProviders?: string[];
+    /** Custom cwd. Default: getProjectDir() */
+    cwd?: string;
+    /** Include items even if they fail validation. Default: false */
+    includeInvalid?: boolean;
+    /** Include items disabled via settings. Default: false */
+    includeDisabled?: boolean;
+    /** Explicit disabled extension IDs to apply instead of settings. */
+    disabledExtensions?: string[];
+}
+/**
+ * Source metadata attached to every loaded item.
+ */
+export interface SourceMeta {
+    /** Provider ID that loaded this item */
+    provider: string;
+    /** Provider display name (for UI) */
+    providerName: string;
+    /** Absolute path to the source file */
+    path: string;
+    /** Whether this came from user-level, project-level, or native config */
+    level: "user" | "project" | "native";
+}
+/**
+ * Merged result from loading a capability across all providers.
+ */
+export interface CapabilityResult<T> {
+    /** Deduplicated items in priority order */
+    items: Array<T & {
+        _source: SourceMeta;
+    }>;
+    /** All items including shadowed duplicates (for diagnostics) */
+    all: Array<T & {
+        _source: SourceMeta;
+        _shadowed?: boolean;
+    }>;
+    /** Warnings from all providers */
+    warnings: string[];
+    /** Which providers contributed items (IDs) */
+    providers: string[];
+}
+/**
+ * Definition of a capability.
+ */
+export interface Capability<T> {
+    /** Capability ID (e.g., "mcps", "skills", "context-files") */
+    id: string;
+    /** Human-readable name for UI display (e.g., "MCP Servers", "Skills") */
+    displayName: string;
+    /** Short description for settings/status UI */
+    description: string;
+    /**
+     * Extract a unique key from an item for deduplication.
+     * Items with the same key: first one wins (highest priority provider).
+     * Return undefined to never deduplicate (all items kept).
+     */
+    key(item: T): string | undefined;
+    /**
+     * Optional validation. Return error message if invalid, undefined if valid.
+     */
+    validate?(item: T): string | undefined;
+    /**
+     * Optional disabledExtensions ID for this item.
+     * When present, loadCapability() can hide items disabled via settings.
+     */
+    toExtensionId?(item: T): string | undefined;
+    /** Registered providers, sorted by priority (highest first) */
+    providers: Provider<T>[];
+}
+/**
+ * Metadata about a capability (for introspection/UI).
+ */
+export interface CapabilityInfo {
+    id: string;
+    displayName: string;
+    description: string;
+    providers: Array<{
+        id: string;
+        displayName: string;
+        description: string;
+        priority: number;
+        enabled: boolean;
+    }>;
+}
+/**
+ * Metadata about a provider (for introspection/UI).
+ */
+export interface ProviderInfo {
+    id: string;
+    displayName: string;
+    description: string;
+    priority: number;
+    /** Which capabilities this provider is registered for */
+    capabilities: string[];
+    /** Whether this provider is currently enabled */
+    enabled: boolean;
+}

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

@@ -0,0 +1,12 @@
+export type AgentsAction = "unpack";
+export interface AgentsCommandArgs {
+    action: AgentsAction;
+    flags: {
+        force?: boolean;
+        json?: boolean;
+        dir?: string;
+        user?: boolean;
+        project?: boolean;
+    };
+}
+export declare function runAgentsCommand(cmd: AgentsCommandArgs): Promise<void>;

package/dist/types/cli/args.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CLI argument parsing and help display
+ */
+import { type Effort } from "@sayknow-cli/ai";
+export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui" | "bridge";
+export interface Args {
+    cwd?: string;
+    allowHome?: boolean;
+    provider?: string;
+    model?: string;
+    smol?: string;
+    slow?: string;
+    plan?: string;
+    mpreset?: string;
+    default?: boolean;
+    apiKey?: string;
+    credential?: string;
+    systemPrompt?: string;
+    appendSystemPrompt?: string;
+    thinking?: Effort;
+    continue?: boolean;
+    resume?: string | true;
+    help?: boolean;
+    version?: boolean;
+    mode?: Mode;
+    noSession?: boolean;
+    sessionDir?: string;
+    rpcListen?: string;
+    providerSessionId?: string;
+    fork?: string;
+    models?: string[];
+    tools?: string[];
+    noTools?: boolean;
+    noLsp?: boolean;
+    noPty?: boolean;
+    tmux?: boolean;
+    /** Retained for runtime/test compatibility; extension loading flags are no longer parsed. */
+    hooks?: string[];
+    extensions?: string[];
+    noExtensions?: boolean;
+    pluginDirs?: string[];
+    print?: boolean;
+    export?: string;
+    /** Retained for runtime/test compatibility; arbitrary skill discovery is always disabled. */
+    noSkills?: boolean;
+    skills?: string[];
+    noRules?: boolean;
+    listModels?: string | true;
+    noTitle?: boolean;
+    messages: string[];
+    fileArgs: string[];
+    /** Retained for test/runtime compatibility; extension-defined flags are no longer parsed. */
+    unknownFlags: Map<string, boolean | string>;
+}
+export declare function parseArgs(args: string[]): Args;
+export declare function getExtraHelpText(): string;
+export declare function printHelp(): void;

package/dist/types/cli/auth-broker-cli.d.ts

@@ -0,0 +1,25 @@
+export type AuthBrokerAction = "serve" | "token" | "login" | "logout" | "status" | "import" | "migrate";
+export interface AuthBrokerCommandArgs {
+    action: AuthBrokerAction;
+    flags: {
+        json?: boolean;
+        bind?: string;
+        regenerate?: boolean;
+        via?: string;
+        provider?: string;
+        dryRun?: boolean;
+        /** `login`/`logout`: provider id. `import`: filesystem path. */
+        source?: string;
+        /** `import`: keep credentials whose JSON had `disabled: true`. */
+        includeDisabled?: boolean;
+        /** `migrate`: also upload local OAuth (default: api_key only, since OAuth is via cliproxy import). */
+        includeOauth?: boolean;
+        /** `migrate`: also capture env-var API keys for providers not yet on broker. */
+        includeEnv?: boolean;
+        /** `migrate`: required `--from-local` source. Reserved for future sources. */
+        fromLocal?: boolean;
+    };
+}
+declare const ACTIONS: readonly AuthBrokerAction[];
+export declare function runAuthBrokerCommand(cmd: AuthBrokerCommandArgs): Promise<void>;
+export { ACTIONS as AUTH_BROKER_ACTIONS };

package/dist/types/cli/auth-gateway-cli.d.ts

@@ -0,0 +1,18 @@
+export type AuthGatewayAction = "serve" | "token" | "status" | "check";
+export interface AuthGatewayCommandArgs {
+    action: AuthGatewayAction;
+    flags: {
+        json?: boolean;
+        bind?: string;
+        regenerate?: boolean;
+        /**
+         * Disable bearer-token auth on inbound requests. Useful when the gateway
+         * is bound to loopback (the default `127.0.0.1:4000`) and you don't want
+         * to wire token-paste plumbing into every local client.
+         */
+        noAuth?: boolean;
+    };
+}
+declare const ACTIONS: readonly AuthGatewayAction[];
+export declare function runAuthGatewayCommand(cmd: AuthGatewayCommandArgs): Promise<void>;
+export { ACTIONS as AUTH_GATEWAY_ACTIONS };

package/dist/types/cli/classify-install-target.d.ts

@@ -0,0 +1,8 @@
+export declare function classifyInstallTarget(spec: string, knownMarketplaces: Set<string>): {
+    type: "marketplace";
+    name: string;
+    marketplace: string;
+} | {
+    type: "npm";
+    spec: string;
+};

package/dist/types/cli/commands/init-xdg.d.ts

@@ -0,0 +1 @@
+export declare function initXdg(): Promise<void>;

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

@@ -0,0 +1,41 @@
+import type { CommandCtor, CommandEntry } from "@sayknow-cli/utils/cli";
+export type FigName = string | string[];
+export interface FigArg {
+    name: string;
+    description?: string;
+    isOptional?: boolean;
+    isVariadic?: boolean;
+    suggestions?: string[];
+}
+export interface FigOption {
+    name: FigName;
+    description?: string;
+    args?: FigArg;
+    isRepeatable?: boolean;
+}
+export interface FigSubcommand {
+    name: FigName;
+    description?: string;
+    options?: FigOption[];
+    args?: FigArg | FigArg[];
+}
+export interface FigSpec extends FigSubcommand {
+    name: string;
+    subcommands?: FigSubcommand[];
+}
+export type InshellisenseIndexStatus = "created" | "updated" | "already-compatible" | "overwritten";
+export interface InstallSkcInshellisenseSpecOptions {
+    dir?: string;
+    force?: boolean;
+}
+export interface InstallSkcInshellisenseSpecResult {
+    directory: string;
+    specPath: string;
+    indexPath: string;
+    indexStatus: InshellisenseIndexStatus;
+}
+export declare function defaultInshellisenseSpecDir(homeDir?: string): string;
+export declare function buildSkcFigSpec(entries: CommandEntry[], rootCommandOverride?: CommandCtor): Promise<FigSpec>;
+export declare function renderFigSpecModule(spec: FigSpec): string;
+export declare function renderInshellisenseIndexModule(): string;
+export declare function installSkcInshellisenseSpec(spec: FigSpec, options?: InstallSkcInshellisenseSpecOptions): Promise<InstallSkcInshellisenseSpecResult>;

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

@@ -0,0 +1,23 @@
+/**
+ * Config CLI command handlers.
+ *
+ * Handles `skc config <command>` subcommands for managing settings.
+ * Uses the settings schema as the source of truth for available settings.
+ */
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+export interface ConfigCommandArgs {
+    action: ConfigAction;
+    key?: string;
+    value?: string;
+    flags: {
+        json?: boolean;
+        showSecrets?: boolean;
+    };
+}
+/**
+ * Parse config subcommand arguments.
+ * Returns undefined if not a config command.
+ */
+export declare function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined;
+export declare function runConfigCommand(cmd: ConfigCommandArgs): Promise<void>;
+export declare function printConfigHelp(): void;

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

@@ -0,0 +1,27 @@
+/**
+ * `skc daemon` command handler.
+ *
+ * Generic over the static built-in daemon controller map: lists/inspects
+ * daemons and drives cooperative stop/reload. Telegram is the only kind today.
+ */
+import { Settings } from "../config/settings";
+import type { BuiltInDaemonController, DaemonKind } from "../daemon/control-types";
+export type DaemonCliAction = "list" | "status" | "stop" | "reload";
+export interface DaemonCommandArgs {
+    action: DaemonCliAction;
+    kinds: DaemonKind[];
+    all: boolean;
+    json: boolean;
+    force: boolean;
+    gracefulTimeoutMs?: number;
+    killTimeoutMs?: number;
+    spawnIfStopped?: boolean;
+    /** Show runtime detail and the full roots list in human output. */
+    verbose?: boolean;
+}
+export interface DaemonCommandDeps {
+    settings?: Settings;
+    controllers?: BuiltInDaemonController[];
+}
+export declare function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined;
+export declare function runDaemonCommand(cmd: DaemonCommandArgs, deps?: DaemonCommandDeps): Promise<void>;

package/dist/types/cli/fast-help.d.ts

@@ -0,0 +1 @@
+export declare function getExtraHelpText(): string;

package/dist/types/cli/file-processor.d.ts

@@ -0,0 +1,11 @@
+import type { ImageContent } from "@sayknow-cli/ai";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text content and image attachments */
+export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;

package/dist/types/cli/fixture-report.d.ts

@@ -0,0 +1,20 @@
+import type { TaskTokenLog } from "../task/types";
+export interface LiveRunReportShape {
+    schemaVersion: 1;
+    binaryId: string;
+    fixtureId: string;
+    totals: {
+        turns: number;
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        totalTokens: number;
+    };
+    cacheHitRate: number | null;
+    receiptArtifactRatio: number | null;
+    spawnDecisions: number | null;
+    roi: number | null;
+}
+export declare function buildFixtureReport(fixtureId: string, logs: readonly TaskTokenLog[]): LiveRunReportShape;
+export declare function runFixtureReport(fixtureId: string): Promise<number>;

package/dist/types/cli/fixture-report.test.d.ts

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

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

@@ -0,0 +1,17 @@
+import { GrepOutputMode } from "@sayknow-cli/natives";
+export interface GrepCommandArgs {
+    pattern: string;
+    path: string;
+    glob?: string;
+    limit: number;
+    context: number;
+    mode: GrepOutputMode;
+    gitignore: boolean;
+}
+/**
+ * Parse grep subcommand arguments.
+ * Returns undefined if not a grep command.
+ */
+export declare function parseGrepArgs(args: string[]): GrepCommandArgs | undefined;
+export declare function runGrepCommand(cmd: GrepCommandArgs): Promise<void>;
+export declare function printGrepHelp(): void;

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/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>;