@sayknow-cli/coding-agent 0.3.11 → 0.3.13

package/dist/types/modes/runtime-init.d.ts

@@ -1,21 +0,0 @@
-import type { ExtensionError, ExtensionUIContext } from "../extensibility/extensions/types";
-import type { AgentSession } from "../session/agent-session";
-/** Action name for an extension-originated send failure. */
-export type ExtensionSendAction = "extension_send" | "extension_send_user";
-export interface InitializeExtensionsOptions {
-    /** Reports an error thrown by an extension-initiated send. */
-    reportSendError: (action: ExtensionSendAction, error: Error) => void;
-    /** Reports a runtime error surfaced through {@link ExtensionRunner.onError}. */
-    reportRuntimeError: (error: ExtensionError) => void;
-    /** Optional shutdown hook (rpc mode signals its loop; print mode is a no-op). */
-    onShutdown?: () => void;
-    /** Optional UI context (rpc supplies one; print runs headless). */
-    uiContext?: ExtensionUIContext;
-}
-/**
- * Initialize the session's extension runner with the standard action set
- * shared by non-interactive modes, then emit `session_start`.
- *
- * No-op when the session was constructed without an extension runner.
- */
-export declare function initializeExtensions(session: AgentSession, options: InitializeExtensionsOptions): Promise<void>;

package/dist/types/modes/session-observer-registry.d.ts

@@ -1,26 +0,0 @@
-import type { AgentProgress } from "../task";
-import type { EventBus } from "../utils/event-bus";
-export interface ObservableSession {
-    id: string;
-    kind: "main" | "subagent";
-    label: string;
-    agent?: string;
-    description?: string;
-    status: "active" | "completed" | "failed" | "aborted";
-    sessionFile?: string;
-    lastUpdate: number;
-    /** Latest progress snapshot from the subagent executor */
-    progress?: AgentProgress;
-}
-export declare class SessionObserverRegistry {
-    #private;
-    /** Add a change listener. Returns unsubscribe function. */
-    onChange(cb: () => void): () => void;
-    setMainSession(sessionFile?: string): void;
-    getSessions(): ObservableSession[];
-    getActiveSubagentCount(): number;
-    /** Clear all tracked sessions (e.g. on session switch). Keeps EventBus subscriptions and listeners. */
-    resetSessions(): void;
-    dispose(): void;
-    subscribeToEventBus(eventBus: EventBus): void;
-}

package/dist/types/modes/shared/agent-wire/approval-gate.d.ts

@@ -1,57 +0,0 @@
-/**
- * Ralplan approval + ultragoal execution gate mapping (#317).
- *
- * Maps the two human-gated lifecycle decisions onto `workflow_gate` events:
- *  - ralplan `pending approval` -> `workflow_gate` { kind: "approval" } whose
- *    answer is one of approve / request-changes / reject (+ optional comments);
- *  - ultragoal execution sign-off -> `workflow_gate` { kind: "execution" } whose
- *    answer is approve / decline (+ optional reason).
- *
- * Gates remain mandatory; the external agent substitutes for the human at the
- * answer boundary only. Declining / requesting changes is honored and is NEVER
- * silently treated as approval.
- *
- * This is the pure mapping primitive; routing ralplan/ultragoal through it when
- * an unattended controller + gate broker are attached is wired with the transport
- * in #321 and exercised end-to-end by #323.
- */
-import type { RpcWorkflowGateContext } from "../../rpc/rpc-types";
-import type { OpenGateInput } from "./workflow-gate-broker";
-export type ApprovalDecision = "approve" | "request-changes" | "reject";
-export type ExecutionDecision = "approve" | "decline";
-export interface ApprovalGateAnswer {
-    decision: ApprovalDecision;
-    comments?: string;
-}
-export interface ExecutionGateAnswer {
-    decision: ExecutionDecision;
-    reason?: string;
-}
-export interface ApprovalGateResult {
-    approved: boolean;
-    decision: ApprovalDecision;
-    comments?: string;
-}
-export interface ExecutionGateResult {
-    approved: boolean;
-    decision: ExecutionDecision;
-    reason?: string;
-}
-export declare class ApprovalGateError extends Error {
-    readonly code: "invalid_answer_shape" | "unknown_decision" | "missing_comments";
-    constructor(code: "invalid_answer_shape" | "unknown_decision" | "missing_comments", message: string);
-}
-/** Build the ralplan `pending approval` -> `workflow_gate { kind: "approval" }` open-input. */
-export declare function approvalGate(context?: RpcWorkflowGateContext): OpenGateInput;
-/** Build the ultragoal execution sign-off -> `workflow_gate { kind: "execution" }` open-input. */
-export declare function executionGate(context?: RpcWorkflowGateContext): OpenGateInput;
-/**
- * Decode a ralplan approval answer. `request-changes` requires comments and is
- * NEVER treated as approval; only an explicit `approve` advances.
- */
-export declare function decodeApproval(answer: unknown): ApprovalGateResult;
-/**
- * Decode an ultragoal execution answer. Only an explicit `approve` advances;
- * `decline` is honored and never silently approved.
- */
-export declare function decodeExecution(answer: unknown): ExecutionGateResult;

