@sayknow-cli/coding-agent 0.4.1 → 0.4.3

package/dist/types/skill-state/deep-interview-mutation-guard.d.ts

@@ -0,0 +1,38 @@
+import type { AgentTool } from "@sayknow-cli/agent-core";
+export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `skc deep-interview --write --stage final` or hand off to an execution phase.";
+export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = ".skc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.skc/**`; use the sanctioned `skc` CLI instead.";
+export declare const RALPLAN_MUTATION_BLOCK_MESSAGE = "Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `skc ralplan --write` (stage scratch files under a temp dir if needed). Product-code mutation tools and patch execution are blocked while ralplan is active; mutate only after the plan is approved and execution begins.";
+export declare const ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE = "Ultragoal goal-planning phase boundary: finish goal planning and record goals through `skc ultragoal` before editing code. Product-code mutation tools and patch execution are blocked until goal planning completes and execution begins.";
+type ToolWithEditMode = AgentTool & {
+    mode?: unknown;
+    customWireName?: unknown;
+};
+export interface DeepInterviewMutationGuardInput {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    tool: ToolWithEditMode;
+    args: unknown;
+    forceOverride?: boolean;
+    enforceWorkflowState?: boolean;
+}
+export interface DeepInterviewMutationDecision {
+    blocked: boolean;
+    message?: string;
+    targets: string[];
+    reason?: string;
+    command?: string;
+}
+export declare function assertDeepInterviewMutationRawPathsAllowed(input: {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    rawPaths: string[];
+    forceOverride?: boolean;
+}): Promise<void>;
+export declare function getDeepInterviewMutationDecision(input: DeepInterviewMutationGuardInput): Promise<DeepInterviewMutationDecision>;
+export declare function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void>;
+export declare const getWorkflowMutationDecision: typeof getDeepInterviewMutationDecision;
+export declare const assertWorkflowMutationAllowed: typeof assertDeepInterviewMutationAllowed;
+export declare const assertWorkflowMutationRawPathsAllowed: typeof assertDeepInterviewMutationRawPathsAllowed;
+export {};

package/dist/types/skill-state/initial-phase.d.ts

@@ -0,0 +1,12 @@
+import type { CanonicalSkcWorkflowSkill } from "./active-state";
+/**
+ * Canonical initial phase for each SKC workflow skill. Used by both
+ * `recordSkillActivation` (UserPromptSubmit hook seeding initial mode-state)
+ * and the `skc state <caller> handoff --to <callee>` runtime when promoting
+ * the callee.
+ *
+ * Keeping this mapping in a neutral skill-state module avoids cycles between
+ * `skc-runtime/state-runtime.ts` and `hooks/skill-state.ts` (which pulls in
+ * session-manager and ultragoal verification code).
+ */
+export declare function initialPhaseForSkill(skill: CanonicalSkcWorkflowSkill | string): string;

package/dist/types/skill-state/workflow-hud.d.ts

@@ -0,0 +1,83 @@
+import type { WorkflowHudSummary } from "./active-state";
+interface WorkflowGateHudState {
+    approvalStatus?: string;
+    blockedReason?: string;
+    nextAction?: string;
+}
+interface DeepInterviewHudState extends WorkflowGateHudState {
+    phase?: string;
+    ambiguity?: number;
+    threshold?: number;
+    roundCount?: number;
+    targetComponent?: string;
+    weakestDimension?: string;
+    specStatus?: string;
+    updatedAt?: string;
+}
+interface RalplanHudState extends WorkflowGateHudState {
+    stage?: string;
+    waiting?: string;
+    iteration?: number;
+    iterationFromIndex?: number;
+    stages?: string;
+    verdict?: string;
+    latestSummary?: string;
+    pendingApproval?: boolean;
+    updatedAt?: string;
+}
+interface UltragoalLikeGoal {
+    id: string;
+    title: string;
+    status: string;
+}
+interface UltragoalHudState extends WorkflowGateHudState {
+    status: string;
+    currentGoal?: UltragoalLikeGoal;
+    counts: Record<string, number>;
+    goals: UltragoalLikeGoal[];
+    latestLedgerEvent?: {
+        event?: string;
+        goalId?: string;
+        timestamp?: string;
+        kind?: string;
+        evidence?: string;
+    };
+    updatedAt?: string;
+}
+interface TeamHudWorker {
+    id: string;
+    status?: string;
+}
+interface TeamHudState extends WorkflowGateHudState {
+    phase: string;
+    task_total: number;
+    task_counts: Record<string, number>;
+    workers: TeamHudWorker[];
+    updated_at?: string;
+    latestEvent?: {
+        type?: string;
+        worker?: string;
+        message?: string;
+    };
+    latestMessage?: {
+        from_worker?: string;
+        body?: string;
+    };
+}
+export declare function buildDeepInterviewHudSummary(state: DeepInterviewHudState): WorkflowHudSummary;
+export interface DeepInterviewHudDeriveOptions {
+    phase?: string;
+    specStatus?: string;
+    updatedAt?: string;
+}
+/**
+ * Single source of deep-interview HUD derivation. Reads a complete (normalized)
+ * mode-state envelope so recorder, `skc state write`, reconcile, seed, and handoff
+ * all produce identical chips. Topology-aware `target`/`weakest` come from
+ * `state.topology`; `legacy_missing` topology omits those chips (no synthetic values).
+ */
+export declare function deriveDeepInterviewHud(payload: Record<string, unknown>, options?: DeepInterviewHudDeriveOptions): WorkflowHudSummary;
+export declare function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary;
+export declare function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary;
+export declare function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary;
+export {};

