@gajae-code/coding-agent 0.10.1 → 0.11.0

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 "@gajae-code/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/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 "@gajae-code/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 GJC 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 `.gjc/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[]>;

package/dist/types/modes/shared/agent-wire/ui-request-broker.d.ts

@@ -1,42 +0,0 @@
-export type UiRequestCancelReason = "timeout" | "abort" | "disconnect";
-export interface UiRequestCancelled {
-    status: "cancelled";
-    reason: UiRequestCancelReason;
-}
-export type UiRequestResolution<TResponse> = TResponse | UiRequestCancelled;
-export type UiBrokerResponseResult = {
-    status: "accepted";
-} | {
-    status: "rejected";
-    code: "not_controller" | "already_resolved" | "unknown_request";
-};
-export interface UiRequestBrokerOptions<TRequest> {
-    emitRequest: (correlationId: string, request: TRequest) => void;
-}
-export interface UiRequestOptions {
-    correlationId?: string;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-/**
- * Broker for one active session. v1 supports one controller token at a time;
- * other clients may observe frames but cannot answer correlated requests.
- */
-export declare class UiRequestBroker<TRequest, TResponse> {
-    #private;
-    constructor(options: UiRequestBrokerOptions<TRequest>);
-    get ownerToken(): string | undefined;
-    get pendingCount(): number;
-    claimController(ownerToken?: string): {
-        status: "claimed";
-        ownerToken: string;
-    } | {
-        status: "busy";
-    };
-    releaseController(ownerToken: string): boolean;
-    request(request: TRequest, options?: UiRequestOptions): Promise<UiRequestResolution<TResponse>>;
-    respond(correlationId: string, ownerToken: string, response: TResponse): UiBrokerResponseResult;
-    cancelAll(reason: UiRequestCancelReason): void;
-    cancel(correlationId: string, reason: UiRequestCancelReason): boolean;
-    disconnectController(ownerToken: string): boolean;
-}

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

@@ -1,27 +0,0 @@
-/**
- * Typed UI/manipulation result semantics for bridge-capability handling.
- *
- * `unsupported` is distinct from both a real value and user cancellation. This
- * prevents local-only or undeclared `ExtensionUIContext` surfaces from becoming
- * silent no-ops that look like user intent.
- */
-export interface BridgeUiValue<TValue> {
-    status: "value";
-    value: TValue;
-}
-export interface BridgeUiCancelled {
-    status: "cancelled";
-    reason?: "user" | "timeout" | "abort" | "disconnect";
-}
-export interface BridgeUiUnsupported {
-    status: "unsupported";
-    capability: string;
-    reason: string;
-}
-export type BridgeUiResult<TValue> = BridgeUiValue<TValue> | BridgeUiCancelled | BridgeUiUnsupported;
-export declare function uiValue<TValue>(value: TValue): BridgeUiValue<TValue>;
-export declare function uiCancelled(reason?: BridgeUiCancelled["reason"]): BridgeUiCancelled;
-export declare function uiUnsupported(capability: string, reason: string): BridgeUiUnsupported;
-export declare function isUiUnsupported<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiUnsupported;
-export declare function isUiCancelled<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiCancelled;
-export declare function isUiValue<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiValue<TValue>;

package/dist/types/modes/shared/agent-wire/unattended-action-policy.d.ts

@@ -1,29 +0,0 @@
-/**
- * Unattended action taxonomy + classifier (#319).
- *
- * Maps coarse command scopes and concrete bash commands onto the v1 action
- * taxonomy so the controller can authorize (default-deny) BEFORE any side effect.
- *
- * The classifier is deliberately FAIL-CLOSED for shell evasion:
- *  - nested execution via `$(...)`, backticks, and `<(...)` / `>(...)` is
- *    extracted and classified recursively, so a destructive command hidden in a
- *    substitution cannot masquerade as the harmless outer command;
- *  - statements are split on newlines and `; && || | &`, so a second
- *    (destructive) command on another line is classified too;
- *  - leading environment assignments and wrappers (`sudo`, `env`, `command`,
- *    `xargs`, …) are stripped/followed to the effective command;
- *  - anything that is not provably read-only escalates to at least
- *    `bash.mutating`, and clearly destructive forms escalate further, so an
- *    undeclared destructive action is denied rather than silently allowed.
- */
-import type { RpcUnattendedActionClass } from "../../rpc/rpc-types";
-import type { BridgeCommandScope } from "./scopes";
-/** Coarse command scope -> `command.<scope>` action class. */
-export declare function actionClassForScope(scope: BridgeCommandScope): RpcUnattendedActionClass;
-/** Runtime list of every v1 action class — membership-validation source for negotiate (#319). */
-export declare const RPC_UNATTENDED_ACTION_CLASSES: readonly RpcUnattendedActionClass[];
-/**
- * Classify a (possibly compound / nested) bash command into the most severe
- * action class across all statements and nested substitutions. Fail-closed.
- */
-export declare function classifyBashAction(command: string): RpcUnattendedActionClass;

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

@@ -1,68 +0,0 @@
-import type { RpcBudgetExceeded, RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
-export declare const AUDIT_SCHEMA_VERSION = 1;
-export declare const AUDIT_CATEGORY = "unattended_lifecycle";
-export type AuditOutcome = "accepted" | "rejected" | "denied" | "exceeded" | "aborted" | "info";
-export interface AuditRecord {
-    event_id: string;
-    schema_version: number;
-    category: typeof AUDIT_CATEGORY;
-    run_id: string;
-    session_id?: string;
-    actor?: string;
-    timestamp: string;
-    event: string;
-    outcome: AuditOutcome;
-    dedupe_key: string;
-    gate_id?: string;
-    stage?: RpcWorkflowStage;
-    kind?: RpcWorkflowGateKind;
-    scope?: string;
-    action?: string;
-    budget?: RpcBudgetExceeded;
-    /** Full answer (omitted when redaction is enabled). */
-    answer?: unknown;
-    answer_hash?: string;
-    error?: unknown;
-}
-export interface AuditQuery {
-    run_id?: string;
-    session_id?: string;
-    actor?: string;
-    gate_id?: string;
-    outcome?: AuditOutcome;
-    event?: string;
-    since?: string;
-    until?: string;
-}
-export interface AuditLogOptions {
-    /** When true, gate answers are stored as hash + summary only. */
-    redactAnswers?: boolean;
-    /** Injectable id/clock for deterministic tests. */
-    now?(): number;
-    nextId?(): string;
-}
-export declare function defaultAuditPath(runId: string, root?: string, gjcSessionId?: string): string;
-/** Append-only audit log writer + reader for one unattended run. */
-export declare class UnattendedAuditLog {
-    private readonly filePath;
-    private readonly seen;
-    private readonly now;
-    private readonly nextId;
-    private readonly redactAnswers;
-    constructor(filePath: string, options?: AuditLogOptions);
-    /**
-     * Append a record. Returns the written record, or `null` if a record with the
-     * same dedupe_key was already written (exactly-once).
-     */
-    record(input: Omit<AuditRecord, "event_id" | "schema_version" | "category" | "timestamp">): AuditRecord | null;
-    /** Append one line and fsync it for crash durability. */
-    private appendDurable;
-    /** Read every record (fail-closed: a corrupt line throws rather than silently dropping). */
-    readAll(): AuditRecord[];
-    /** Query records with filters (run/session/actor/gate/outcome/event + time window). */
-    query(filter?: AuditQuery): AuditRecord[];
-    /** Export the full trail as an array (for `get_unattended_audit`). */
-    export(filter?: AuditQuery): AuditRecord[];
-}
-/** SHA-256 of the canonical JSON of an answer (matches the gate broker's hash). */
-export declare function answerHash(answer: unknown): string;

package/dist/types/modes/shared/agent-wire/unattended-run-controller.d.ts

@@ -1,166 +0,0 @@
-/**
- * Unattended run controller (#318).
- *
- * The single required owner of negotiated unattended state. Entering unattended
- * mode is fail-closed: a controller can only be created via {@link
- * UnattendedRunController.negotiate}, which rejects a missing/partial budget, an
- * invalid declaration, or a provider that cannot account for tokens/cost.
- *
- * The controller owns budget accounting across metrics and phases. Scope/action
- * authorization (#319) and the durable audit trail (#320) layer onto the same
- * controller; this slice wires the budget floor and abort coordination.
- *
- * Attended mode never constructs a controller, so by construction the attended
- * path is unaffected by everything here.
- */
-import type { RpcActionDenied, RpcBudgetExceeded, RpcBudgetMetric, RpcScopeDenied, RpcUnattendedActionClass, RpcUnattendedBudget, RpcUnattendedRefusalCode } from "../../rpc/rpc-types";
-import type { BridgeCommandScope } from "./scopes";
-import { actionClassForScope } from "./unattended-action-policy";
-/** Coordinated abort surfaces invoked exactly once on a budget breach / abort. */
-export interface UnattendedAbortHooks {
-    abortModelStream?(): void | Promise<void>;
-    abortBash?(): void | Promise<void>;
-    cancelHostTools?(reason: string): void | Promise<void>;
-    cancelHostUris?(reason: string): void | Promise<void>;
-    stopWorkflow?(reason: string): void | Promise<void>;
-}
-export type UnattendedAuditEvent = {
-    event: "unattended_negotiated";
-    run_id: string;
-    actor: string;
-} | {
-    event: "budget_exceeded";
-    payload: RpcBudgetExceeded;
-} | {
-    event: "unattended_aborted";
-    run_id: string;
-    reason: string;
-} | {
-    event: "unattended_abort_settled";
-    run_id: string;
-    status: "aborted" | "abort_failed";
-    failures: number;
-} | {
-    event: "scope_denied";
-    payload: RpcScopeDenied;
-} | {
-    event: "action_denied";
-    payload: RpcActionDenied;
-};
-export interface NegotiateContext {
-    runId: string;
-    sessionId?: string;
-    audit?(event: UnattendedAuditEvent): void;
-    abortHooks?: UnattendedAbortHooks;
-    /**
-     * Whether the active provider can report token usage and cost. Unattended
-     * mode rejects providers without this accounting up front (fail-closed).
-     */
-    providerSupportsTokenCostMetrics?: boolean;
-    /** Injectable clock for deterministic tests. Defaults to Date.now. */
-    now?(): number;
-}
-export declare class UnattendedNegotiationError extends Error {
-    readonly code: RpcUnattendedRefusalCode;
-    constructor(code: RpcUnattendedRefusalCode, message: string);
-}
-export declare class UnattendedBudgetExceededError extends Error {
-    readonly payload: RpcBudgetExceeded;
-    constructor(payload: RpcBudgetExceeded);
-}
-/** Thrown when a provider/tool reports a non-finite usage value (fail-closed). */
-export declare class UnattendedAccountingError extends Error {
-    readonly metric: RpcBudgetMetric;
-    readonly phase: string;
-    constructor(metric: RpcBudgetMetric, phase: string, value: unknown);
-}
-/** Thrown when a command's coarse scope is outside the declared allowlist (#319). */
-export declare class ScopeDeniedError extends Error {
-    readonly payload: RpcScopeDenied;
-    constructor(payload: RpcScopeDenied);
-}
-/** Thrown when an action class is outside the declared allowlist (default-deny, #319). */
-export declare class ActionDeniedError extends Error {
-    readonly payload: RpcActionDenied;
-    constructor(payload: RpcActionDenied);
-}
-interface Usage {
-    tokens: number;
-    toolCalls: number;
-    costUsd: number;
-}
-export declare class UnattendedRunController {
-    readonly runId: string;
-    readonly sessionId?: string;
-    readonly actor: string;
-    readonly budget: RpcUnattendedBudget;
-    readonly scopes: ReadonlySet<string>;
-    readonly actionAllowlist: ReadonlySet<string>;
-    private readonly usage;
-    private readonly startedAt;
-    private readonly now;
-    private readonly audit?;
-    private readonly abortHooks;
-    private aborted;
-    private abortPromise?;
-    private constructor();
-    /** Fail-closed entry: validate the declaration + budget, or throw. */
-    static negotiate(declaration: unknown, ctx: NegotiateContext): UnattendedRunController;
-    get isAborted(): boolean;
-    usageSnapshot(): Readonly<Usage> & {
-        wallTimeMs: number;
-    };
-    remainingWallTimeMs(): number;
-    /**
-     * Authorize a command's coarse scope against the declared allowlist. Throws
-     * ScopeDeniedError (pre-side-effect) when the scope was not declared.
-     */
-    authorizeScope(scope: BridgeCommandScope, command?: string): void;
-    /**
-     * Authorize an action class against the declared allowlist. Default-deny: any
-     * class not explicitly declared is rejected with ActionDeniedError before the
-     * side effect runs.
-     */
-    authorizeAction(action: RpcUnattendedActionClass, command?: string): void;
-    /**
-     * Classify a bash command and authorize the resulting action class BEFORE the
-     * command is executed. Returns the classified action class on success.
-     */
-    authorizeBash(command: string): RpcUnattendedActionClass;
-    /** Convenience: map a coarse scope to its `command.<scope>` action class. */
-    static actionClassForScope: typeof actionClassForScope;
-    /** Pre-turn estimate: refuse to start a turn that would obviously breach. */
-    preTurnEstimate(estimate: {
-        tokens?: number;
-        costUsd?: number;
-    }): void;
-    /** Reserve one tool-call unit BEFORE any side effect; breach if it would exceed. */
-    preflightToolCall(phase?: string): void;
-    /** Post-turn reconciliation of actual token usage. Fails closed on non-finite. */
-    recordTokens(tokens: number, phase?: string): void;
-    recordCost(costUsd: number, phase?: string): void;
-    /** Combined post-turn reconciliation. */
-    reconcile(actual: {
-        tokens?: number;
-        costUsd?: number;
-    }, phase?: string): void;
-    /** Wall-time check; call before/inside long operations. */
-    checkWallTime(phase?: string): void;
-    private breach;
-    /**
-     * Idempotent abort: runs every abort hook at most once. Safe to call from the
-     * synchronous breach path (which does not await) and from callers that do; both
-     * share a single abort promise so hook completion can be awaited deterministically.
-     */
-    abort(reason: string): Promise<void>;
-    /** Returns the in-flight/settled abort completion once aborting has begun. */
-    get abortCompletion(): Promise<void> | undefined;
-    private fireAbort;
-    /**
-     * Invoke every configured abort hook exactly once with per-hook isolation, so a
-     * failing hook never prevents the other cancellation surfaces from running.
-     * Returns the number of hooks that rejected.
-     */
-    private runAbortHooks;
-}
-export {};