package/dist/types/modes/shared/agent-wire/command-contract.d.ts

@@ -1,18 +0,0 @@
-/**
- * Canonical command-surface boundary for the agent-wire adapters.
- *
- * RPC and Bridge SHARE the JSONL `RpcCommand` grammar and dispatch it through
- * the single `dispatchRpcCommand` entry in `command-dispatch.ts`. This module
- * re-exports that command surface so the shared contract has one documented home.
- *
- * ACP does NOT use `RpcCommand`. It keeps its richer `@agentclientprotocol/sdk`
- * command surface (fork/resume/elicitation/session-mode/session-model) and only
- * shares the lower session/event layer (`AgentWireEventPayload`). ACP must never
- * import `dispatchRpcCommand`.
- *
- * Event semantics are intentionally elsewhere: `event-contract.ts` owns the event
- * types + registry and `event-observation.ts` owns the single semantic mapping.
- */
-export type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
-export { dispatchRpcCommand, type RpcCommandDispatchContext } from "./command-dispatch";
-export { isRpcCommandType, RPC_COMMAND_TYPES, type RpcCommandType } from "./scopes";

package/dist/types/modes/shared/agent-wire/command-dispatch.d.ts

@@ -1,37 +0,0 @@
-import type { AgentTool } from "@sayknow-cli/agent-core";
-import type { ExtensionUIContext } from "../../../extensibility/extensions";
-import type { AgentSession } from "../../../session/agent-session";
-import type { RpcCommand, RpcExtensionUIRequest, RpcHostToolDefinition, RpcHostUriSchemeDefinition, RpcResponse, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGateResolution, RpcWorkflowGateResponse } from "../../rpc/rpc-types";
-export type RpcCommandDispatchOutput = (obj: RpcResponse | RpcExtensionUIRequest | object) => void;
-export interface RpcHostToolRegistry {
-    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
-}
-export interface RpcHostUriRegistry {
-    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
-}
-/**
- * Optional unattended control plane wired into RPC dispatch (#318/#319/#323).
- * When present, `negotiate_unattended` and `workflow_gate_response` route here
- * instead of falling through to the unknown-command path.
- */
-export interface RpcUnattendedControlPlane {
-    /** Enter unattended mode (fail-closed); throws an Error on refusal. */
-    negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
-    /** Resolve a pending workflow gate with the agent's answer. */
-    resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
-    /** List unresolved durable workflow gates for reconnect replay. */
-    listPendingGates?(): import("../../rpc/rpc-types").RpcWorkflowGate[];
-    isUnattended?(): boolean;
-    preflightCommand?(command: RpcCommand): void;
-    reconcileUsage?(phase?: string): void;
-}
-export interface RpcCommandDispatchContext {
-    session: AgentSession;
-    output: RpcCommandDispatchOutput;
-    hostToolRegistry: RpcHostToolRegistry;
-    hostUriRegistry: RpcHostUriRegistry;
-    createUiContext: () => Pick<ExtensionUIContext, "notify">;
-    unattendedControlPlane?: RpcUnattendedControlPlane;
-}
-export declare function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[];
-export declare function dispatchRpcCommand(command: RpcCommand, context: RpcCommandDispatchContext): Promise<RpcResponse>;