package/dist/types/skill-state/workflow-mutation-guard.d.ts

@@ -0,0 +1,54 @@
+import type { AgentTool } from "@sayknow-cli/agent-core";
+import { readVisibleSkillActiveState } from "./active-state";
+export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `skc deep-interview --write --stage final` or hand off to an execution phase.";
+export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = ".skc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.skc/**`; use the sanctioned `skc` CLI instead.";
+export declare const RALPLAN_MUTATION_BLOCK_MESSAGE = "Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `skc ralplan --write` (stage scratch files under a temp dir if needed). Product-code mutation tools and patch execution are blocked while ralplan is active; mutate only after the plan is approved and execution begins.";
+export declare const ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE = "Ultragoal goal-planning phase boundary: finish goal planning and record goals through `skc ultragoal` before editing code. Product-code mutation tools and patch execution are blocked until goal planning completes and execution begins.";
+type ToolWithEditMode = AgentTool & {
+    mode?: unknown;
+    customWireName?: unknown;
+};
+export interface WorkflowMutationGuardInput {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    tool: ToolWithEditMode;
+    args: unknown;
+    forceOverride?: boolean;
+    enforceWorkflowState?: boolean;
+    guardContext?: WorkflowGuardContext;
+}
+export interface WorkflowMutationDecision {
+    blocked: boolean;
+    message?: string;
+    targets: string[];
+    reason?: string;
+    command?: string;
+}
+export interface WorkflowGuardContext {
+    sessionId: string | null;
+    activeState: Awaited<ReturnType<typeof readVisibleSkillActiveState>>;
+    modeStates: ReadonlyMap<string, ModeState | null>;
+}
+interface ModeState {
+    active?: boolean;
+    current_phase?: string;
+    session_id?: string;
+    thread_id?: string;
+    [key: string]: unknown;
+}
+export declare function readWorkflowGuardContext(cwd: string, options?: {
+    sessionId?: string;
+    threadId?: string;
+}): Promise<WorkflowGuardContext>;
+export declare function assertWorkflowMutationRawPathsAllowed(input: {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    rawPaths: string[];
+    forceOverride?: boolean;
+    guardContext?: WorkflowGuardContext;
+}): Promise<void>;
+export declare function getWorkflowMutationDecision(input: WorkflowMutationGuardInput): Promise<WorkflowMutationDecision>;
+export declare function assertWorkflowMutationAllowed(input: WorkflowMutationGuardInput): Promise<void>;
+export {};

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -0,0 +1,55 @@
+import { type CanonicalSkcWorkflowSkill } from "./active-state";
+export { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION, WORKFLOW_STATE_VERSION, } from "./workflow-state-version";
+export type { CanonicalSkcWorkflowSkill };
+export type WorkflowStateMutationOwner = "skc-state-cli" | "skc-runtime" | "skc-hook";
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+export interface WorkflowStateContentChecksum {
+    algorithm: "sha256";
+    value: string;
+    covered_path: string;
+    computed_at: string;
+}
+export interface WorkflowStateReceipt {
+    version: 1;
+    skill: CanonicalSkcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    state_path: string;
+    storage_path: string;
+    mutated_at: string;
+    fresh_until: string;
+    status: WorkflowStateReceiptStatus;
+    mutation_id: string;
+    verb?: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced?: boolean;
+    paths?: string[];
+    content_sha256?: WorkflowStateContentChecksum;
+}
+export interface AuditEntry {
+    ts: string;
+    skill?: string;
+    category: string;
+    verb: string;
+    owner: WorkflowStateMutationOwner;
+    mutation_id: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced: boolean;
+    paths: string[];
+}
+export declare function workflowModeStateFileName(skill: CanonicalSkcWorkflowSkill): string;
+export declare function buildWorkflowStateReceipt(input: {
+    cwd: string;
+    skill: CanonicalSkcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    sessionId: string;
+    nowIso?: string;
+    mutationId?: string;
+}): WorkflowStateReceipt;
+export declare function workflowReceiptStatus(receipt: WorkflowStateReceipt | undefined, nowMs?: number): WorkflowStateReceiptStatus | undefined;
+export declare function canonicalWorkflowSkill(value: string): CanonicalSkcWorkflowSkill | null;
+export declare function sanctionedWorkflowStateCommand(skill: CanonicalSkcWorkflowSkill): string;
+export declare function describeWorkflowStateContract(skill: CanonicalSkcWorkflowSkill): string[];

