@gajae-code/coding-agent 0.11.0 → 0.11.2

package/dist/types/coordinator-mcp/question-state.d.ts

@@ -0,0 +1,356 @@
+import type { PrivateAskGateCodecV1, PublicReason } from "./question-gate-codec";
+export type CoordinatorSessionState = "booting" | "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored" | "stale" | "unknown";
+export interface CanonicalSessionSnapshotV1 {
+    schema_version: 1;
+    namespace_id: string;
+    session_id: string;
+    cwd: string;
+    created_at: string;
+    updated_at: string;
+    mpreset: string | null;
+    source: string | null;
+    model: string | null;
+    tmux: {
+        session: string | null;
+        window: string | null;
+        pane: string | null;
+    };
+    broker: {
+        workspace: string | null;
+        endpoint_url: string;
+        endpoint_generation: number;
+        endpoint_incarnation: string;
+    };
+    ephemeral: boolean;
+    visible: boolean;
+}
+export interface CanonicalTurnSnapshotV1 {
+    schema_version: 1;
+    turn_id: string;
+    session_id: string;
+    namespace_id: string;
+    status: string;
+    prompt: {
+        text: string;
+        created_at: string;
+        source: string;
+    };
+    delivery: Record<string, unknown>;
+    question_ids: string[];
+    final_response: Record<string, unknown>;
+    evidence: Record<string, unknown>[];
+    error: Record<string, unknown> | null;
+    liveness: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+    terminal_fence: {
+        epoch: number;
+        status: string;
+        reason: PublicReason | null;
+        at: string;
+    } | null;
+}
+export interface CanonicalReportSnapshotV1 {
+    schema_version: 1;
+    report_id: string;
+    operation_id: string;
+    session_id: string;
+    turn_id: string;
+    status: string;
+    summary: string;
+    blocker: string | null;
+    pr_url: string | null;
+    evidence_paths: string[];
+    created_at: string;
+}
+export type GateAuthorityEntryV1 = {
+    authority: {
+        namespace_id: string;
+        session_id: string;
+        endpoint_incarnation: string;
+        gate_id: string;
+    };
+    observation: {
+        kind: "valid";
+        first_provenance: {
+            runtime_turn_id: string;
+            gate_created_at: string;
+            schema_hash: string;
+            stage: string;
+            kind: string;
+        };
+    } | {
+        kind: "malformed";
+        immutable_observation_digest: string;
+        malformed: "missing_runtime_turn" | "invalid_runtime_turn" | "invalid_gate_row" | "wrong_session";
+    };
+    outcome: {
+        state: "deferred_link";
+        first_seen_at: string;
+    } | {
+        state: "pending" | "answered";
+        turn_id: string;
+        question_id: string;
+    } | {
+        state: "stale" | "uncertain";
+        reason: PublicReason;
+        turn_id?: string;
+        question_id?: string;
+    } | {
+        state: "ownership_unavailable";
+        reason: "ownership_unavailable";
+    } | {
+        state: "ownership_conflict";
+        reason: "ownership_conflict";
+    };
+    first_seen_at: string;
+    updated_at: string;
+};
+export interface PrivateQuestionV1 {
+    question_id: string;
+    authority_id: string;
+    session_id: string;
+    turn_id: string;
+    endpoint_incarnation: string;
+    stage: string;
+    kind: string;
+    prompt: string;
+    status: "pending" | "resolving" | "answered" | "stale" | "uncertain";
+    binding_plaintext: string;
+    binding_sha256: string;
+    codec: PrivateAskGateCodecV1;
+    claim_fence_epoch: number | null;
+    answer_request_id: string | null;
+    created_at: string;
+    updated_at: string;
+    answered_at: string | null;
+    history: Array<{
+        at: string;
+        status: "pending" | "resolving" | "answered" | "stale" | "uncertain";
+        reason: PublicReason | null;
+    }>;
+}
+export interface AnswerRequestV1 {
+    request_id: string;
+    key_digest: string;
+    request_digest: string;
+    answer_hash: string;
+    answer_binding_sha256: string;
+    authority_id: string;
+    question_id: string;
+    turn_id: string;
+    endpoint_incarnation: string;
+    sdk_idempotency_key: string;
+    claim_fence_epoch: number;
+    phase: "claimed" | "remote_started" | "accepted" | "rejected" | "completed" | "uncertain";
+    safe_receipt?: {
+        status: "accepted" | "rejected";
+        answer_hash: string;
+        answer_binding_sha256: string;
+        authority_id: string;
+        turn_id: string;
+        endpoint_incarnation: string;
+        claim_fence_epoch: number;
+        resolved_at: string;
+    };
+    error_code?: PublicReason | "idempotency_conflict";
+    created_at: string;
+    updated_at: string;
+}
+export interface PromptRequestV1 {
+    request_id: string;
+    key_digest: string;
+    request_digest: string;
+    operation: "turn.prompt" | "turn.follow_up" | "turn.abort_and_prompt";
+    canonical_prompt: {
+        text: string;
+    };
+    sdk_idempotency_key: string;
+    phase: "claimed" | "remote_started" | "accepted" | "linked" | "terminal" | "completed" | "uncertain";
+    runtime_receipt?: {
+        accepted: true;
+        command_id: string;
+        turn_id: string;
+    };
+    coordinator_turn_id?: string;
+    safe_response?: Record<string, unknown>;
+    error_code?: PublicReason | "idempotency_conflict";
+    created_at: string;
+    updated_at: string;
+}
+export interface OperationRequestV1 {
+    operation_id: string;
+    tool: string;
+    key_digest: string;
+    request_digest: string;
+    local_id: string;
+    remote_id?: string;
+    phase: "claimed" | "remote_started" | "completed" | "uncertain";
+    intent: Record<string, unknown>;
+    safe_response?: Record<string, unknown>;
+    error_code?: PublicReason | "idempotency_conflict";
+    created_at: string;
+    updated_at: string;
+}
+export interface OutboxEventV1 {
+    id: string;
+    transaction_revision: number;
+    kind: string;
+    entity: "turn" | "question" | "report" | "session" | "deletion";
+    entity_id: string;
+    payload: Record<string, string | number | boolean | null>;
+    emitted: boolean;
+}
+export interface CoordinatorSessionTransactionV1 {
+    schema_version: 1;
+    namespace_id: string;
+    session_id: string;
+    revision: number;
+    endpoint: {
+        incarnation: string;
+        observed_at: string;
+    } | null;
+    canonical: {
+        session: CanonicalSessionSnapshotV1;
+        turns: Record<string, CanonicalTurnSnapshotV1>;
+        queue: {
+            ordered_turn_ids: string[];
+            active_turn_id: string | null;
+            selected_promotion: {
+                from_turn_id: string;
+                to_turn_id: string;
+                revision: number;
+            } | null;
+        };
+        desired_session_state: CoordinatorSessionState;
+        reports: Record<string, CanonicalReportSnapshotV1>;
+        gate_authorities: Record<string, GateAuthorityEntryV1>;
+        questions: Record<string, PrivateQuestionV1>;
+    };
+    requests: {
+        prompts: Record<string, PromptRequestV1>;
+        answers: Record<string, AnswerRequestV1>;
+        operations: Record<string, OperationRequestV1>;
+    };
+    outbox: Record<string, OutboxEventV1>;
+    projection: {
+        applied_turns_revision: number;
+        applied_reports_revision: number;
+        applied_session_revision: number;
+        applied_active_revision: number;
+        applied_events_revision: number;
+    };
+    recovery: {
+        prompt_watermark_at: string | null;
+        last_repaired_at: string | null;
+    };
+}
+export type CanonicalCreateIntentV1 = {
+    kind: "register";
+    session: CanonicalSessionSnapshotV1;
+    initial_state: CoordinatorSessionState;
+    initial_events: Record<string, string | number | boolean | null>[];
+} | {
+    kind: "start";
+    session: CanonicalSessionSnapshotV1;
+    remote_create_key: string;
+    initial_state: CoordinatorSessionState;
+    initial_prompt: {
+        text: string;
+        caller_key_digest: string;
+    } | null;
+    initial_events: Record<string, string | number | boolean | null>[];
+} | {
+    kind: "delegate";
+    workflow: "plan" | "execute" | "team";
+    session: CanonicalSessionSnapshotV1;
+    remote_create_key: string;
+    initial_state: CoordinatorSessionState;
+    initial_prompt: {
+        text: string;
+        caller_key_digest: string;
+    };
+    initial_events: Record<string, string | number | boolean | null>[];
+};
+export interface CreationRequestV1 {
+    key_digest: string;
+    request_digest: string;
+    tool: string;
+    phase: "claimed" | "remote_started" | "wal_committed" | "projected" | "completed" | "uncertain";
+    canonical_create_intent: CanonicalCreateIntentV1 | null;
+    remote_create_key: string;
+    session_id: string | null;
+    endpoint_incarnation: string | null;
+    wal_revision?: number;
+    wal_digest?: string;
+    safe_response?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface NamespaceDeletionEntryV1 {
+    deletion_id: string;
+    session_id: string;
+    endpoint_incarnation: string;
+    operation_id: string;
+    key_digest: string;
+    request_digest: string;
+    close_key: string;
+    phase: "intent" | "broker_closed" | "cleanup_pending" | "completed" | "uncertain";
+    safe_response?: Record<string, unknown>;
+    cleanup: {
+        wal: boolean;
+        turns: boolean;
+        reports: boolean;
+        session: boolean;
+        events: boolean;
+    };
+    authority_digest: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface NamespaceRegistryV1 {
+    schema_version: 1;
+    namespace_id: string;
+    creations: Record<string, CreationRequestV1>;
+    deletions: Record<string, NamespaceDeletionEntryV1>;
+}
+export interface CoordinatorStatePaths {
+    root: string;
+    registry: string;
+    registryLock: string;
+    journal: string;
+    journalLock: string;
+    sessions: string;
+}
+export declare function coordinatorStatePaths(stateRoot: string, namespaceId: string): CoordinatorStatePaths;
+export declare function transactionPath(paths: CoordinatorStatePaths, sessionId: string): string;
+export declare function transactionLockPath(paths: CoordinatorStatePaths, sessionId: string): string;
+export declare function initializeCoordinatorNamespace(paths: CoordinatorStatePaths): Promise<void>;
+export declare function withNamespaceRegistry<T>(paths: CoordinatorStatePaths, operation: (registry: NamespaceRegistryV1) => Promise<T>): Promise<T>;
+export declare function withSessionTransaction<T>(paths: CoordinatorStatePaths, sessionId: string, operation: (transaction: CoordinatorSessionTransactionV1) => Promise<T>): Promise<T>;
+/** Serializes a session mutation with namespace close admission. */
+export declare function withAdmittedSessionTransaction<T>(paths: CoordinatorStatePaths, sessionId: string, operation: (transaction: CoordinatorSessionTransactionV1) => Promise<T>): Promise<T>;
+/** Claims a caller-visible creation request before any remote work or projection. */
+export declare function claimCreationRequest(paths: CoordinatorStatePaths, input: {
+    key_digest: string;
+    request_digest: string;
+    tool: string;
+}): Promise<CreationRequestV1>;
+/** Persists the remote result needed to resume a creation after a crash. */
+export declare function bindCreationRequest(paths: CoordinatorStatePaths, keyDigest: string, intent: CanonicalCreateIntentV1): Promise<CreationRequestV1>;
+/** Creates the durable session WAL for an already claimed creation request. */
+export declare function commitCreationWal(paths: CoordinatorStatePaths, keyDigest: string, intent: CanonicalCreateIntentV1): Promise<CoordinatorSessionTransactionV1>;
+export declare function createSessionTransaction(paths: CoordinatorStatePaths, intent: CanonicalCreateIntentV1): Promise<CoordinatorSessionTransactionV1>;
+export declare function assertCloseAdmission(registry: NamespaceRegistryV1, transaction: CoordinatorSessionTransactionV1): void;
+export declare function deterministicOutboxId(sessionId: string, revision: number, kind: string, entity: OutboxEventV1["entity"], entityId: string): string;
+export declare function appendOutboxEvents(paths: CoordinatorStatePaths, transaction: CoordinatorSessionTransactionV1): Promise<void>;
+export declare function compactTransaction(transaction: CoordinatorSessionTransactionV1, now?: number): void;
+/** Records projection repair after projecting complete canonical snapshots. */
+export declare function repairProjections(paths: CoordinatorStatePaths, sessionId: string, project: (canonical: CoordinatorSessionTransactionV1["canonical"]) => Promise<void>): Promise<void>;
+/** Advances a creation receipt only after its WAL or projection authority exists. */
+export declare function advanceCreationReceipt(paths: CoordinatorStatePaths, keyDigest: string, phase: "projected" | "completed" | "uncertain", safeResponse?: Record<string, unknown>): Promise<void>;
+export declare function hasEmergencyCapacity(transaction: CoordinatorSessionTransactionV1, incomingBytes: number, essential: boolean): boolean;
+export declare function recordDeletionIntent(paths: CoordinatorStatePaths, entry: NamespaceDeletionEntryV1): Promise<void>;
+export declare function advanceDeletion(paths: CoordinatorStatePaths, deletionId: string, phase: NamespaceDeletionEntryV1["phase"], cleanup?: Partial<NamespaceDeletionEntryV1["cleanup"]>, safeResponse?: Record<string, unknown>): Promise<void>;

package/dist/types/coordinator-mcp/server.d.ts

@@ -1,4 +1,6 @@
 import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
+import type { BrokerDiscovery } from "../sdk/broker/discovery";
+import { type EnsureBrokerSettings } from "../sdk/broker/ensure";
 import { SdkClient } from "../sdk/client/client";
 import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
@@ -24,6 +26,8 @@ interface JsonRpcResponse {
 }
 interface CoordinatorServices {
     connectSdk?: (url: string, token: string) => Promise<SdkClient>;
+    ensureBroker?: (settings: EnsureBrokerSettings) => Promise<BrokerDiscovery>;
+    readSdkBrokerDiscovery?: (agentDir: string) => Promise<BrokerDiscovery | null>;
     getAgentDir?: () => string;
     resolveModelProfiles?: CoordinatorModelProfileLoader;
     canonicalizePath?: (value: string) => Promise<string>;

package/dist/types/discovery/helpers.d.ts

@@ -263,9 +263,3 @@ export declare function preloadPluginRoots(home: string, cwd?: string): Promise<
  * Returns empty array if preloadPluginRoots() hasn't been called.
  */
 export declare function getPreloadedPluginRoots(): readonly ClaudePluginRoot[];
-/**
- * Inject synthetic plugin roots from --plugin-dir paths.
- * These are prepended to the cache with highest precedence (before GJC/Anthropic model entries).
- * Must be called before any listAnthropic modelPluginRoots() access.
- */
-export declare function injectPluginDirRoots(home: string, dirs: string[], cwd?: string): Promise<void>;

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

@@ -24,6 +24,8 @@ type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlin
 type VimParams = z.infer<typeof vimSchema>;
 type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
+/** Project edit targets and operation counts without exposing patches, diffs, or file contents. */
+export declare function summarizeEditToolActivity(kind: "args" | "result", value: unknown): string | undefined;
 export declare class EditTool implements AgentTool<TInput> {
     #private;
     private readonly session;
@@ -33,6 +35,7 @@ export declare class EditTool implements AgentTool<TInput> {
     readonly nonAbortable = true;
     readonly concurrency = "exclusive";
     readonly strict = true;
+    readonly safeSummary: typeof summarizeEditToolActivity;
     constructor(session: ToolSession);
     get mode(): EditMode;
     get description(): string;

package/dist/types/eval/py/env.d.ts

@@ -0,0 +1,9 @@
+/** Environment values consulted by the Python subprocess integration. */
+export type PythonEnv = Record<string, string | undefined>;
+/** True when `value` is a non-empty string matching a truthy boolean token. */
+export declare function isTruthyPythonFlag(value: string | undefined): boolean;
+/** Resolve paired GJC/legacy PI flags using OR semantics. */
+export declare function resolvePythonFlag(env: PythonEnv, gjcName: string, piName: string): boolean;
+export declare function resolvePythonSkipCheck(env: PythonEnv): boolean;
+export declare function resolvePythonIpcTrace(env: PythonEnv): boolean;
+export declare function resolvePythonIntegrationGate(env: PythonEnv): boolean;

package/dist/types/extensibility/extensions/loader.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
-import type { UsageReport } from "@gajae-code/ai";
+import type { Tool, UsageReport } from "@gajae-code/ai";
 import { EventBus } from "../../utils/event-bus";
 import type { Extension, ExtensionFactory, ExtensionRuntime as IExtensionRuntime, LoadExtensionsResult } from "./types";
 export declare class ExtensionRuntimeNotInitializedError extends Error {
@@ -22,6 +22,7 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
     setLabel(): void;
     getActiveTools(): string[];
     getAllTools(): string[];
+    resolveTool(): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
     setActiveTools(): Promise<void>;
     getCommands(): never;
     setModel(): Promise<boolean>;

package/dist/types/extensibility/extensions/runner.d.ts

@@ -5,7 +5,7 @@ import type { AgentMessage } from "@gajae-code/agent-core";
 import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMetadata } from "@gajae-code/ai";
 import type { KeyId } from "@gajae-code/tui";
 import type { ModelRegistry } from "../../config/model-registry";
-import type { SessionManager } from "../../session/session-manager";
+import { type SessionManager } from "../../session/session-manager";
 import type { AfterProviderResponseEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, ContextEvent, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, MessageRenderer, RegisteredCommand, RegisteredTool, ResourcesDiscoverEvent, SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types";
 /** Combined result from all before_agent_start handlers */
 interface BeforeAgentStartCombinedResult {
@@ -105,7 +105,7 @@ export declare class ExtensionRunner {
      */
     shutdown(): void;
     createCommandContext(): ExtensionCommandContext;
-    emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
+    emit<TEvent extends RunnerEmitEvent>(event: TEvent, continueWhile?: () => boolean): Promise<RunnerEmitResult<TEvent>>;
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
     emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
     emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -9,7 +9,7 @@
  */
 import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@gajae-code/agent-core";
 import type { CompactionResult } from "@gajae-code/agent-core/compaction";
-import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, TSchema, UsageReport } from "@gajae-code/ai";
+import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, Tool, TSchema, UsageReport } from "@gajae-code/ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
 import type * as piCodingAgent from "@gajae-code/coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@gajae-code/tui";
@@ -173,7 +173,11 @@ export interface ExtensionUIContext {
     }>;
     /** Get current tool output expansion state. */
     getToolsExpanded(): boolean;
-    /** Set tool output expansion state. */
+    /**
+     * Set tool output expansion state. This is an explicit fold choice, pinning
+     * existing tool and read components for their renderer instance lifetime,
+     * the same as the user shortcut.
+     */
     setToolsExpanded(expanded: boolean): void;
 }
 export interface ExtensionTranscriptEntry {
@@ -244,6 +248,8 @@ export interface ExtensionContext {
     getQueuedMessages(): unknown[];
     getActiveTools(): string[];
     getAllTools(): string[];
+    /** Resolve display-safe metadata for a configured tool without exposing its implementation. */
+    resolveTool(name: string): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
     /** Session control seams used by the SDK host. */
     cycleModel(): Promise<{
         model: Model;
@@ -412,6 +418,23 @@ export interface MessageUpdateEvent {
     message: AgentMessage;
     assistantMessageEvent: AssistantMessageEvent;
 }
+export interface ReasoningSummaryStartEvent {
+    type: "reasoning_summary_start";
+    message: AgentMessage;
+    contentIndex: number;
+}
+export interface ReasoningSummaryDeltaEvent {
+    type: "reasoning_summary_delta";
+    message: AgentMessage;
+    contentIndex: number;
+    delta: string;
+}
+export interface ReasoningSummaryEndEvent {
+    type: "reasoning_summary_end";
+    message: AgentMessage;
+    contentIndex: number;
+    content: string;
+}
 /** Fired when a message ends */
 export interface MessageEndEvent {
     type: "message_end";
@@ -579,7 +602,7 @@ export declare function isToolCallEventType<TName extends string, TInput extends
     input: TInput;
 };
 /** Union of all event types */
-export type ExtensionEvent = ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | AutoCompactionStartEvent | AutoCompactionEndEvent | AutoRetryStartEvent | AutoRetryEndEvent | TtsrTriggeredEvent | TodoReminderEvent | GoalUpdatedEvent | CredentialDisabledEvent | UserBashEvent | UserPythonEvent | InputEvent | ToolCallEvent | ToolResultEvent;
+export type ExtensionEvent = ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ReasoningSummaryStartEvent | ReasoningSummaryDeltaEvent | ReasoningSummaryEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | AutoCompactionStartEvent | AutoCompactionEndEvent | AutoRetryStartEvent | AutoRetryEndEvent | TtsrTriggeredEvent | TodoReminderEvent | GoalUpdatedEvent | CredentialDisabledEvent | UserBashEvent | UserPythonEvent | InputEvent | ToolCallEvent | ToolResultEvent;
 export interface ContextEventResult {
     messages?: AgentMessage[];
 }
@@ -657,6 +680,9 @@ export interface ExtensionAPI {
     on(event: "turn_end", handler: ExtensionHandler<TurnEndEvent>): void;
     on(event: "message_start", handler: ExtensionHandler<MessageStartEvent>): void;
     on(event: "message_update", handler: ExtensionHandler<MessageUpdateEvent>): void;
+    on(event: "reasoning_summary_start", handler: ExtensionHandler<ReasoningSummaryStartEvent>): void;
+    on(event: "reasoning_summary_delta", handler: ExtensionHandler<ReasoningSummaryDeltaEvent>): void;
+    on(event: "reasoning_summary_end", handler: ExtensionHandler<ReasoningSummaryEndEvent>): void;
     on(event: "message_end", handler: ExtensionHandler<MessageEndEvent>): void;
     on(event: "tool_execution_start", handler: ExtensionHandler<ToolExecutionStartEvent>): void;
     on(event: "tool_execution_update", handler: ExtensionHandler<ToolExecutionUpdateEvent>): void;
@@ -723,6 +749,8 @@ export interface ExtensionAPI {
     getActiveTools(): string[];
     /** Get all configured tools (built-in + extension tools). */
     getAllTools(): string[];
+    /** Resolve display-safe metadata for a configured tool without exposing its implementation. */
+    resolveTool(name: string): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
     /** Set the active tools by name. */
     setActiveTools(toolNames: string[]): Promise<void>;
     /** Get available slash commands in the current session. */
@@ -889,6 +917,7 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
 export type GetAllToolsHandler = () => string[];
+export type ResolveToolHandler = (name: string) => Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
 export type GetCommandsHandler = () => SlashCommandInfo[];
 export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 export type SetModelHandler = (model: Model) => Promise<boolean>;
@@ -920,6 +949,7 @@ export interface ExtensionActions {
     setLabel: (targetId: string, label: string | undefined) => void;
     getActiveTools: GetActiveToolsHandler;
     getAllTools: GetAllToolsHandler;
+    resolveTool: ResolveToolHandler;
     setActiveTools: SetActiveToolsHandler;
     getCommands: GetCommandsHandler;
     setModel: SetModelHandler;
@@ -955,6 +985,7 @@ export interface ExtensionContextActions {
     getQueuedMessages?: () => unknown[];
     getActiveTools?: () => string[];
     getAllTools?: () => string[];
+    resolveTool?: (name: string) => Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
     shutdown: () => void;
     getContextUsage: () => ContextUsage | undefined;
     compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;

package/dist/types/extensibility/hooks/runner.d.ts

@@ -4,7 +4,7 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai";
 import type { ModelRegistry } from "../../config/model-registry";
-import type { SessionManager } from "../../session/session-manager";
+import { type SessionManager } from "../../session/session-manager";
 import type { AppendEntryHandler, BranchHandler, LoadedHook, NavigateTreeHandler, NewSessionHandler, SendMessageHandler } from "./loader";
 import type { BeforeAgentStartEventResult, HookCommandContext, HookError, HookEvent, HookMessageRenderer, HookUIContext, RegisteredCommand, SessionBeforeCompactResult, SessionBeforeTreeResult, SessionCompactingResult, ToolCallEvent, ToolCallEventResult, ToolResultEventResult } from "./types";
 /**

package/dist/types/extensibility/shared-events.d.ts

@@ -142,6 +142,8 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
     type: "agent_end";
     messages: AgentMessage[];
+    /** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
+    stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
 }
 /** Fired at the start of each turn */
 export interface TurnStartEvent {

package/dist/types/gjc-runtime/deep-interview-recorder.d.ts

@@ -1,4 +1,4 @@
-import { type DeepInterviewEstablishedFact, type DeepInterviewRoundRecord, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
+import { type DeepInterviewEstablishedFact, type DeepInterviewIntentItem, type DeepInterviewIntentSubstitution, type DeepInterviewRoundRecord, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
 export * from "./deep-interview-ambiguity";
 export * from "./deep-interview-state";
 /**
@@ -22,6 +22,15 @@ export interface DeepInterviewAnswerInput {
     ambiguity?: number;
     selectedOptions?: string[];
     customInput?: string;
+    intent_contract?: {
+        items: DeepInterviewIntentItem[];
+        confirmation_options: string[];
+    };
+    intent_review?: {
+        observed_items: DeepInterviewIntentItem[];
+        supporting_substitutions: DeepInterviewIntentSubstitution[];
+        approval_options: string[];
+    };
 }
 export interface DeepInterviewScoringInput {
     interviewId?: string;

package/dist/types/gjc-runtime/deep-interview-state.d.ts

@@ -125,3 +125,47 @@ export declare function mergeDeepInterviewRounds(existing: readonly Record<strin
 export declare function mergeDeepInterviewEnvelope(existing: unknown, incoming: unknown, options?: {
     replace?: boolean;
 }): DeepInterviewStateEnvelope;
+export declare const DEEP_INTERVIEW_INTENT_CATEGORIES: readonly ["artifact", "surface", "integration", "constraint"];
+export type DeepInterviewIntentCategory = (typeof DEEP_INTERVIEW_INTENT_CATEGORIES)[number];
+export interface DeepInterviewIntentItem {
+    id: string;
+    category: DeepInterviewIntentCategory;
+    statement: string;
+}
+export interface DeepInterviewIntentManifest {
+    version: 1;
+    items: DeepInterviewIntentItem[];
+    digest: string;
+    confirmation_round: 0;
+    confirmation_answer_hash: string;
+    confirmation_evidence: string;
+}
+export interface DeepInterviewIntentSubstitution {
+    removed_id: string;
+    replacement_ids: string[];
+    rationale: string;
+}
+export interface DeepInterviewIntentReview {
+    version: 1;
+    status: "not_required" | "pending" | "approved";
+    locked_digest: string;
+    observed_digest: string;
+    removed_locked_ids: string[];
+    supporting_substitutions: DeepInterviewIntentSubstitution[];
+    approval_round?: number;
+    answer_hash?: string;
+    user_answer_evidence?: string;
+}
+export declare function isCanonicalDeepInterviewAnswerHash(value: unknown): value is string;
+export declare function deepInterviewIntentManifestDigest(items: readonly DeepInterviewIntentItem[]): string;
+export declare function deepInterviewObservedIntentDigest(ids: readonly string[]): string;
+export declare function createDeepInterviewIntentManifest(items: readonly DeepInterviewIntentItem[], confirmation: {
+    round: 0;
+    answer_hash: string;
+}): DeepInterviewIntentManifest;
+export declare function assertDeepInterviewIntentManifest(value: unknown): asserts value is DeepInterviewIntentManifest;
+export declare function reviewDeepInterviewIntent(locked: DeepInterviewIntentManifest, observedItems: readonly DeepInterviewIntentItem[], input: Omit<DeepInterviewIntentReview, "version" | "locked_digest" | "observed_digest" | "removed_locked_ids">): DeepInterviewIntentReview;
+export declare function assertDeepInterviewIntentReview(value: unknown, locked: DeepInterviewIntentManifest, observedIds: readonly string[], recordedAnswers: readonly {
+    round: unknown;
+    answer_hash: unknown;
+}[]): asserts value is DeepInterviewIntentReview;