package/dist/types/modes/shared/agent-wire/command-validation.d.ts

@@ -1,2 +0,0 @@
-import type { RpcCommand } from "../../rpc/rpc-types";
-export declare function isRpcCommand(value: unknown): value is RpcCommand;

package/dist/types/modes/shared/agent-wire/deep-interview-gate.d.ts

@@ -1,94 +0,0 @@
-/**
- * Deep-interview gate mapping (#316).
- *
- * Converts deep-interview `ask`-tool questions into machine-addressable
- * `workflow_gate` { kind: "question" } events (option set + free-text shape
- * encoded in `schema`/`options`) and decodes a `workflow_gate_response` answer
- * back into the exact QuestionResult shape the human path produces, so ambiguity
- * scoring/state updates proceed identically whether a human or an agent answers.
- *
- * This is the pure mapping primitive. Routing the ask tool through it (instead of
- * the interactive select/editor UI) when an unattended controller + gate broker
- * are attached is wired with the transport in #321 and exercised by #323.
- */
-import type { RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
-import type { OpenGateInput } from "./workflow-gate-broker";
-/** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
-export declare const GATE_OTHER_OPTION = "Other (type your own)";
-/** Optional structured deep-interview round metadata supplied by the agent. */
-export interface AskGateDeepInterviewState {
-    round_id?: string;
-    round: number;
-    component: string;
-    dimension: string;
-    ambiguity: number;
-}
-export interface AskGateWorkflowGateMeta {
-    stage: RpcWorkflowStage;
-    kind: RpcWorkflowGateKind;
-}
-export interface AskGateQuestion {
-    id: string;
-    question: string;
-    options: Array<{
-        label: string;
-    }>;
-    multi?: boolean;
-    recommended?: number;
-    /**
-     * Structured round metadata. When present it is the authoritative source for gate
-     * `stage_state`; when absent, the question text is regex-parsed as a fallback.
-     */
-    deepInterview?: AskGateDeepInterviewState;
-    /** Override the emitted workflow gate address for non-deep-interview ask prompts. */
-    workflowGate?: AskGateWorkflowGateMeta;
-}
-export interface AskGateResult {
-    id: string;
-    question: string;
-    options: string[];
-    multi: boolean;
-    selectedOptions: string[];
-    customInput?: string;
-    clarificationQuestion?: string;
-}
-/**
- * The answer shape an agent returns for a deep-interview question gate.
- *
- * `selected` are picked option labels; free text is conveyed by `other: true`
- * plus `custom`, encoded separately from `selected` so a real option whose label
- * happens to equal the display sentinel can never collide with the free-text path.
- *
- * `action: "clarify"` is a non-answer. It lets a Deep Interview user ask about
- * the presented choices without advancing the round, scoring ambiguity, or
- * recording selection state.
- */
-export type DeepInterviewGateAnswer = {
-    selected: string[];
-    other?: false;
-    custom?: undefined;
-    action?: "answer";
-} | {
-    selected: string[];
-    other: true;
-    custom: string;
-    action?: "answer";
-} | {
-    action: "clarify";
-    question: string;
-};
-export declare class DeepInterviewGateError extends Error {
-    readonly code: "invalid_answer_shape" | "unknown_option" | "multi_not_allowed" | "missing_custom" | "missing_clarification" | "empty_selection" | "duplicate_selection";
-    constructor(code: "invalid_answer_shape" | "unknown_option" | "multi_not_allowed" | "missing_custom" | "missing_clarification" | "empty_selection" | "duplicate_selection", message: string);
-}
-/** Build the `workflow_gate` open-input for one ask question. */
-export declare function questionToGate(question: AskGateQuestion): OpenGateInput;
-/**
- * Decode a gate answer into the QuestionResult the interactive path produces.
- * Selections are de-duplicated (the interactive UI stores them in a Set), and
- * free text is taken from `other`/`custom`. Throws DeepInterviewGateError on a
- * semantically invalid answer.
- */
-export declare function gateAnswerToResult(question: AskGateQuestion, answer: unknown): AskGateResult;
-/** Convenience: map a batch of ask questions to gate open-inputs. */
-export declare function questionsToGates(questions: AskGateQuestion[]): OpenGateInput[];

package/dist/types/modes/shared/agent-wire/event-contract.d.ts

@@ -1,103 +0,0 @@
-/**
- * Canonical agent-wire contract: the single transport-neutral source of truth
- * for AgentSession events and bounded owner observations.
- *
- * Two distinct consumer-facing shapes, deliberately NOT collapsed into one:
- * - `AgentWireEventPayload`: rich, full `AgentSessionEvent` for renderers
- *   (ACP SDK notifications, RPC/Bridge event frames).
- * - `AgentWireOwnerObservation`: bounded/redacted owner evidence for control
- *   planes (Harness). Never carries assistant text, message deltas, raw tool
- *   args, raw command output, raw tool results, answers, or oversize strings.
- *
- * The exhaustive `AGENT_SESSION_EVENT_TYPE_REGISTRY` lives here so that adding
- * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
- * conformance tests can assert fixture coverage equals the registry exactly.
- */
-import type { AssistantMessageEvent } from "@sayknow-cli/ai";
-import type { AgentSessionEvent } from "../../../session/agent-session";
-/** Wire protocol version. Bump on breaking envelope/semantic changes. */
-export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
-export type AgentWireProtocolVersion = typeof AGENT_WIRE_PROTOCOL_VERSION;
-/** The discriminant of every `AgentSessionEvent` the agent can emit. */
-export type AgentWireEventType = AgentSessionEvent["type"];
-/** Every agent-session event type, derived from the exhaustive registry. */
-export declare const AGENT_WIRE_EVENT_TYPES: readonly AgentWireEventType[];
-/**
- * Rich event payload. Carries the full `AgentSessionEvent` so renderers (ACP,
- * RPC, Bridge) can present message content, tool args/results, todo state, etc.
- */
-export interface AgentWireEventPayload {
-    event_type: AgentWireEventType;
-    event: AgentSessionEvent;
-}
-export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent ? TEvent extends {
-    type: string;
-} ? Omit<TEvent, "partial" | "message" | "error"> : never : never;
-export interface AgentWireCompactMessageUpdatePayload {
-    event_type: "message_update";
-    /** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
-    compact: true;
-    message_id: string | null;
-    content_index: number | null;
-    assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
-    /** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
-    checkpoint_message?: Extract<AgentSessionEvent, {
-        type: "message_update";
-    }>["message"];
-    checkpoint_reason?: "periodic";
-}
-export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
-/**
- * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
- * the Harness `ObservedSignal` set; the Harness type aliases this in a later
- * step so there is a single source of truth.
- */
-export type AgentWireObservedSignal = "SessionStart" | "prompt-accepted" | "tool-call" | "test-running" | "commit-created" | "completed" | "error" | "streaming" | "idle";
-export type AgentWireSeverity = "info" | "warn" | "critical";
-/**
- * Bounded, redacted owner observation. Evidence may include ids, names,
- * categories, statuses, cursors, timestamps, short codes, and bounded short
- * messages ONLY. It must never carry assistant text, message deltas, raw tool
- * args, raw command output, raw tool result content, answers, or oversize
- * strings.
- */
-export interface AgentWireOwnerObservation {
-    /** Set when this observation derives from an `AgentSessionEvent`. */
-    eventType?: AgentWireEventType;
-    /** Set when this observation derives from a non-event wire frame. */
-    frameType?: string;
-    /** Owner event kind (e.g. `rpc_tool_started`). */
-    kind: string;
-    /** Bounded observed signal, or null when the frame carries no signal. */
-    signal: AgentWireObservedSignal | null;
-    /** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
-    evidence: Record<string, unknown>;
-    /** Severity for the emitted event. */
-    severity: AgentWireSeverity;
-    /** Never-drop observations: must be enqueued in order, never coalesced away. */
-    semantic: boolean;
-    /** Coalescing key for high-frequency non-semantic frames; null otherwise. */
-    coalesceKey: string | null;
-}
-/** Top-level frame categories carried over any agent-wire transport. */
-export type AgentWireFrameType = "ready" | "event" | "response" | "ui_request" | "permission_request" | "host_tool_call" | "host_uri_request" | "reset" | "workflow_gate" | "error";
-/**
- * Universal frame envelope. Every frame on every transport carries these
- * fields so clients can order (`seq`), resume (`seq` cursor), and correlate
- * request/response pairs (`correlation_id`).
- */
-export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = AgentWireFrameType, TPayload = unknown> {
-    protocol_version: AgentWireProtocolVersion;
-    session_id: string;
-    /** Monotonic per-session sequence number, starting at 1. */
-    seq: number;
-    /** Unique id for this frame. */
-    frame_id: string;
-    /** Ties a request frame to its response frame, when applicable. */
-    correlation_id?: string;
-    type: TType;
-    payload: TPayload;
-}
-/** An `AgentSessionEvent` serialized into a versioned wire frame. */
-export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
-export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

package/dist/types/modes/shared/agent-wire/event-envelope.d.ts

@@ -1,60 +0,0 @@
-import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentWireCompactAssistantMessageEvent, type AgentWireCompactEventFrame, type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
-export declare const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
-/**
- * Resolve the stable wire event-type for an `AgentSessionEvent`.
- *
- * Exhaustive over the union; adding a variant without a case is a type error.
- */
-export declare function agentSessionEventType(event: AgentSessionEvent): AgentWireEventType;
-/**
- * Per-session monotonic frame builder. One instance per active session; `seq`
- * starts at 1 and increments per frame so clients can order and resume.
- */
-export declare class AgentWireFrameSequencer {
-    #private;
-    constructor(sessionId: string);
-    /** The session id stamped onto every frame this sequencer produces. */
-    get sessionId(): string;
-    /** The seq assigned to the most recently produced frame (0 before any). */
-    get lastSeq(): number;
-    /** Build the next envelope of the given type with a fresh seq + frame id. */
-    next<TType extends AgentWireFrameType, TPayload>(type: TType, payload: TPayload, correlationId?: string): AgentWireFrameEnvelope<TType, TPayload>;
-}
-/** Back-compat alias for {@link AgentWireFrameSequencer}. */
-export declare const BridgeFrameSequencer: typeof AgentWireFrameSequencer;
-export type BridgeFrameSequencer = AgentWireFrameSequencer;
-/** Serialize a single `AgentSessionEvent` into a canonical `event` wire frame. */
-export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
-/** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
-export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
-export declare function sanitizeAssistantMessageEventForCompact(assistantMessageEvent: Extract<AgentSessionEvent, {
-    type: "message_update";
-}>["assistantMessageEvent"]): AgentWireCompactAssistantMessageEvent;
-export interface AgentWireCompactMessageUpdateOptions {
-    checkpointInterval?: number;
-}
-/**
- * Stateful compact event serializer for opt-in RPC clients.
- *
- * Only `message_update` changes shape: it carries the immutable provider delta
- * plus message/content identifiers, with periodic full-message checkpoints that
- * are cloned synchronously before the caller returns to the event loop. All other
- * event variants remain canonical full event frames so legacy bridge/RPC behavior
- * and terminal `message_end` reconstruction are unchanged.
- */
-export declare class AgentWireCompactEventEncoder {
-    #private;
-    constructor(sequencer: AgentWireFrameSequencer, options?: AgentWireCompactMessageUpdateOptions);
-    frame(event: AgentSessionEvent): AgentWireCompactEventFrame;
-}
-export declare function toAgentWireCompactEventFrame(event: AgentSessionEvent, encoder: AgentWireCompactEventEncoder): AgentWireCompactEventFrame;
-/** Back-compat alias for {@link toAgentWireEventFrame}. */
-export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
-/**
- * Serialize a `workflow_gate` event into a sequenced wire frame (#321). The
- * gate_id is stamped as the correlation id so the answer (posted to the
- * ui-responses endpoint) can be matched, and the monotonic `seq` gives replay
- * while `frame_id` + gate_id give idempotency.
- */
-export declare function toBridgeWorkflowGateFrame(gate: import("../../rpc/rpc-types").RpcWorkflowGate, sequencer: AgentWireFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;

package/dist/types/modes/shared/agent-wire/event-observation.d.ts

@@ -1,37 +0,0 @@
-/**
- * Canonical AgentSession event observation: the single semantic mapping from
- * `AgentSessionEvent` (and non-event wire frames) to bounded owner observations.
- *
- * This is the one place that derives `AgentWireOwnerObservation`s. Harness (and
- * any other owner control plane) consumes these instead of re-parsing the wire
- * protocol with private knowledge.
- *
- * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses,
- * cursors, timestamps, and short codes/messages. Never assistant text, message
- * deltas, command output, raw args, or raw tool results.
- */
-import type { AgentSessionEvent } from "../../../session/agent-session";
-import type { AgentWireEventPayload, AgentWireOwnerObservation } from "./event-contract";
-import { toAgentWireEventPayload } from "./event-envelope";
-/** True when a tool name or command indicates a test-runner invocation. */
-export declare function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean;
-/** Only accept a known closed-vocabulary tool status; reject arbitrary strings. */
-export declare function boundedStatus(v: unknown): string | undefined;
-/** Accept only identifier-shaped tokens (e.g. RPC command names); reject free text. */
-export declare function boundedToken(v: unknown): string | undefined;
-/**
- * Map a single `AgentSessionEvent` to its bounded owner observation, or null
- * when the event carries no owner-facing signal.
- */
-export declare function observeAgentSessionEvent(event: AgentSessionEvent): AgentWireOwnerObservation | null;
-/** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
-export { toAgentWireEventPayload };
-/** Observe the bounded owner signal carried by a rich event payload. */
-export declare function observeAgentWireEventPayload(payload: AgentWireEventPayload): AgentWireOwnerObservation | null;
-/**
- * Map a single outbound RPC wire frame (docs/rpc.md) to a bounded owner
- * observation, or null when the frame carries no owner-facing signal. Event
- * frames delegate to {@link observeAgentWireEventPayload}; non-event frames are
- * mapped here so owners never re-parse protocol semantics privately.
- */
-export declare function observeRpcOutboundFrame(frame: Record<string, unknown>): AgentWireOwnerObservation | null;

package/dist/types/modes/shared/agent-wire/handshake.d.ts

@@ -1,56 +0,0 @@
-import type { RpcUnattendedDeclaration } from "../../rpc/rpc-types";
-import { BRIDGE_PROTOCOL_VERSION, type BridgeFrameType } from "./protocol";
-import type { BridgeCommandScope } from "./scopes";
-export type BridgeCapability = "events" | "prompt" | "permission" | "elicitation" | "ui.declarative" | "ui.editor" | "ui.terminal_input" | "host_tools" | "host_uri" | "client_bridge.read_text_file" | "client_bridge.write_text_file" | "client_bridge.create_terminal" | "workflow_gate";
-export interface BridgeProtocolRange {
-    min: number;
-    max: number;
-}
-export interface BridgeHandshakeRequest {
-    protocol_version_range: BridgeProtocolRange;
-    capabilities: BridgeCapability[];
-    requested_scopes: BridgeCommandScope[];
-    last_seq?: number;
-    /** Optional unattended declaration (budget + scope + action allowlist) for #318/#319. */
-    unattended?: RpcUnattendedDeclaration;
-}
-export interface BridgeEndpointDescriptor {
-    events: string;
-    commands: string;
-    uiResponses: string;
-    claimControl: string;
-    disconnectControl: string;
-    hostToolResults: string;
-    hostUriResults: string;
-}
-export interface BridgeHandshakeAccepted {
-    status: "accepted";
-    protocol_version: typeof BRIDGE_PROTOCOL_VERSION;
-    session_id: string;
-    accepted_capabilities: BridgeCapability[];
-    accepted_scopes: BridgeCommandScope[];
-    unsupported: BridgeCapability[];
-    endpoints: BridgeEndpointDescriptor;
-    frame_types: BridgeFrameType[];
-    /** Echoed unattended declaration when one was supplied and accepted (#321). */
-    accepted_unattended?: RpcUnattendedDeclaration;
-    /** Server-side accepted unattended mode after live negotiation, not just declaration echo. */
-    unattended_active?: boolean;
-}
-export interface BridgeHandshakeRejected {
-    status: "rejected";
-    reason: "incompatible_version" | "unauthorized" | "invalid_request";
-    message: string;
-}
-export type BridgeHandshakeResponse = BridgeHandshakeAccepted | BridgeHandshakeRejected;
-/** Shape-validate an optional unattended declaration carried on the handshake. */
-export declare function isUnattendedDeclarationShape(value: unknown): value is RpcUnattendedDeclaration;
-export declare function isBridgeHandshakeRequest(value: unknown): value is BridgeHandshakeRequest;
-export declare function negotiateBridgeHandshake(request: BridgeHandshakeRequest, server: {
-    sessionId: string;
-    capabilities: readonly BridgeCapability[];
-    scopes: readonly BridgeCommandScope[];
-    endpoints: BridgeEndpointDescriptor;
-    frameTypes: readonly BridgeFrameType[];
-    acceptedUnattended?: RpcUnattendedDeclaration;
-}): BridgeHandshakeResponse;

package/dist/types/modes/shared/agent-wire/host-tool-bridge.d.ts

@@ -1,16 +0,0 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
-import type { RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate } from "../../rpc/rpc-types";
-type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
-export declare function isRpcHostToolResult(value: unknown): value is RpcHostToolResult;
-export declare function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate;
-export declare class RpcHostToolBridge {
-    #private;
-    constructor(output: RpcHostToolOutput);
-    getToolNames(): string[];
-    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
-    handleResult(frame: RpcHostToolResult): boolean;
-    handleUpdate(frame: RpcHostToolUpdate): boolean;
-    requestExecution(definition: RpcHostToolDefinition, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>): Promise<AgentToolResult<unknown>>;
-    rejectAllPending(message: string): void;
-}
-export {};

package/dist/types/modes/shared/agent-wire/host-uri-bridge.d.ts

@@ -1,17 +0,0 @@
-import { InternalUrlRouter } from "../../../internal-urls";
-import type { InternalResource, InternalUrl, ResolveContext, WriteContext } from "../../../internal-urls/types";
-import type { RpcHostUriCancelRequest, RpcHostUriRequest, RpcHostUriResult, RpcHostUriSchemeDefinition } from "../../rpc/rpc-types";
-type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
-export declare function isRpcHostUriResult(value: unknown): value is RpcHostUriResult;
-export declare class RpcHostUriBridge {
-    #private;
-    constructor(output: RpcHostUriOutput, router?: InternalUrlRouter);
-    getSchemes(): string[];
-    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
-    clear(message?: string): void;
-    handleResult(frame: RpcHostUriResult): boolean;
-    rejectAllPending(message: string): void;
-    requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
-    requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
-}
-export {};

package/dist/types/modes/shared/agent-wire/protocol.d.ts

@@ -1,25 +0,0 @@
-/**
- * Shared agent-wire protocol primitives for SKC bridge surfaces.
- *
- * The canonical event/frame contract now lives in `event-contract.ts`. This
- * module re-exports it under the historical `Bridge*` names so existing RPC and
- * Bridge code keeps compiling while the adapters migrate to the canonical
- * `AgentWire*` names. See `.skc/specs/deep-interview-reconcile-rpc-adapters.md`.
- */
-import type { AgentWireEventFrame, AgentWireEventPayload, AgentWireEventType, AgentWireFrameEnvelope, AgentWireFrameType } from "./event-contract";
-/** Wire protocol version. Bump on breaking envelope/semantic changes. */
-export declare const BRIDGE_PROTOCOL_VERSION: 2;
-/** The discriminant of every `AgentSessionEvent` the agent can emit. */
-export type AgentSessionEventType = AgentWireEventType;
-/** Every agent-session event type, derived from the exhaustive registry. */
-export declare const AGENT_SESSION_EVENT_TYPES: readonly AgentSessionEventType[];
-/** Top-level frame categories carried over any bridge transport. */
-export type BridgeFrameType = AgentWireFrameType;
-/** Universal frame envelope. See {@link AgentWireFrameEnvelope}. */
-export type BridgeFrameEnvelope<TType extends BridgeFrameType = BridgeFrameType, TPayload = unknown> = AgentWireFrameEnvelope<TType, TPayload>;
-/** Payload carried by an `event` frame. See {@link AgentWireEventPayload}. */
-export type BridgeEventPayload = AgentWireEventPayload;
-/** An `AgentSessionEvent` serialized into a versioned wire frame. */
-export type BridgeEventFrame = AgentWireEventFrame;
-/** A `workflow_gate` event serialized into a versioned wire frame (#321). */
-export type BridgeWorkflowGateFrame = BridgeFrameEnvelope<"workflow_gate", import("../../rpc/rpc-types").RpcWorkflowGate>;

package/dist/types/modes/shared/agent-wire/responses.d.ts

@@ -1,4 +0,0 @@
-/** Shared RPC-compatible response helpers for agent-wire consumers. */
-import type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
-export declare function rpcSuccess<T extends RpcCommand["type"]>(id: string | undefined, command: T, data?: object | null): RpcResponse;
-export declare function rpcError(id: string | undefined, command: string, error: string | object): RpcResponse;

package/dist/types/modes/shared/agent-wire/scopes.d.ts

@@ -1,18 +0,0 @@
-/**
- * Coarse bridge authorization scopes for RPC commands.
- *
- * The v1 bridge exposes a network-reachable control surface, so every
- * `RpcCommand` must be assigned to one coarse scope before any REST handler can
- * dispatch it. The registry is intentionally typed as `Record<RpcCommandType,
- * BridgeCommandScope>` so adding a new RPC command without a scope is a compile
- * failure.
- */
-import type { RpcCommand } from "../../rpc/rpc-types";
-export type RpcCommandType = RpcCommand["type"];
-export type BridgeCommandScope = "prompt" | "control" | "bash" | "export" | "session" | "model" | "message:read" | "host_tools" | "host_uri" | "admin";
-export declare const BRIDGE_COMMAND_SCOPES: readonly BridgeCommandScope[];
-export declare const RPC_COMMAND_TYPES: readonly RpcCommandType[];
-export declare function isRpcCommandType(value: unknown): value is RpcCommandType;
-export declare const MANDATORY_FLOOR_COMMAND_SCOPES: readonly BridgeCommandScope[];
-export declare function scopeForRpcCommand(type: RpcCommandType): BridgeCommandScope;
-export declare function isRpcCommandAllowed(type: RpcCommandType, scopes: ReadonlySet<BridgeCommandScope>): boolean;

package/dist/types/modes/shared/agent-wire/session-registry.d.ts

@@ -1,25 +0,0 @@
-export type RpcSessionTransport = "stdio" | "bridge" | "socket";
-export interface RpcSessionRecord {
-    sessionId: string;
-    pid: number;
-    transport: RpcSessionTransport;
-    cwd: string;
-    model?: string;
-    /** ISO-8601 start timestamp. */
-    startedAt: string;
-    /** Reachable endpoint for persistent transports (issue 09); absent for stdio. */
-    endpoint?: string;
-}
-/**
- * Write (or replace) the registry record for a session. The record is written to
- * a same-directory temp file and atomically renamed into place so a concurrent
- * reader never observes (and reaps) a partially-written record.
- */
-export declare function registerRpcSession(record: RpcSessionRecord, agentDir?: string): Promise<string>;
-/** Remove a session's registry record. Best-effort: a missing file is not an error. */
-export declare function unregisterRpcSession(sessionId: string, agentDir?: string): Promise<void>;
-/**
- * List live RPC sessions, reaping records whose process is gone or whose file is
- * unparseable. Returns records sorted by `startedAt` ascending.
- */
-export declare function listRpcSessions(agentDir?: string): Promise<RpcSessionRecord[]>;