package/dist/types/skill-state/workflow-state-version.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_VERSION = 2;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -0,0 +1,18 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+export type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * Commands advertised to ACP clients. Entries without a text-mode `handle`
+ * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't
+ * see commands it cannot drive.
+ */
+export declare const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[];
+/**
+ * Dispatch a slash command in ACP/text mode. Returns:
+ * - `false` when no builtin matched (or matched a TUI-only entry); the caller
+ *   should forward the input as a prompt.
+ * - `{ consumed: true }` when the command handled the input entirely.
+ * - `{ prompt }` when the command was handled but a residual prompt should be
+ *   sent to the model.
+ */
+export declare function executeAcpBuiltinSlashCommand(text: string, runtime: AcpBuiltinCommandRuntime): Promise<AcpBuiltinSlashCommandResult>;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -0,0 +1,27 @@
+import { type ComposerSubmissionOptions } from "../modes/types";
+import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
+export type { BuiltinSlashCommand, SubcommandDef } from "./types";
+/** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime & {
+    composer?: ComposerSubmissionOptions;
+};
+export declare function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined;
+/** Builtin command metadata used for slash-command autocomplete and help text. */
+export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;
+/**
+ * Unified registry exposed for cross-mode tooling. Each spec carries at least
+ * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the
+ * ACP dispatcher requires `handle` and skips TUI-only entries.
+ */
+export declare const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommandSpec>;
+/**
+ * Execute a builtin slash command in the interactive TUI.
+ *
+ * Returns `false` when no builtin matched. Returns `true` when a command
+ * consumed the input entirely. Returns a `string` when the command was handled
+ * but remaining text should be sent as a prompt.
+ */
+export declare function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<string | boolean>;
+/** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
+export declare function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined;
+export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };

package/dist/types/slash-commands/helpers/context-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/context` ACP-mode text. Tries the rich breakdown first
+ * (categories + auto-compact buffer + free slack) and falls back to the
+ * minimal "window/used" lines when the breakdown helper throws.
+ */
+export declare function buildContextReportText(runtime: SlashCommandRuntime): string;

package/dist/types/slash-commands/helpers/fast-status-report.d.ts

