@gajae-code/coding-agent 0.3.0 → 0.3.2

package/dist/types/gjc-runtime/state-schema.d.ts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+export declare const WorkflowStateContentChecksumSchema: z.ZodObject<{
+    algorithm: z.ZodLiteral<"sha256">;
+    value: z.ZodString;
+    covered_path: z.ZodString;
+    computed_at: z.ZodString;
+}, z.core.$loose>;
+/** Lenient receipt schema for reads (mirrors WorkflowStateReceipt). */
+export declare const WorkflowStateReceiptSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    skill: z.ZodEnum<{
+        "deep-interview": "deep-interview";
+        ralplan: "ralplan";
+        team: "team";
+        ultragoal: "ultragoal";
+    }>;
+    owner: z.ZodEnum<{
+        "gjc-hook": "gjc-hook";
+        "gjc-runtime": "gjc-runtime";
+        "gjc-state-cli": "gjc-state-cli";
+    }>;
+    command: z.ZodString;
+    state_path: z.ZodString;
+    storage_path: z.ZodString;
+    mutated_at: z.ZodString;
+    fresh_until: z.ZodString;
+    status: z.ZodEnum<{
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    mutation_id: z.ZodString;
+    verb: z.ZodOptional<z.ZodString>;
+    from_phase: z.ZodOptional<z.ZodString>;
+    to_phase: z.ZodOptional<z.ZodString>;
+    forced: z.ZodOptional<z.ZodBoolean>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    content_sha256: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+        covered_path: z.ZodString;
+        computed_at: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** Lenient envelope schema for reads. Every non-structural field optional. */
+export declare const WorkflowStateEnvelopeSchema: z.ZodObject<{
+    skill: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    current_phase: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    receipt: z.ZodOptional<z.ZodObject<{
+        version: z.ZodNumber;
+        skill: z.ZodEnum<{
+            "deep-interview": "deep-interview";
+            ralplan: "ralplan";
+            team: "team";
+            ultragoal: "ultragoal";
+        }>;
+        owner: z.ZodEnum<{
+            "gjc-hook": "gjc-hook";
+            "gjc-runtime": "gjc-runtime";
+            "gjc-state-cli": "gjc-state-cli";
+        }>;
+        command: z.ZodString;
+        state_path: z.ZodString;
+        storage_path: z.ZodString;
+        mutated_at: z.ZodString;
+        fresh_until: z.ZodString;
+        status: z.ZodEnum<{
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        mutation_id: z.ZodString;
+        verb: z.ZodOptional<z.ZodString>;
+        from_phase: z.ZodOptional<z.ZodString>;
+        to_phase: z.ZodOptional<z.ZodString>;
+        forced: z.ZodOptional<z.ZodBoolean>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        content_sha256: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            value: z.ZodString;
+            covered_path: z.ZodString;
+            computed_at: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * Strict receipt required on WRITE (post checksum-stamping). Anchored to the
+ * fields the sanctioned writer emits — `content_sha256` is REQUIRED here.
+ */
+export declare const RequiredWorkflowStateReceiptSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    skill: z.ZodEnum<{
+        "deep-interview": "deep-interview";
+        ralplan: "ralplan";
+        team: "team";
+        ultragoal: "ultragoal";
+    }>;
+    owner: z.ZodEnum<{
+        "gjc-hook": "gjc-hook";
+        "gjc-runtime": "gjc-runtime";
+        "gjc-state-cli": "gjc-state-cli";
+    }>;
+    command: z.ZodString;
+    state_path: z.ZodString;
+    storage_path: z.ZodString;
+    mutated_at: z.ZodString;
+    fresh_until: z.ZodString;
+    status: z.ZodEnum<{
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    mutation_id: z.ZodString;
+    content_sha256: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+        covered_path: z.ZodString;
+        computed_at: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+/**
+ * Write-side fail-closed gate: the serialized on-disk envelope must satisfy
+ * this after checksum stamping. Anchored to current sanctioned-writer output.
+ */
+export declare const RequiredOnWriteEnvelopeSchema: z.ZodObject<{
+    skill: z.ZodEnum<{
+        "deep-interview": "deep-interview";
+        ralplan: "ralplan";
+        team: "team";
+        ultragoal: "ultragoal";
+    }>;
+    version: z.ZodLiteral<2>;
+    updated_at: z.ZodString;
+    current_phase: z.ZodString;
+    active: z.ZodBoolean;
+    receipt: z.ZodObject<{
+        version: z.ZodNumber;
+        skill: z.ZodEnum<{
+            "deep-interview": "deep-interview";
+            ralplan: "ralplan";
+            team: "team";
+            ultragoal: "ultragoal";
+        }>;
+        owner: z.ZodEnum<{
+            "gjc-hook": "gjc-hook";
+            "gjc-runtime": "gjc-runtime";
+            "gjc-state-cli": "gjc-state-cli";
+        }>;
+        command: z.ZodString;
+        state_path: z.ZodString;
+        storage_path: z.ZodString;
+        mutated_at: z.ZodString;
+        fresh_until: z.ZodString;
+        status: z.ZodEnum<{
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        mutation_id: z.ZodString;
+        content_sha256: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            value: z.ZodString;
+            covered_path: z.ZodString;
+            computed_at: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+/** Per-skill mode state consumed by hooks / the mutation guard. */
+export declare const ModeStateSchema: z.ZodObject<{
+    active: z.ZodOptional<z.ZodBoolean>;
+    current_phase: z.ZodOptional<z.ZodString>;
+    skill: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    thread_id: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    handoff_from: z.ZodOptional<z.ZodString>;
+    handoff_to: z.ZodOptional<z.ZodString>;
+    handoff_at: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const SkillActiveEntrySchema: z.ZodObject<{
+    skill: z.ZodString;
+    phase: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    activated_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    thread_id: z.ZodOptional<z.ZodString>;
+    turn_id: z.ZodOptional<z.ZodString>;
+    stale: z.ZodOptional<z.ZodBoolean>;
+    handoff_from: z.ZodOptional<z.ZodString>;
+    handoff_to: z.ZodOptional<z.ZodString>;
+    handoff_at: z.ZodOptional<z.ZodString>;
+    receipt: z.ZodOptional<z.ZodObject<{
+        version: z.ZodNumber;
+        skill: z.ZodEnum<{
+            "deep-interview": "deep-interview";
+            ralplan: "ralplan";
+            team: "team";
+            ultragoal: "ultragoal";
+        }>;
+        owner: z.ZodEnum<{
+            "gjc-hook": "gjc-hook";
+            "gjc-runtime": "gjc-runtime";
+            "gjc-state-cli": "gjc-state-cli";
+        }>;
+        command: z.ZodString;
+        state_path: z.ZodString;
+        storage_path: z.ZodString;
+        mutated_at: z.ZodString;
+        fresh_until: z.ZodString;
+        status: z.ZodEnum<{
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        mutation_id: z.ZodString;
+        verb: z.ZodOptional<z.ZodString>;
+        from_phase: z.ZodOptional<z.ZodString>;
+        to_phase: z.ZodOptional<z.ZodString>;
+        forced: z.ZodOptional<z.ZodBoolean>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        content_sha256: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            value: z.ZodString;
+            covered_path: z.ZodString;
+            computed_at: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const SkillActiveStateSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodNumber>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    skill: z.ZodOptional<z.ZodString>;
+    keyword: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodString>;
+    activated_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    thread_id: z.ZodOptional<z.ZodString>;
+    turn_id: z.ZodOptional<z.ZodString>;
+    active_skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        skill: z.ZodString;
+        phase: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodBoolean>;
+        activated_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        session_id: z.ZodOptional<z.ZodString>;
+        thread_id: z.ZodOptional<z.ZodString>;
+        turn_id: z.ZodOptional<z.ZodString>;
+        stale: z.ZodOptional<z.ZodBoolean>;
+        handoff_from: z.ZodOptional<z.ZodString>;
+        handoff_to: z.ZodOptional<z.ZodString>;
+        handoff_at: z.ZodOptional<z.ZodString>;
+        receipt: z.ZodOptional<z.ZodObject<{
+            version: z.ZodNumber;
+            skill: z.ZodEnum<{
+                "deep-interview": "deep-interview";
+                ralplan: "ralplan";
+                team: "team";
+                ultragoal: "ultragoal";
+            }>;
+            owner: z.ZodEnum<{
+                "gjc-hook": "gjc-hook";
+                "gjc-runtime": "gjc-runtime";
+                "gjc-state-cli": "gjc-state-cli";
+            }>;
+            command: z.ZodString;
+            state_path: z.ZodString;
+            storage_path: z.ZodString;
+            mutated_at: z.ZodString;
+            fresh_until: z.ZodString;
+            status: z.ZodEnum<{
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            mutation_id: z.ZodString;
+            verb: z.ZodOptional<z.ZodString>;
+            from_phase: z.ZodOptional<z.ZodString>;
+            to_phase: z.ZodOptional<z.ZodString>;
+            forced: z.ZodOptional<z.ZodBoolean>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            content_sha256: z.ZodOptional<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                value: z.ZodString;
+                covered_path: z.ZodString;
+                computed_at: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type WorkflowStateEnvelope = z.infer<typeof WorkflowStateEnvelopeSchema>;
+export type RequiredOnWriteEnvelope = z.infer<typeof RequiredOnWriteEnvelopeSchema>;
+export type ModeStateParsed = z.infer<typeof ModeStateSchema>;
+export type SkillActiveStateParsed = z.infer<typeof SkillActiveStateSchema>;
+/**
+ * Validated read result.
+ * - `null`        → file absent (ENOENT); callers treat as no state.
+ * - `{ok:true}`   → parsed + schema-valid.
+ * - `{ok:false}`  → present but unparseable or schema-invalid. Callers fail
+ *                   OPEN (normalize/log), never crash — preserving v2 reads.
+ */
+export type ReadGjcJsonResult<T> = {
+    ok: true;
+    value: T;
+    raw: unknown;
+} | {
+    ok: false;
+    error: string;
+    raw: unknown;
+};
+/**
+ * Parse + schema-validate a `.gjc` JSON file at the read boundary.
+ * Returns `null` when the file is absent. Fail-open: an invalid file yields
+ * `{ ok: false }` with the raw value attached so the caller can normalize/log.
+ */
+export declare function readGjcJson<T>(filePath: string, schema: z.ZodType<T>): Promise<ReadGjcJsonResult<T> | null>;

package/dist/types/gjc-runtime/state-writer.d.ts

@@ -93,6 +93,16 @@ export declare class AlreadyExistsError extends Error {
     readonly path: string;
     constructor(path: string);
 }
+export type StrictMutationReadResult = {
+    kind: "absent";
+} | {
+    kind: "corrupt";
+    error: string;
+} | {
+    kind: "valid";
+    value: Record<string, unknown>;
+};
+export declare function readExistingStateForMutation(filePath: string): Promise<StrictMutationReadResult>;
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
 export declare function stampWorkflowEnvelopeChecksum<T>(value: T, filePath: string, computedAt?: string): T;
 export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string): Promise<WorkflowEnvelopeIntegrityMismatch | undefined>;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowHudSummary } from "../skill-state/active-state";
+import { type WorkflowHudSummary } from "../skill-state/active-state";
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
 export interface UltragoalGoal {
@@ -94,6 +94,7 @@ export declare function computeUltragoalPlanGeneration(input: {
 export declare function readUltragoalPlan(cwd: string): Promise<UltragoalPlan | null>;
 export declare function getUltragoalStatus(cwd: string): Promise<UltragoalStatusSummary>;
 export declare function buildUltragoalHudSummary(summary: UltragoalStatusSummary, latestLedger?: UltragoalLedgerEvent): WorkflowHudSummary;
+export declare function syncUltragoalWorkflowState(cwd: string): Promise<void>;
 export declare function createUltragoalPlan(input: {
     cwd: string;
     brief: string;

package/dist/types/gjc-runtime/workflow-command-ref.d.ts

@@ -0,0 +1,43 @@
+import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
+export type CommandRefVisibility = "public" | "hidden" | "planned";
+export type CommandRefIncludeWhen = "implemented-only" | "planned";
+export interface CommandRefCommand {
+    tokens: string[];
+    rendered: string;
+    visibility: CommandRefVisibility;
+    includeWhen: CommandRefIncludeWhen;
+    note?: string;
+}
+export interface CommandRefExample {
+    label?: string;
+    bytes: string;
+}
+export interface CommandRefBridge {
+    from: string;
+    to: string;
+    rendered: string;
+}
+export interface CommandRefBlock {
+    skill: CanonicalGjcWorkflowSkill;
+    blockId: string;
+    sourcePath: string;
+    renderOrder: number;
+    markers: {
+        start: string;
+        end: string;
+    };
+    commands: CommandRefCommand[];
+    examples: CommandRefExample[];
+    aliasesAndBridges: CommandRefBridge[];
+    notes: string[];
+}
+export interface RenderedCommandRefBlock {
+    skill: CanonicalGjcWorkflowSkill;
+    blockId: string;
+    markers: CommandRefBlock["markers"];
+    bytes: string;
+}
+export declare const WORKFLOW_COMMAND_REF_BLOCKS: readonly CommandRefBlock[];
+export declare function listCommandRefBlocks(skill?: CanonicalGjcWorkflowSkill): CommandRefBlock[];
+export declare function renderCommandRefBlock(skill: CanonicalGjcWorkflowSkill, blockId?: string): RenderedCommandRefBlock;
+export declare function isCanonicalGjcWorkflowSkill(value: string): value is CanonicalGjcWorkflowSkill;

package/dist/types/harness-control-plane/control-endpoint.d.ts

@@ -24,7 +24,8 @@ export declare class ControlServer {
 }
 export declare class EndpointUnreachableError extends Error {
     readonly socketPath: string;
-    constructor(socketPath: string);
+    readonly reason: string;
+    constructor(socketPath: string, reason?: string);
 }
-/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens. */
+/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens or responds. */
 export declare function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs?: number): Promise<unknown>;

package/dist/types/hooks/skill-state.d.ts

@@ -59,6 +59,27 @@ import { initialPhaseForSkill } from "../skill-state/initial-phase";
 export { initialPhaseForSkill };
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, stateDir?: string): Promise<SkillActiveState | null>;
 export declare function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null>;
+export interface EnsureWorkflowSkillActivationInput {
+    cwd: string;
+    skill: string;
+    sessionId?: string;
+    threadId?: string;
+    turnId?: string;
+    nowIso?: string;
+    stateDir?: string;
+}
+/**
+ * Idempotently seed `.gjc/state` for a workflow skill that was invoked directly
+ * (e.g. via `/skill:<name>`) rather than through keyword detection. This ensures
+ * the mutation guard and Stop hook engage the moment a workflow skill becomes
+ * active, instead of relying on the skill prompt to run its own state-init steps.
+ *
+ * The seed is non-destructive: if an active entry for this skill already exists
+ * (for example after a `gjc state handoff` promotion that carries
+ * `handoff_from`/`handoff_at` lineage), nothing is written so lineage is
+ * preserved. Non-workflow skills are ignored.
+ */
+export declare function ensureWorkflowSkillActivationState(input: EnsureWorkflowSkillActivationInput): Promise<SkillActiveState | null>;
 export declare function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null>;
 export declare function buildSkillStopOutput(input: StopHookInput): Promise<Record<string, unknown> | null>;
 export declare function buildSkillActivationAdditionalContext(state: SkillActiveState, effectiveSkillConfig?: EffectiveSkillConfigInput): string;

package/dist/types/internal-urls/agent-protocol.d.ts

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 /**
  * Handler for agent:// URLs.
  *
@@ -8,5 +8,5 @@ import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 export declare class AgentProtocolHandler implements ProtocolHandler {
     readonly scheme = "agent";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
 }

package/dist/types/internal-urls/artifact-protocol.d.ts

@@ -1,6 +1,6 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 export declare class ArtifactProtocolHandler implements ProtocolHandler {
     readonly scheme = "artifact";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
 }

package/dist/types/internal-urls/registry-helpers.d.ts

@@ -1,10 +1,11 @@
+import type { ResolveContext } from "./types";
 /**
- * Snapshot of artifacts dirs for every registered session, deduped.
+ * Snapshot of artifacts dirs explicitly authorized for the calling session.
  *
- * Prefers `sessionManager.getArtifactsDir()` because subagents adopt their
- * parent's `ArtifactManager` and report the parent's dir there; dedup then
- * collapses parent + N subagents (the whole agent tree) to one entry. Falls
- * back to the raw session file (with the `.jsonl` suffix stripped) when no
- * live session reference is attached.
+ * Normal reads are scoped to the caller's artifacts directory. Parent/child
+ * agent tree sharing is allowed only when the caller supplies explicit
+ * authorized directories at the ResolveContext boundary. This intentionally
+ * does not enumerate AgentRegistry.global(); live but unrelated sessions are
+ * not an authorization source.
  */
-export declare function artifactsDirsFromRegistry(): string[];
+export declare function authorizedArtifactsDirsFromContext(context?: ResolveContext): string[];

package/dist/types/internal-urls/types.d.ts

@@ -56,6 +56,10 @@ export interface ResolveContext {
     cwd?: string;
     /** Settings of the calling session (used by `issue://`/`pr://` for cache TTLs). */
     settings?: unknown;
+    /** Artifacts directory of the calling session. */
+    getArtifactsDir?: () => string | null;
+    /** Additional artifacts directories explicitly authorized for this caller (for parent/child agent trees). */
+    getAuthorizedArtifactsDirs?: () => readonly string[];
     /** Caller's abort signal. */
     signal?: AbortSignal;
 }

package/dist/types/lsp/index.d.ts

@@ -93,8 +93,8 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
     readonly loadMode = "discoverable";
     readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
     readonly description: string;
-    readonly parameters: import("zod/v4").ZodObject<{
-        action: import("zod/v4").ZodEnum<{
+    readonly parameters: import("zod").ZodObject<{
+        action: import("zod").ZodEnum<{
             capabilities: "capabilities";
             code_actions: "code_actions";
             definition: "definition";
@@ -110,14 +110,14 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
             symbols: "symbols";
             type_definition: "type_definition";
         }>;
-        file: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        line: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        symbol: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        query: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        new_name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        apply: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
-        timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        file: import("zod").ZodOptional<import("zod").ZodString>;
+        line: import("zod").ZodOptional<import("zod").ZodNumber>;
+        symbol: import("zod").ZodOptional<import("zod").ZodString>;
+        query: import("zod").ZodOptional<import("zod").ZodString>;
+        new_name: import("zod").ZodOptional<import("zod").ZodString>;
+        apply: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        payload: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     readonly renderCall: typeof renderCall;
     readonly renderResult: typeof renderResult;

package/dist/types/main.d.ts

@@ -24,10 +24,19 @@ export interface AcpSessionFactoryOptions {
     sessionDir?: string;
     authStorage: AuthStorage;
     modelRegistry: ModelRegistry;
-    parsedArgs: Pick<Args, "apiKey">;
+    parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
     rawArgs: string[];
     createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
 }
+export declare function applyStartupModelProfiles(args: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+    startupModel?: CreateAgentSessionOptions["model"];
+    startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+}): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof applyStartupModelProfiles>[0]): Promise<void>;
 /**
  * Build the per-`session/new` factory used by ACP mode.
  *

package/dist/types/modes/bridge/auth.d.ts

@@ -0,0 +1,12 @@
+export interface BridgeAuthConfig {
+    token: string;
+}
+export interface BridgeBindConfig {
+    hostname: string;
+    port: number;
+    tlsConfigured: boolean;
+}
+export declare function extractBearerToken(authorization: string | null | undefined): string | undefined;
+export declare function isBridgeTokenAuthorized(authorization: string | null | undefined, config: BridgeAuthConfig): boolean;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function assertSafeBridgeBind(config: BridgeBindConfig): void;

package/dist/types/modes/bridge/bridge-client-bridge.d.ts

@@ -0,0 +1,9 @@
+import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+export interface BridgePermissionRequestPayload {
+    kind: "permission";
+    toolCall: ClientBridgePermissionToolCall;
+    options: ClientBridgePermissionOption[];
+}
+export type BridgePermissionBroker = UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+export declare function createBridgeClientBridge(broker: BridgePermissionBroker): ClientBridge;

package/dist/types/modes/bridge/bridge-mode.d.ts

@@ -0,0 +1,44 @@
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
+import type { RpcCommand, RpcResponse } from "../rpc/rpc-types";
+import { RpcHostToolBridge } from "../shared/agent-wire/host-tool-bridge";
+import { RpcHostUriBridge } from "../shared/agent-wire/host-uri-bridge";
+import { type BridgeCommandScope } from "../shared/agent-wire/scopes";
+import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { type BridgePermissionRequestPayload } from "./bridge-client-bridge";
+import { type BridgeUiRequestPayload } from "./bridge-ui-context";
+import { BridgeEventStream } from "./event-stream";
+interface BridgeEndpointMatrix {
+    events: boolean;
+    commands: boolean;
+    control: boolean;
+    uiResponses: boolean;
+    hostToolResults: boolean;
+    hostUriResults: boolean;
+}
+interface BridgeFetchHandlerOptions {
+    sessionId: string;
+    token: string;
+    eventStream?: BridgeEventStream;
+    commandDispatcher?: (command: RpcCommand) => Promise<RpcResponse>;
+    commandScopes?: readonly BridgeCommandScope[];
+    idempotencyCache?: BridgeIdempotencyCache;
+    permissionBroker?: UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+    uiBroker?: UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+    hostToolBridge?: RpcHostToolBridge;
+    hostUriBridge?: RpcHostUriBridge;
+    endpointMatrix?: Partial<BridgeEndpointMatrix>;
+}
+interface BridgeIdempotencyRecord {
+    route: string;
+    ownerToken?: string;
+    body: string | Promise<string>;
+    response: unknown | Promise<unknown>;
+    pending?: boolean;
+}
+type BridgeIdempotencyCache = Map<string, BridgeIdempotencyRecord>;
+export declare function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function runBridgeMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export {};