@gajae-code/coding-agent 0.10.2 → 0.11.1

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 } from "@gajae-code/ai";
+import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, 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";
@@ -20,8 +20,9 @@ import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
-import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/unattended-session";
+import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import type { Theme } from "../../modes/theme/theme";
+import type { ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
 import type { BashToolDetails, BashToolInput, FindToolDetails, FindToolInput, ReadToolDetails, ReadToolInput, SearchToolDetails, SearchToolInput, WriteToolInput } from "../../tools";
@@ -54,7 +55,7 @@ export interface ExtensionUIDialogOptions {
     /**
      * For interactive TUI select dialogs, render the focused option across
      * multiple rows instead of truncating it. This is a select-only rendering
-     * hint; non-TUI bridges (RPC, ACP) drop it and do not serialize it.
+     * hint; non-TUI clients (SDK, ACP) drop it and do not serialize it.
      */
     wrapFocused?: boolean;
     /**
@@ -68,7 +69,7 @@ export interface ExtensionUIDialogOptions {
      * inline: selecting it keeps the title and option list on screen and opens
      * a free-text input below the list. Submitting calls `onSubmit` with the
      * typed text and resolves the select with `optionLabel`; Escape returns to
-     * option selection. Non-TUI bridges (RPC, ACP) drop it; callers must keep
+     * option selection. Non-TUI clients (SDK, ACP) drop it; callers must keep
      * a fallback path for selects that resolve `optionLabel` without invoking
      * `onSubmit`.
      */
@@ -104,7 +105,7 @@ export type ExtensionUiComponentFactory = (tui: TUI, theme: Theme) => ExtensionU
 export type ExtensionWidgetContent = string[] | ExtensionUiComponentFactory | undefined;
 /**
  * UI context for extensions to request interactive UI.
- * Each mode (interactive, RPC, print) provides its own implementation.
+ * Interactive, SDK, and headless callers provide their own implementation.
  */
 export interface ExtensionUIContext {
     /** Show a selector and return the user's choice. */
@@ -175,6 +176,13 @@ export interface ExtensionUIContext {
     /** Set tool output expansion state. */
     setToolsExpanded(expanded: boolean): void;
 }
+export interface ExtensionTranscriptEntry {
+    id: string;
+    role: string;
+    textSummary: string;
+    ts: string;
+    body?: string;
+}
 export interface ContextUsage {
     /** Context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
     tokens: number | null;
@@ -204,7 +212,7 @@ export interface ExtensionContext {
     getContextUsage(): ContextUsage | undefined;
     /** Compact the session context (interactive mode shows UI). */
     compact(instructionsOrOptions?: string | CompactOptions): Promise<void>;
-    /** Whether UI is available (false in print/RPC mode) */
+    /** Whether an interactive UI is available */
     hasUI: boolean;
     /** Current working directory */
     cwd: string;
@@ -222,17 +230,60 @@ export interface ExtensionContext {
     abort(): void;
     /** Whether there are queued messages waiting */
     hasPendingMessages(): boolean;
+    /** Typed pending-message counts per queue (steering, follow-up, next-turn). */
+    getPendingMessageCounts(): {
+        steering: number;
+        followUp: number;
+        nextTurn: number;
+    };
+    /** Read-only session data exposed to extensions and the SDK host. */
+    getTranscript(): ExtensionTranscriptEntry[];
+    getTranscriptBody(entryId: string): string | undefined;
+    getGoalState(): unknown;
+    getTodoState(): unknown;
+    getQueuedMessages(): unknown[];
+    getActiveTools(): string[];
+    getAllTools(): string[];
+    /** Session control seams used by the SDK host. */
+    cycleModel(): Promise<{
+        model: Model;
+        thinkingLevel: ThinkingLevel | undefined;
+    } | undefined>;
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    setQueueMode(kind: "steering" | "follow_up" | "interrupt", mode: unknown): boolean;
+    getSkillState(): unknown;
+    getConfigItems(): unknown;
+    getBranchCandidates(): unknown;
+    getExtensions(): unknown;
+    getArtifact(id: string): Uint8Array | string | undefined | Promise<Uint8Array | string | undefined>;
+    getArtifactRange?(id: string, offset: number, length: number): {
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined | Promise<{
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined>;
+    getJobs(): unknown;
+    /** Typed skill and mode controls exposed to the SDK host. */
+    invokeSkill?(name: string, args?: string): Promise<unknown>;
+    setPlanMode?(on: boolean): unknown;
+    operateGoal?(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
+    /** Typed nonvisual session controls exposed to the SDK host. */
+    sdkControl?(operation: string, input: Record<string, unknown>): unknown | Promise<unknown>;
+    /** Install a permission callback backed by a live SDK reverse provider lease. */
+    setSdkPermissionProvider?(provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined): void;
+    /** Names of session SDK seams actually installed by the active runtime. */
+    sdkBindings?(): readonly string[];
     /** Gracefully shutdown and exit. */
     shutdown(): void;
     /** Get the current effective system prompt. */
     getSystemPrompt(): string[];
     /** @deprecated Use hasPendingMessages() instead */
     hasQueuedMessages(): boolean;
-    /**
-     * Unattended workflow-gate bridge. Present only when the session runs in
-     * unattended/RPC mode; `undefined` in interactive/TUI mode (notify-only).
-     */
+    /** SDK workflow-gate bridge, when a session has a remote gate responder. */
     workflowGate?: WorkflowGateEmitter;
+    /** Clear the active conversation while preserving the saved session identity. */
+    clearContext(): Promise<boolean>;
 }
 /**
  * Extended context for command handlers.
@@ -419,12 +470,12 @@ export interface UserPythonEvent {
     /** Current working directory */
     cwd: string;
 }
-/** Fired when the user submits input (interactive mode only). */
+/** Fired when input enters through an interactive, SDK, or extension source. */
 export interface InputEvent {
     type: "input";
     text: string;
     images?: ImageContent[];
-    source: "interactive" | "rpc" | "extension";
+    source: "interactive" | "sdk" | "extension";
 }
 interface ToolCallEventBase {
     type: "tool_call";
@@ -662,7 +713,8 @@ export interface ExtensionAPI {
     /** Send a user message to the agent, or queue it when deliverAs is set. */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
-    }): void;
+        onPreflightAccepted?: () => void;
+    }): Promise<void>;
     /** Append a custom entry to the session for state persistence (not sent to LLM). */
     appendEntry<T = unknown>(customType: string, data?: T): void;
     /** Execute a shell command. */
@@ -680,7 +732,23 @@ export interface ExtensionAPI {
     /** Get current thinking level. */
     getThinkingLevel(): ThinkingLevel | undefined;
     /** Set thinking level for the current session. */
-    setThinkingLevel(level: ThinkingLevel): void;
+    setThinkingLevel(level: ThinkingLevel, persist?: boolean): void;
+    /** Get whether thinking output is visible in the current session. */
+    getThinkingVisibility(): "visible" | "hidden";
+    /** Set whether thinking output is visible for the current session. */
+    setThinkingVisibility(visibility: "visible" | "hidden", persist?: boolean): void;
+    /** Cycle the current model's available thinking levels. */
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    /** Set thinking level from a session or durable global control surface. */
+    setThinkingLevelForControl(level: ThinkingLevel, persist: boolean): Promise<void>;
+    /** Set thinking visibility from a session or durable global control surface. */
+    setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
+    /** Set the model for this session only. Returns false when it is unavailable. */
+    setModelTemporaryForControl(model: Model, expectedSessionId?: string): Promise<boolean>;
+    /** Fetch provider usage through the session's canonical provider resolution. */
+    fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
+    /** Report whether the current effort follows global config or a session override. */
+    getThinkingScopeForControl(): "session" | "global config";
     /** Get the current session name. */
     getSessionName(): string | undefined;
     /** Set the session name. Persists to the session file. */
@@ -816,15 +884,24 @@ options?: {
 }) => void;
 export type SendUserMessageHandler = (content: string | (TextContent | ImageContent)[], options?: {
     deliverAs?: "steer" | "followUp";
-}) => void;
+    onPreflightAccepted?: () => void;
+}) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
 export type GetAllToolsHandler = () => string[];
 export type GetCommandsHandler = () => SlashCommandInfo[];
 export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 export type SetModelHandler = (model: Model) => Promise<boolean>;
+export type CycleThinkingLevelHandler = () => ThinkingLevel | undefined;
+export type SetThinkingLevelForControlHandler = (level: ThinkingLevel, persist: boolean) => Promise<void>;
+export type SetThinkingVisibilityForControlHandler = (visibility: "visible" | "hidden", persist: boolean) => Promise<void>;
+export type SetModelTemporaryForControlHandler = (model: Model, expectedSessionId?: string) => Promise<boolean>;
+export type FetchUsageReportsForControlHandler = () => Promise<UsageReport[] | null>;
+export type GetThinkingScopeForControlHandler = () => "session" | "global config";
 export type GetThinkingLevelHandler = () => ThinkingLevel | undefined;
 export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean) => void;
+export type GetThinkingVisibilityHandler = () => "visible" | "hidden";
+export type SetThinkingVisibilityHandler = (visibility: "visible" | "hidden", persist?: boolean) => void;
 /** Shared state created by loader, used during registration and runtime. */
 export interface ExtensionRuntimeState {
     flagValues: Map<string, boolean | string>;
@@ -848,6 +925,14 @@ export interface ExtensionActions {
     setModel: SetModelHandler;
     getThinkingLevel: GetThinkingLevelHandler;
     setThinkingLevel: SetThinkingLevelHandler;
+    getThinkingVisibility: GetThinkingVisibilityHandler;
+    setThinkingVisibility: SetThinkingVisibilityHandler;
+    cycleThinkingLevel: CycleThinkingLevelHandler;
+    setThinkingLevelForControl: SetThinkingLevelForControlHandler;
+    setThinkingVisibilityForControl: SetThinkingVisibilityForControlHandler;
+    setModelTemporaryForControl: SetModelTemporaryForControlHandler;
+    fetchUsageReportsForControl: FetchUsageReportsForControlHandler;
+    getThinkingScopeForControl: GetThinkingScopeForControlHandler;
     getSessionName: () => string | undefined;
     setSessionName: (name: string) => Promise<void>;
 }
@@ -857,12 +942,52 @@ export interface ExtensionContextActions {
     isIdle: () => boolean;
     abort: () => void;
     hasPendingMessages: () => boolean;
+    /** Typed pending-message counts per queue; optional for embedders without a counted queue. */
+    getPendingMessageCounts?: () => {
+        steering: number;
+        followUp: number;
+        nextTurn: number;
+    };
+    getTranscript?: () => ExtensionTranscriptEntry[];
+    getTranscriptBody?: (entryId: string) => string | undefined;
+    getGoalState?: () => unknown;
+    getTodoState?: () => unknown;
+    getQueuedMessages?: () => unknown[];
+    getActiveTools?: () => string[];
+    getAllTools?: () => string[];
     shutdown: () => void;
     getContextUsage: () => ContextUsage | undefined;
     compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;
     getSystemPrompt: () => string[];
-    /** Unattended workflow-gate bridge (present only in unattended/RPC mode). */
+    /** SDK workflow-gate bridge, when a session has a remote gate responder. */
     getWorkflowGate?: () => WorkflowGateEmitter | undefined;
+    /** Clear the active conversation while preserving the saved session identity. */
+    clearContext?: () => Promise<boolean>;
+    /** Session control and query seams exposed to the per-session SDK host. */
+    cycleModel?: () => Promise<{
+        model: Model;
+        thinkingLevel: ThinkingLevel | undefined;
+    } | undefined>;
+    cycleThinkingLevel?: () => ThinkingLevel | undefined;
+    setQueueMode?: (kind: "steering" | "follow_up" | "interrupt", mode: unknown) => boolean;
+    getSkillState?: () => unknown;
+    getConfigItems?: () => unknown;
+    getBranchCandidates?: () => unknown;
+    getExtensions?: () => unknown;
+    getArtifact?: (id: string) => Uint8Array | string | undefined | Promise<Uint8Array | string | undefined>;
+    getArtifactRange?: (id: string, offset: number, length: number) => {
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined | Promise<{
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined>;
+    getJobs?: () => unknown;
+    setSdkPermissionProvider?: (provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined) => void;
+    sdkControl?: (operation: string, input: Record<string, unknown>) => unknown | Promise<unknown>;
+    invokeSkill?: (name: string, args?: string) => Promise<unknown>;
+    setPlanMode?: (on: boolean) => unknown;
+    operateGoal?: (op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string) => Promise<unknown>;
 }
 /** Actions for ExtensionCommandContext (ctx.* in command handlers). */
 export interface ExtensionCommandContextActions {

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

@@ -11,7 +11,7 @@ import type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompac
 export type { ExecOptions, ExecResult } from "../../exec/exec";
 /**
  * UI context for hooks to request interactive UI from the harness.
- * Each mode (interactive, RPC, print) provides its own implementation.
+ * Interactive and headless callers provide their own implementation.
  */
 export interface HookUIContext {
     /**

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -1,8 +1,9 @@
 import type { Args } from "../cli/args";
 import { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, type GjcTmuxProfileCommand } from "./tmux-common";
 import { type OwnerIsolationProbeSync } from "./tmux-owner-isolation";
-export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
-export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
+import { buildWindowsPowerShellInnerCommand, GJC_TMUX_LAUNCHED_ENV, type WindowsPowerShellInnerCommandOptions } from "./windows-powershell-command";
+export type { WindowsPowerShellInnerCommandOptions };
+export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, buildWindowsPowerShellInnerCommand, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_LAUNCHED_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
 export declare const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export declare const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
 interface TtyState {

package/dist/types/gjc-runtime/psmux-detect.d.ts

@@ -36,6 +36,9 @@ export type PsmuxSpawnRunner = (command: string, args: string[]) => {
 export type BinaryResolver = (candidate: string) => string | null;
 /** @internal Test-only seam; production code never calls this. */
 export declare function __setBinaryResolverForTests(resolver: BinaryResolver | null): void;
+export type ExecutableIdentityResolver = (path: string) => string | null;
+/** @internal Test-only seam; production code never calls this. */
+export declare function __setExecutableIdentityResolverForTests(resolver: ExecutableIdentityResolver | null): void;
 export declare function envDisabled(value: string | undefined): boolean;
 /**
  * Decide whether command resolves to a psmux binary by probing its version

package/dist/types/gjc-runtime/session-state-sidecar.d.ts

@@ -41,6 +41,8 @@ export interface RuntimeStateContext {
     sessionId: string;
     cwd: string;
     sessionFile?: string | null;
+    /** Optional platform seam for deterministic cross-platform path identity checks. */
+    platform?: NodeJS.Platform;
     branch?: string | null;
     /** Public-safe owner metadata used to persist the canonical terminal verdict. */
     ownerTerminal?: OwnerTerminalContext | null;
@@ -60,6 +62,7 @@ export declare function readTerminalRuntimeStateMarker(input: {
     sessionId?: string | null;
     cwd?: string | null;
     sessionFile?: string | null;
+    platform?: NodeJS.Platform;
 }): Promise<TerminalRuntimeStateStatus>;
 export declare function stateForEvent(event: RuntimeStateEvent): RuntimeState | null;
 export declare function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean;

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

@@ -146,7 +146,7 @@ export interface GjcTeamWorkerLifecycle {
 }
 export type GjcTeamNotificationDeliveryState = "pending" | "sent" | "queued" | "deferred" | "failed" | "delivered" | "acknowledged";
 export type GjcTeamPaneAttemptResult = "sent" | "queued" | "deferred" | "failed";
-export type GjcTeamMailboxDeliveryTransportKind = "notifications_sdk" | "pane";
+export type GjcTeamMailboxDeliveryTransportKind = "sdk" | "pane";
 export interface GjcTeamNotification {
     id: string;
     kind: "mailbox_message" | "worker_lifecycle" | "invalid_attempt";
@@ -175,7 +175,7 @@ export interface GjcTeamMailboxDeliveryInput {
     env: NodeJS.ProcessEnv;
 }
 export type GjcTeamMailboxDeliveryResult = {
-    transport: "notifications_sdk";
+    transport: "sdk";
     state: GjcTeamNotificationDeliveryState;
     reason?: string;
 } | {
@@ -314,8 +314,7 @@ export declare function resolveWorkerWorktreePath(input: {
     platform: NodeJS.Platform;
     isPsmux: boolean;
 }): string;
-type CommandPathResolver = (command: string) => string | null;
-export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string, which?: CommandPathResolver): string;
+export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string): string;
 /** @internal Exported for unit tests. */
 export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform): string;
 export type GjcWorkerCheckpointClassification = {

package/dist/types/gjc-runtime/tmux-owner-isolation-cli.d.ts

@@ -1,5 +1,18 @@
+import { type TmuxServerProof } from "./tmux-owner-isolation";
 /** Matches the sole argv shape allowed to enter the owner-isolation JSON-line protocol. */
 export declare function isTmuxOwnerIsolationCliArgv(argv: readonly string[]): boolean;
+interface TmuxListSessionsResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+interface TmuxServerProofOptions {
+    platform?: NodeJS.Platform;
+    runListSessions?: (argv: string[]) => TmuxListSessionsResult;
+}
+/** Probes a tmux server using an injectable list-sessions runner for platform-bounded callers. */
+export declare function tmuxServerProof(socketKey: string, tmuxControlArgv?: string[], options?: TmuxServerProofOptions): Promise<TmuxServerProof>;
 /** Reads exactly one bounded JSON line and writes exactly one JSON response line. */
 export declare function runTmuxOwnerIsolationCli(stdin: string): Promise<string>;
 export declare function runTmuxOwnerIsolationCliFromStdin(): Promise<void>;
+export {};

package/dist/types/gjc-runtime/tmux-sessions.d.ts

@@ -65,6 +65,9 @@ export interface ForceCloseOwnerDependencies {
     sleep(ms: number): Promise<void>;
     listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
 }
+export interface CreateGjcTmuxSessionOptions {
+    platform?: NodeJS.Platform;
+}
 export type CreateOwnerIsolationTestDependencies = {
     probe?: Partial<OwnerIsolationProbeSync>;
     execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
@@ -80,7 +83,7 @@ export declare function findGjcTmuxSessionByBranch(branch: string, env?: NodeJS.
 export declare function findGjcTmuxSessionByName(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function findGjcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function statusGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
-export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
+export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv, options?: CreateGjcTmuxSessionOptions): GjcTmuxSessionStatus;
 /** Proves a managed reusable name still resolves to one immutable session on one server. */
 export declare function proveGjcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv): ProvenTmuxSessionIdentity;
 /** @internal */

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

@@ -26,6 +26,17 @@ export declare function validateReceiptFreshBase(input: {
     receipt: UltragoalCompletionVerification;
     receiptKind: UltragoalReceiptKind;
 }): UltragoalReceiptFreshnessDiagnostic | null;
+/**
+ * Validate a final-aggregate receipt that was legitimately superseded — its
+ * aggregate claim staled by later plan growth (e.g. `steer add_subgoal`
+ * appending goals after a terminal run) — as historical evidence for its own
+ * goal. Returns null when the receipt stands.
+ */
+export declare function validateSupersededFinalAggregateReceipt(input: {
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receipt: UltragoalCompletionVerification;
+}): UltragoalReceiptFreshnessDiagnostic | null;
 export declare function findFreshBatchCloseReceipt(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];

package/dist/types/gjc-runtime/windows-powershell-command.d.ts

@@ -0,0 +1,9 @@
+export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
+export interface WindowsPowerShellInnerCommandOptions {
+    command: readonly string[];
+    args?: readonly string[];
+    environment?: Record<string, string>;
+    tmuxExitMarkerPath?: string;
+}
+/** Builds the shared BOM-free UTF-16LE command for native Windows tmux-compatible panes. */
+export declare function buildWindowsPowerShellInnerCommand({ command, args, environment, tmuxExitMarkerPath, }: WindowsPowerShellInnerCommandOptions): string;

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

@@ -1,16 +1,16 @@
 import { type FinalizeChecks, type FinalizeResult, type ValidationCommandSpec } from "./finalize";
 import { type PreserveResult } from "./preserve";
-import { type HarnessRpc } from "./rpc-adapter";
+import { type HarnessSessionTransport } from "./session-transport";
 import { type HarnessLifecycle, type Observation, type RecoveryClassification, type RetryBudget, type Severity } from "./types";
 export interface OperateOptions {
     root: string;
     sessionId: string;
     workspace: string;
     branch: string;
-    rpc: HarnessRpc;
-    /** Factory used to (re)create the RPC subprocess on restart recovery. Defaults to reusing `rpc`. */
-    rpcFactory?: () => HarnessRpc;
-    /** Bounded observation provider (scripted in tests; real = git + rpc state). */
+    transport: HarnessSessionTransport;
+    /** Factory used to recreate an SDK transport on restart recovery. Defaults to reusing `transport`. */
+    transportFactory?: () => HarnessSessionTransport;
+    /** Bounded observation provider (scripted in tests; real = git + SDK session state). */
     observe: () => Promise<Observation>;
     /** Real dirty-worktree preservation; injectable for tests. Defaults to git stash/diff capture. */
     preserve?: (workspace: string) => PreserveResult;

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

@@ -3,20 +3,22 @@
  *
  * Responsibilities:
  *  - hold the {@link SessionLease} (single writer),
- *  - own the {@link HarnessRpc} subprocess (injected; real `GajaeCodeRpc` in prod, fake in tests),
+ *  - own an injected SDK session transport,
  *  - serve owner-routed primitives over the {@link ControlServer} endpoint,
  *  - be the SOLE writer of the severity event stream,
  *  - heartbeat the lease.
  *
  * Stateless `gjc harness` CLI calls reach the owner via {@link resolveOwner} + the endpoint.
  */
+import { ControlServer, type EndpointHandler } from "./control-endpoint";
 import { type FinalizeChecks, type ValidationCommandSpec } from "./finalize";
-import { type HarnessRpc } from "./rpc-adapter";
-import { type SessionLease } from "./session-lease";
+import { releaseLease, type SessionLease } from "./session-lease";
+import { type HarnessSessionTransport } from "./session-transport";
+import { appendEvent, writeSessionState } from "./storage";
 export interface OwnerOptions {
     root: string;
     sessionId: string;
-    rpc: HarnessRpc;
+    transport: HarnessSessionTransport;
     ownerId?: string;
     ttlMs?: number;
     heartbeatMs?: number;
@@ -24,6 +26,18 @@ export interface OwnerOptions {
     clock?: () => number;
     finalizeChecks?: FinalizeChecks;
     validationCommands?: ValidationCommandSpec[];
+    /** Test seam for deterministic control-endpoint teardown failures. */
+    controlServerFactory?: (socketPath: string, handler: EndpointHandler) => ControlServer;
+    /** Test seam for deterministic lease-release teardown failures. */
+    leaseRelease?: typeof releaseLease;
+    /** Test seams for frame persistence failures. */
+    framePersistence?: {
+        appendEvent?: typeof appendEvent;
+        writeSessionState?: typeof writeSessionState;
+    };
+    /** Test seams; production retries verified shutdown without a finite limit. */
+    cleanupRetryMs?: number;
+    cleanupRetryLimit?: number;
 }
 export interface OwnerStartInfo {
     ownerId: string;

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

@@ -57,7 +57,6 @@ export interface VanishEvidence {
 }
 export interface PromptAcceptanceEvidence {
     promptSha256: string;
-    rpcCommandId: string;
     preSubmitState: {
         isStreaming: boolean;
         steeringQueueDepth: number;

package/dist/types/harness-control-plane/sdk-transport.d.ts

@@ -0,0 +1,43 @@
+import { SdkClient } from "../sdk/client";
+import type { HarnessSessionTransport } from "./session-transport";
+export declare class HarnessSdkTransportError extends Error {
+    readonly code: "endpoint_unavailable" | "invalid_response";
+    readonly cause?: unknown;
+    constructor(code: "endpoint_unavailable" | "invalid_response", message: string, cause?: unknown);
+}
+export interface SpawnedHarnessSession {
+    stop(): Promise<void>;
+}
+export interface CreateSdkSessionTransportOptions {
+    repo: string;
+    sessionId: string;
+    /** Starts the normal GJC session before discovery. Test callers may provide a deterministic SDK host. */
+    spawn?: () => SpawnedHarnessSession | Promise<SpawnedHarnessSession>;
+    discoveryTimeoutMs?: number;
+    /** Test seam: inject SDK client/endpoint resolution to avoid a process-global module mock. */
+    connect?: typeof SdkClient.connect;
+    readEndpoint?: (repo: string, sessionId: string) => Promise<{
+        url: string;
+        token: string;
+    } | null>;
+}
+/**
+ * Connects an owner to the child session's public SDK endpoint. The SDK client owns
+ * hello-gated reconnects; this adapter only owns the bounded discovery wait and child
+ * lifecycle.
+ */
+export declare function createSdkSessionTransport(options: CreateSdkSessionTransportOptions): Promise<HarnessSessionTransport>;
+export interface ReapableHarnessChild {
+    kill(signal?: number | NodeJS.Signals): void;
+    readonly exited: Promise<number>;
+    readonly exitCode: number | null;
+}
+export declare function spawnNormalHarnessSession(repo: string, sessionId: string, options?: {
+    termGraceMs?: number;
+    killVerifyMs?: number;
+}): SpawnedHarnessSession;
+/** Test hook for exact-child stop serialization and retry semantics. */
+export declare function ownedHarnessSessionForTest(child: ReapableHarnessChild, options?: {
+    termGraceMs?: number;
+    killVerifyMs?: number;
+}): SpawnedHarnessSession;

package/dist/types/harness-control-plane/session-transport.d.ts

@@ -0,0 +1,48 @@
+export interface SessionStateSnapshot {
+    isStreaming: boolean;
+    steeringQueueDepth: number;
+    followupQueueDepth: number;
+}
+export interface HarnessSessionTransportCloseContext {
+    /**
+     * Immediate cycle-break acknowledgment for the exact direct close path.
+     *
+     * Invoke this method synchronously before an async close() reaches its first await
+     * (or before a non-async close() returns its promise); the returned promise may be
+     * awaited later. It does NOT signal that RuntimeOwner teardown has completed.
+     */
+    acknowledgeDirectOwnerStopReentry(): Promise<void>;
+}
+/** SDK-backed transport contract for a live harness session. */
+export interface HarnessSessionTransport {
+    getState(): Promise<SessionStateSnapshot>;
+    sendPrompt(prompt: string): Promise<{
+        commandId: string;
+        ack: boolean;
+    }>;
+    eventCursor(): number;
+    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
+        cursor: number;
+    } | null>;
+    /**
+     * Await every transport-owned cleanup step. close() MUST NOT call public
+     * RuntimeOwner.stop(), which would circularly await this close and hang. A transport
+     * that needs that direct cycle break must synchronously invoke
+     * `context.acknowledgeDirectOwnerStopReentry()` before its first await.
+     */
+    close(context?: HarnessSessionTransportCloseContext): Promise<void>;
+    /** Return a synchronous disposer that fully severs this event subscription. */
+    onEventFrame?(listener: (frame: Record<string, unknown>) => void): () => void;
+    isLive?(): boolean;
+    lastFrameAt?(): string | null;
+    getLastAssistantText?(): Promise<string | null>;
+}
+export interface AcceptanceResult {
+    accepted: boolean;
+    reason: string;
+    commandId: string | null;
+    preSubmitCursor: number;
+    agentStartCursor: number | null;
+    preSubmitState: SessionStateSnapshot;
+}
+export declare function singleFlightAccept(transport: HarnessSessionTransport, prompt: string, timeoutMs: number): Promise<AcceptanceResult>;

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

@@ -81,10 +81,9 @@ export interface SessionHandle {
         ownerId: string | null;
         pid: number | null;
     };
-    rpcHandle: {
-        kind: "rpc-subprocess";
-        pid: number | null;
-        sessionDir: string;
+    sdkHandle: {
+        kind: "sdk-session-endpoint";
+        sessionId: string;
     };
     ownerHandle: {
         leasePath: string;

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

@@ -9,7 +9,7 @@ export type { LspServerStatus } from "./client";
 export type { LspToolDetails } from "./types";
 export interface LspStartupServerInfo {
     name: string;
-    status: "connecting" | "ready" | "error";
+    status: "idle" | "connecting" | "ready" | "error";
     fileTypes: string[];
     error?: string;
 }