@@ -0,0 +1,82 @@
+import type { Model } from "@sayknow-cli/ai";
+/**
+ * A single line in the `/fast status` report: a labelled model and whether fast
+ * mode is effective for it. The `fast` flag is resolved by the caller
+ * (`buildFastStatusReport`) so each row can use the correct service tier — the
+ * main session tier for the current model / `modelRoles` roles, or the subagent
+ * tier (`task.serviceTier`) for `task.agentModelOverrides` roles.
+ */
+export interface FastStatusRow {
+    /** Display label, e.g. "현재 모델", "DEFAULT", "EXECUTOR". */
+    label: string;
+    /** Resolved model for this row, if any. */
+    model?: Model;
+    /** Whether fast mode is effective for this row's model. */
+    fast: boolean;
+}
+export interface FormatFastStatusReportArgs {
+    rows: FastStatusRow[];
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/** Title line of the `/fast status` report. */
+export declare const FAST_STATUS_TITLE = "Fast \uBAA8\uB4DC \uC0C1\uD0DC";
+/** The inactive marker shown for rows where fast mode does not apply. */
+export declare const FAST_STATUS_OFF = "off";
+/**
+ * Format a multiline `/fast status` report. Pure and shared by the CLI
+ * (`handle`) and TUI (`handleTui`) command branches so the two never drift.
+ * Each row's fast/off state is decided by the caller (see
+ * {@link buildFastStatusReport}) so per-row service-tier differences are honored.
+ */
+export declare function formatFastStatusReport(args: FormatFastStatusReportArgs): string;
+/** Minimal session surface needed to build the `/fast status` report. */
+export interface FastStatusSessionLike {
+    readonly model?: Model;
+    /** Fast predicate against the main session tier (current model + `modelRoles`). */
+    isFastForProvider(provider?: string): boolean;
+    /**
+     * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
+     * Used for the current-model row so it matches what the next request does.
+     * Optional so lightweight fakes can omit it; falls back to `isFastForProvider`.
+     */
+    isFastModeActive?(): boolean;
+    /** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
+    isFastForSubagentProvider(provider?: string): boolean;
+    resolveRoleModelWithThinking(role: string): {
+        model?: Model;
+    };
+}
+/** A role to enumerate in the report, with the tier source its subagent runs under. */
+export interface FastStatusRoleTarget {
+    id: string;
+    label: string;
+    /**
+     * True for `task.agentModelOverrides` roles (executor/architect/planner/critic)
+     * that run under `task.serviceTier`; false for `modelRoles` roles (default)
+     * that run under the main session tier.
+     */
+    isSubagentRole: boolean;
+}
+export interface BuildFastStatusReportArgs {
+    session: FastStatusSessionLike;
+    /** Role targets to enumerate, in display order. */
+    roleTargets: ReadonlyArray<FastStatusRoleTarget>;
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/**
+ * Build the `/fast status` report from a live session: the active/current model
+ * followed by each assigned role (subagent) model. Unassigned roles are skipped
+ * so the report mirrors the `/model` selector, which only badges assigned roles.
+ *
+ * Subagent roles (`task.agentModelOverrides`) are evaluated against the
+ * effective subagent tier (`task.serviceTier`), while the current model and
+ * `modelRoles` roles use the main session tier — matching where each model
+ * actually runs.
+ */
+export declare function buildFastStatusReport(args: BuildFastStatusReportArgs): string;

package/dist/types/slash-commands/helpers/format.d.ts

@@ -0,0 +1,10 @@
+import { type Theme } from "../../modes/theme/theme";
+/** Format a millisecond duration as a coarse-grained human label. */
+export declare function formatDuration(ms: number): string;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
+/**
+ * Render an ASCII progress bar with a trailing percent label.
+ * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
+ */
+export declare function renderAsciiBar(fraction: number | undefined, width?: number, uiTheme?: ProgressBarTheme): string;
+export {};

package/dist/types/slash-commands/helpers/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/mcp` handler. Shared by both dispatchers via the spec. */
+export declare function handleMcpAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/parse.d.ts

@@ -0,0 +1,33 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+export interface ParsedSubcommand {
+    verb: string;
+    rest: string;
+}
+export type ConfigScope = "user" | "project";
+export interface NamedScopeArgs {
+    name?: string;
+    scope: ConfigScope;
+    error?: string;
+}
+/**
+ * Parse a slash-invocation string into `name`/`args`.
+ *
+ * The separator is the earliest whitespace or `:` character so that both
+ * `/foo bar` and `/foo:bar` map to `{ name: "foo", args: "bar" }`.
+ */
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+/** Mark a command as fully consumed in the ACP shape. */
+export declare function commandConsumed(): {
+    consumed: true;
+};
+/** Emit a usage/error message and consume the command. */
+export declare function usage(text: string, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;
+/** Split `<verb> <rest>` on the first whitespace; lowercases `verb`. */
+export declare function parseSubcommand(input: string): ParsedSubcommand;
+export declare function errorMessage(error: unknown): string;
+/**
+ * Parse `<name?> [--scope project|user]`-style argument strings used by
+ * remove/rm-style subcommands. `name` is optional so callers can surface
+ * "name required" diagnostics with their own messaging.
+ */
+export declare function parseNamedScopeArgs(rest: string, invalidScopeMessage: string): NamedScopeArgs;

package/dist/types/slash-commands/helpers/ssh.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/ssh` handler. Shared by both dispatchers via the spec. */
+export declare function handleSshAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/todo.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/todo` handler. Shared by both dispatchers via the spec. */
+export declare function handleTodoAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/usage-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
+ * session exposes `fetchUsageReports`; otherwise falls back to the local
+ * session-manager tallies.
+ */
+export declare function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string>;

package/dist/types/slash-commands/types.d.ts

@@ -0,0 +1,120 @@
+import type { Settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession } from "../session/agent-session";
+import type { SessionManager } from "../session/session-manager";
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+    name: string;
+    description: string;
+    /** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+    usage?: string;
+}
+/** Declarative builtin slash command metadata used by autocomplete and help UI. */
+export interface BuiltinSlashCommand {
+    name: string;
+    description: string;
+    /** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
+    subcommands?: SubcommandDef[];
+    /** Static inline hint when command takes a simple argument (no subcommands). */
+    inlineHint?: string;
+    /** Higher values sort earlier in TUI slash-command autocomplete. */
+    priority?: number;
+}
+/** Parsed slash-command text after stripping the leading "/". */
+export interface ParsedSlashCommand {
+    name: string;
+    args: string;
+    text: string;
+}
+/**
+ * Result returned by a slash-command handler.
+ *
+ * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ prompt: string }` — command handled, pass `prompt` through as the new
+ *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
+ */
+export type SlashCommandResult = undefined | {
+    consumed: true;
+} | {
+    prompt: string;
+};
+/**
+ * Runtime visible to slash-command handlers that run in text/ACP mode.
+ *
+ * Both the TUI dispatcher (when invoking a `handle` via its adapter) and the
+ * ACP dispatcher pass this shape. Implementations MUST NOT depend on TUI-only
+ * state (editor, selectors, status line).
+ */
+export interface SlashCommandRuntime {
+    session: AgentSession;
+    sessionManager: SessionManager;
+    settings: Settings;
+    cwd: string;
+    /** Emit text to the operator. TUI maps to `ctx.showStatus`, ACP to `sessionUpdate`. */
+    output: (text: string) => Promise<void> | void;
+    /** Re-advertise the available command list (no-op outside ACP). */
+    refreshCommands: () => Promise<void> | void;
+    /**
+     * Reload plugin state (caches, slash command registry, project registries)
+     * and re-emit available commands. `/move` uses this so the session sees a
+     * consistent view after project-scope changes.
+     */
+    reloadPlugins: () => Promise<void>;
+    notifyTitleChanged?: () => Promise<void> | void;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+/**
+ * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
+ * mode context plus the background-detach hook. Intentionally narrower than
+ * `SlashCommandRuntime` so existing callers can keep building it from just
+ * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
+ * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
+ * from `ctx`.
+ */
+export interface TuiSlashCommandRuntime {
+    ctx: InteractiveModeContext;
+    handleBackgroundCommand: () => void;
+}
+/** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
+export interface SlashCommandSpec extends BuiltinSlashCommand {
+    aliases?: string[];
+    /** When false, the dispatcher refuses to handle invocations that include arguments. */
+    allowArgs?: boolean;
+    /**
+     * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
+     * when building `available_commands_update` payloads so the client receives
+     * mode-appropriate copy (e.g. `/dump` advertises "Return full transcript as
+     * plain text" in ACP rather than the TUI's clipboard-centric copy).
+     */
+    acpDescription?: string;
+    /**
+     * ACP-specific override for the advertised input hint. `subcommands`-only
+     * specs that historically advertised `<subcommand>` / `[on|off|status]` /
+     * `info|delete` to ACP clients carry the hint here so the unification does
+     * not silently drop it from `available_commands_update`.
+     */
+    acpInputHint?: string;
+    /**
+     * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
+     * and, via the TUI adapter, when no `handleTui` override is provided.
+     */
+    handle?: (command: ParsedSlashCommand, runtime: SlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+    /**
+     * TUI-only handler that supersedes `handle` when both are present. Use for
+     * selectors, wizards, dashboards, and anything else that requires
+     * `InteractiveModeContext`.
+     */
+    handleTui?: (command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+}
+/**
+ * @deprecated Use `SlashCommandRuntime` directly. Retained as an alias so
+ * downstream code that imported the ACP-specific name keeps compiling.
+ */
+export type AcpBuiltinCommandRuntime = SlashCommandRuntime;
+/** Result returned by `executeAcpBuiltinSlashCommand`. */
+export type AcpBuiltinSlashCommandResult = false | {
+    consumed: true;
+} | {
+    prompt: string;
+};

package/dist/types/ssh/config-writer.d.ts

@@ -0,0 +1,49 @@
+export interface SSHHostConfig {
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    description?: string;
+    compat?: boolean;
+}
+export interface SSHConfigFile {
+    hosts?: Record<string, SSHHostConfig>;
+}
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readSSHConfigFile(filePath: string): Promise<SSHConfigFile>;
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void>;
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateHostName(name: string): string | undefined;
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export declare function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export declare function removeSSHHost(filePath: string, name: string): Promise<void>;
+/**
+ * List all host names in a config file.
+ */
+export declare function listSSHHosts(filePath: string): Promise<string[]>;