@gajae-code/coding-agent 0.5.0 → 0.5.1

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

@@ -0,0 +1,134 @@
+/**
+ * `gjc gc` runtime — a global, liveness-only, dry-run-by-default garbage
+ * collector for stale GJC session/PID records.
+ *
+ * Design (see .gjc/plans/ralplan/2026-06-13-1347-954f/pending-approval.md):
+ * - This module is an ORCHESTRATOR only. It owns the shared PID probe, the
+ *   report/exit-code policy, and text/JSON rendering. It must NOT parse private
+ *   store layouts directly; every store is reached through an injectable
+ *   `GcStoreAdapter` that lives next to its store owner.
+ * - Liveness-only and fail-closed: only `ESRCH` (no such process) is `dead`
+ *   (removable). `process.kill(pid, 0)` success, `EPERM`, and any unknown probe
+ *   error all mean KEEP — a live process is never signalled or killed.
+ * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
+ */
+export type GcStore = "harness_leases" | "team_workers" | "file_locks" | "tmux_sessions" | "registry_entries";
+export declare const GC_STORES: readonly GcStore[];
+/** Why a probed pid is kept instead of treated as dead. */
+export type GcPidKeepReason = "alive" | "eperm" | "unknown";
+export interface GcPidProbeResult {
+    /** `dead` only on ESRCH; `keep` for alive/eperm/unknown (fail-closed). */
+    status: "dead" | "keep";
+    reason?: GcPidKeepReason;
+    error?: string;
+}
+/** Single shared liveness contract threaded through every classifier + prune path. */
+export type GcPidProbe = (pid: number) => GcPidProbeResult;
+export type GcPidStatus = "dead" | "alive" | "eperm" | "unknown" | "none";
+export type GcAction = "none" | "would_remove" | "removed" | "remove_failed" | "skipped";
+export interface GcRecord {
+    store: GcStore;
+    /** Stable identifier: session id, lock dir path, worker id, tmux name, registry session id. */
+    id: string;
+    path?: string;
+    root?: string;
+    pid?: number;
+    pid_status?: GcPidStatus;
+    /** Store-specific classification label (e.g. "dead", "live", "unclassified", "terminal_lifecycle"). */
+    status: string;
+    stale: boolean;
+    removable: boolean;
+    action: GcAction;
+    reason: string;
+    detail?: string;
+    error?: string;
+    removed?: boolean;
+}
+export interface GcError {
+    store: GcStore;
+    scope: string;
+    message: string;
+}
+export interface GcCollectResult {
+    records: GcRecord[];
+    errors: GcError[];
+}
+export interface GcPruneOutcome {
+    removed: boolean;
+    error?: string;
+    /** Set when a removable record was skipped at prune time (e.g. TOCTOU became live). */
+    skipped?: string;
+}
+export interface GcContext {
+    probe: GcPidProbe;
+    force: boolean;
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+}
+/**
+ * A store-owned GC adapter. `collect` discovers + classifies (using the shared
+ * probe) without mutating anything. `prune` removes a single record, and MUST
+ * re-validate / re-probe immediately before any destructive action.
+ */
+export interface GcStoreAdapter {
+    store: GcStore;
+    collect(ctx: GcContext): Promise<GcCollectResult>;
+    prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome>;
+}
+export interface GcCounts {
+    discovered: number;
+    stale: number;
+    alive: number;
+    eperm: number;
+    unknown: number;
+    terminal_lifecycle: number;
+    unclassified: number;
+    would_remove: number;
+    removed: number;
+    failed: number;
+    errors: number;
+    by_store: Record<GcStore, {
+        discovered: number;
+        stale: number;
+        would_remove: number;
+        removed: number;
+        failed: number;
+    }>;
+}
+export interface GcReport {
+    dry_run: boolean;
+    stores: Record<GcStore, GcRecord[]>;
+    counts: GcCounts;
+    errors: GcError[];
+}
+export interface GcRunResult {
+    stdout: string;
+    stderr: string;
+    status: number;
+}
+/**
+ * The shared, fail-closed PID probe. ESRCH => dead/removable; success => alive;
+ * EPERM => kept (owned by another user); any other error => kept as unknown.
+ */
+export declare const gcPidProbe: GcPidProbe;
+/** Map a `GcPidProbe` onto the harness lease probe shape (`"alive"|"dead"|"eperm"`). */
+export declare function gcProbeToLeasePidStatus(probe: GcPidProbe): (pid: number) => "alive" | "dead" | "eperm";
+/** Translate a probe result into a record-friendly pid status label. */
+export declare function gcPidStatusLabel(result: GcPidProbeResult): Exclude<GcPidStatus, "none">;
+/**
+ * Collect every store's records (catching hard discovery errors per adapter),
+ * then optionally prune removable records with per-record revalidation.
+ */
+export declare function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext, prune: boolean): Promise<GcReport>;
+/**
+ * Exit-code policy:
+ * - usage/parse error => 2
+ * - hard discovery errors => 1 (both modes)
+ * - prune mode with a failed intended removal => 1
+ * - otherwise => 0
+ */
+export declare function computeExitCode(report: GcReport): number;
+export declare function runGjcGcCommand(argv: string[], cwd?: string, env?: NodeJS.ProcessEnv, adapters?: GcStoreAdapter[]): Promise<GcRunResult>;
+export declare function gcHelpText(): string;
+/** Lazily assemble the real store adapters (kept lazy to avoid import cycles). */
+export declare function defaultGcAdapters(): Promise<GcStoreAdapter[]>;

package/dist/types/gjc-runtime/ledger-event-renderer.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Pure parse + summarize for ledger-backed skill observability.
+ *
+ * Workflow progress for ultragoal/ralplan cannot be observed via subagent tool
+ * events (those skills persist through `bash`-backed `gjc` CLI calls whose tool
+ * `details` carry no structured payload). The durable source of truth is the
+ * append-only ledgers:
+ *   - ultragoal: `.gjc/ultragoal/ledger.jsonl`
+ *   - ralplan:   `.gjc/plans/ralplan/<run-id>/index.jsonl`
+ *
+ * This module is I/O-free: callers read the files and pass lines or already-parsed
+ * rows. It feeds the compact HUD chip builders in `skill-state/workflow-hud.ts`
+ * via the runtime sync paths. Display-string helpers stay theme-free.
+ */
+/** Minimal projection of an ultragoal ledger row used for the HUD chip. */
+export interface UltragoalLedgerEventLite {
+    /** Normalized from the row's `event` field, or `type` for reconcile rows. */
+    event: string;
+    goalId?: string;
+    status?: string;
+    timestamp?: string;
+}
+/**
+ * Coerce an already-parsed ledger row into the lite shape. Accepts both the
+ * `event`-keyed vocabulary (plan_created, goal_started, goal_checkpointed,
+ * steering_accepted/rejected, review_blockers_recorded) and the `type`-keyed
+ * reconcile-failure row (`type: "reconcile_failed"`). Returns undefined when no
+ * event/type discriminator is present.
+ */
+export declare function coerceUltragoalLedgerEvent(row: Record<string, unknown>): UltragoalLedgerEventLite | undefined;
+/** Parse a single ultragoal ledger JSONL line; undefined for blank/malformed lines. */
+export declare function parseUltragoalLedgerLine(line: string): UltragoalLedgerEventLite | undefined;
+/** The most recent event, or undefined when the ledger is empty. */
+export declare function latestUltragoalLedgerEvent(events: readonly UltragoalLedgerEventLite[]): UltragoalLedgerEventLite | undefined;
+/**
+ * Best-effort latest event from raw ledger text: parses line-by-line and skips
+ * blank/malformed rows so a torn or hand-edited ledger never throws on the HUD
+ * path. Strict receipt consumers should keep using the validating reader.
+ */
+export declare function latestUltragoalLedgerEventFromText(text: string): UltragoalLedgerEventLite | undefined;
+/** Minimal projection of a ralplan `index.jsonl` row. */
+export interface RalplanIndexRow {
+    stage: string;
+    stageN?: number;
+}
+/** Parse a single ralplan index JSONL line; undefined for blank/malformed lines. */
+export declare function parseRalplanIndexLine(line: string): RalplanIndexRow | undefined;
+export interface RalplanIndexSummary {
+    /** Number of consensus iterations (planner/revision boundaries), >= 0. */
+    iteration: number;
+    /** Stage names present in the current (latest) iteration, in append order. */
+    currentStages: string[];
+}
+/**
+ * Derive iteration count and current-iteration stage presence from index rows.
+ *
+ * `stage_n` is NOT used as the iteration key: it is stored verbatim per row and a
+ * single planner/architect/critic pass can span multiple stage_n values. Instead,
+ * a `planner` or `revision` row opens a new iteration and subsequent rows attach
+ * to it. No verdict is derived here (index rows carry none).
+ */
+export declare function summarizeRalplanIndex(rows: readonly RalplanIndexRow[]): RalplanIndexSummary;
+/**
+ * Compact, theme-free presence string for the ralplan `stages` chip, e.g.
+ * `P·A·C`. Collapses past `cap` with a "… N more" suffix. Returns undefined when
+ * there are no stages.
+ */
+export declare function formatRalplanStagePresence(stages: readonly string[], cap?: number): string | undefined;

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

@@ -0,0 +1,7 @@
+/**
+ * GC adapter for team workers (`.gjc/state/team/<name>/workers/<id>/` heartbeat
+ * + lifecycle). Liveness-only: numeric PID status dominates lifecycle/heartbeat
+ * signals.
+ */
+import type { GcStoreAdapter } from "./gc-runtime";
+export declare const teamWorkersGcAdapter: GcStoreAdapter;

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

@@ -1,4 +1,5 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
+import type { GcPidProbe, GcRecord } from "./gc-runtime";
 export type GjcTeamPhase = "starting" | "running" | "awaiting_integration" | "complete" | "failed" | "cancelled";
 export type GjcTeamTaskStatus = "pending" | "blocked" | "in_progress" | "completed" | "failed";
 export type GjcWorkerStatusState = "idle" | "working" | "blocked" | "done" | "failed" | "draining" | "unknown";
@@ -272,6 +273,10 @@ export interface GjcWorkerIntegrationAttemptRequestResult {
 }
 export declare const GJC_TEAM_API_OPERATIONS: readonly ["send-message", "broadcast", "mailbox-list", "mailbox-mark-delivered", "mailbox-mark-notified", "notification-list", "notification-read", "notification-replay", "notification-mark-pane-attempt", "worker-startup-ack", "create-task", "read-task", "list-tasks", "update-task", "claim-task", "transition-task-status", "transition-task", "release-task-claim", "read-config", "read-manifest", "read-worker-status", "update-worker-status", "read-worker-heartbeat", "recover-stale-claims", "update-worker-heartbeat", "write-worker-inbox", "write-worker-identity", "append-event", "read-events", "read-traces", "await-event", "write-shutdown-request", "read-shutdown-ack", "read-monitor-snapshot", "write-monitor-snapshot", "read-task-approval", "write-task-approval"];
 export declare function resolveGjcTeamStateRoot(cwd?: string, env?: NodeJS.ProcessEnv): string;
+/** @internal */
+export declare function listTeamWorkerGcRecords(teamRoot: string, probe: GcPidProbe): Promise<GcRecord[]>;
+/** @internal */
+export declare function pruneTeamWorkerGcRecord(record: GcRecord, probe: GcPidProbe): Promise<boolean>;
 export declare function persistGjcTeamModeStateSummary(snapshot: GjcTeamSnapshot, cwd?: string): Promise<void>;
 export declare function recoverGjcTeamStaleClaims(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamLivenessRecoveryResult>;
 type GjcTeamTaskMetadataInput = Partial<Pick<GjcTeamTask, "owner" | "lane" | "required_role" | "allowed_roles" | "depends_on" | "blocked_by">>;

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

@@ -21,6 +21,17 @@ export interface TmuxCommandResult {
 export type TmuxCommandRunner = (args: string[]) => TmuxCommandResult;
 export declare function envDisabled(value: string | undefined): boolean;
 export declare function resolveGjcTmuxCommand(env?: NodeJS.ProcessEnv): string;
+/**
+ * Build the exact-session target for tmux *option* commands
+ * (`show-options` / `set-option`) and `display-message -t`.
+ *
+ * Session-scoped commands such as `kill-session` / `attach-session` resolve a
+ * bare exact target (`=NAME`), but tmux 3.6a refuses to resolve a bare `=NAME`
+ * for option/display commands. Appending the empty window separator (`=NAME:`)
+ * keeps the exact-session match while giving tmux the window-qualified target
+ * those commands require. See gajae-code#580.
+ */
+export declare function buildGjcTmuxExactOptionTarget(sessionName: string): string;
 export declare const GJC_TMUX_UNTAGGED_REASON = "gjc_tmux_session_untagged";
 export declare function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string;
 export declare function buildGjcTmuxUntaggedSessionError(sessionName: string, tmuxCommand: string): string;

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

@@ -0,0 +1,7 @@
+/**
+ * GC adapter for gjc-tagged tmux sessions. Stale iff `@gjc-project` path is gone
+ * OR `@gjc-branch` has no live git worktree. Removal is a spec-authorized
+ * destructive `kill-session`, gated by exact-target re-read + revalidation.
+ */
+import type { GcStoreAdapter } from "./gc-runtime";
+export declare const tmuxSessionsGcAdapter: GcStoreAdapter;

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

@@ -9,9 +9,22 @@ export interface GjcTmuxSessionStatus {
     branchSlug?: string;
     project?: string;
 }
+export interface GjcTmuxSessionTagsForGc {
+    profile?: string;
+    project?: string;
+    branch?: string;
+}
+export interface GjcTmuxSessionsForGc {
+    tagged: GjcTmuxSessionStatus[];
+    untagged: string[];
+}
 export declare function listGjcTmuxSessions(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus[];
+/** @internal */
+export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): GjcTmuxSessionsForGc;
 export declare function findGjcTmuxSessionByBranch(branch: string, env?: NodeJS.ProcessEnv, project?: string | null): GjcTmuxSessionStatus | undefined;
 export declare function statusGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
 export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
+/** @internal */
+export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionTagsForGc;
 export declare function removeGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
 export declare function attachGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

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

@@ -0,0 +1,3 @@
+import { type GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+export declare const harnessLeasesGcAdapter: GcStoreAdapter;
+export declare const registryEntriesGcAdapter: GcStoreAdapter;

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

@@ -44,3 +44,10 @@ export interface ResolvedOwner {
 }
 /** Determine whether a live owner currently holds the session (for CLI routing). */
 export declare function resolveOwner(root: string, sessionId: string): Promise<ResolvedOwner>;
+/**
+ * Owner liveness for verbs that do not route to the owner (e.g. `classify`): a routable owner
+ * has a live lease and a socket endpoint. This is the same lease/socket probe `observe` uses to
+ * decide routing, so non-routing verbs derive `ownerLive` consistently instead of assuming the
+ * owner is gone (which would misclassify a live owner as vanished/restart-clean).
+ */
+export declare function resolveOwnerLive(root: string, sessionId: string): Promise<boolean>;

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

@@ -1,8 +1,28 @@
 import type { EventEnvelope, ReceiptFamily, SessionState } from "./types";
+interface HarnessRootRegistryEntry {
+    root: string;
+    updatedAt: string;
+}
+export interface HarnessRootRegistryForGc {
+    sessionId: string;
+    roots: HarnessRootRegistryEntry[];
+}
+export interface HarnessRootRegistryListingForGc {
+    sessionId: string;
+    file: string;
+    roots: HarnessRootRegistryEntry[];
+    error?: string;
+}
 interface ResolveHarnessSessionRootOptions {
     expectedWorkspace?: string;
 }
 export declare function canonicalWorkspacePath(workspace: string): string;
+/** @internal */
+export declare function listHarnessRootRegistriesForGc(env?: NodeJS.ProcessEnv): Promise<HarnessRootRegistryListingForGc[]>;
+/** @internal */
+export declare function rewriteHarnessRootRegistryForGc(file: string, registry: HarnessRootRegistryForGc): Promise<void>;
+/** @internal */
+export declare function removeHarnessRootRegistryFileForGc(file: string): Promise<void>;
 export declare const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 export declare function controlSocketPath(root: string, sessionId: string, env?: NodeJS.ProcessEnv): string;
 export declare class StorageError extends Error {

package/dist/types/modes/components/hook-selector.d.ts

@@ -2,7 +2,7 @@
  * Generic selector component for hooks.
  * Displays a list of string options with keyboard navigation.
  */
-import { Container, type TUI } from "@gajae-code/tui";
+import { type AutocompleteProvider, Container, type TUI } from "@gajae-code/tui";
 export interface HookSelectorOptions {
     tui?: TUI;
     timeout?: number;
@@ -33,6 +33,12 @@ export interface HookSelectorOptions {
         optionLabel: string;
         onSubmit: (text: string) => void;
     };
+    /**
+     * Autocomplete provider for the inline custom-input editor. When present,
+     * the "Other (type your own)" editor gains the same `@` file-link and `/`
+     * completion behavior as the main prompt editor.
+     */
+    autocompleteProvider?: AutocompleteProvider;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

package/dist/types/modes/controllers/command-controller.d.ts

@@ -35,3 +35,4 @@ export declare class CommandController {
     handleContributionPrepCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number): string;

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

@@ -1,3 +1,15 @@
+/**
+ * RPC mode: Headless operation with JSON stdin/stdout protocol.
+ *
+ * Used for embedding the agent in other applications.
+ * Receives commands as JSON on stdin, outputs events and responses as JSON on stdout.
+ *
+ * Protocol:
+ * - Commands: JSON objects with `type` field, optional `id` for correlation
+ * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
+ * - Events: AgentSessionEvent objects streamed as they occur
+ * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
+ */
 import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
 import type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
@@ -7,6 +19,7 @@ export type PendingExtensionRequest = {
     reject: (error: Error) => void;
 };
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+export declare function shouldEmitRpcTitlesForTest(): boolean;
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;
@@ -14,4 +27,6 @@ export declare function requestRpcEditor(pendingRequests: Map<string, PendingExt
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, options?: {
+    listen?: string;
+}): Promise<never>;

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

@@ -1,6 +1,14 @@
 import type { OpenGateInput } from "./workflow-gate-broker";
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
 export declare const GATE_OTHER_OPTION = "Other (type your own)";
+/** Optional structured deep-interview round metadata supplied by the agent. */
+export interface AskGateDeepInterviewState {
+    round_id?: string;
+    round: number;
+    component: string;
+    dimension: string;
+    ambiguity: number;
+}
 export interface AskGateQuestion {
     id: string;
     question: string;
@@ -9,6 +17,11 @@ export interface AskGateQuestion {
     }>;
     multi?: boolean;
     recommended?: number;
+    /**
+     * Structured round metadata. When present it is the authoritative source for gate
+     * `stage_state`; when absent, the question text is regex-parsed as a fallback.
+     */
+    deepInterview?: AskGateDeepInterviewState;
 }
 export interface AskGateResult {
     id: string;

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

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

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

@@ -20,6 +20,8 @@ import type { RpcUnattendedActionClass } from "../../rpc/rpc-types";
 import type { BridgeCommandScope } from "./scopes";
 /** Coarse command scope -> `command.<scope>` action class. */
 export declare function actionClassForScope(scope: BridgeCommandScope): RpcUnattendedActionClass;
+/** Runtime list of every v1 action class — membership-validation source for negotiate (#319). */
+export declare const RPC_UNATTENDED_ACTION_CLASSES: readonly RpcUnattendedActionClass[];
 /**
  * Classify a (possibly compound / nested) bash command into the most severe
  * action class across all statements and nested substitutions. Fail-closed.

package/dist/types/session/agent-session.d.ts

@@ -143,7 +143,7 @@ export type AgentSessionEvent = AgentEvent | {
 };
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "endTime" | "metadata">;
 export interface AsyncJobSnapshot {
     running: AsyncJobSnapshotItem[];
     recent: AsyncJobSnapshotItem[];

package/dist/types/session/blob-store.d.ts

@@ -78,22 +78,58 @@ export declare function externalizeImageDataSync(blobStore: BlobStore, base64Dat
 /**
  * Resolve an externalized provider image data URL back to its original string.
  * If the data is not a blob reference, returns it unchanged.
- * If the blob is missing, logs a warning and returns the reference as-is.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the persisted blob is missing
+ * (e.g. resuming an old session whose image blob was pruned), this warns and returns
+ * the reference as-is rather than throwing, so legacy resume degrades gracefully.
+ * New resident byte-sensitive TEXT uses the fail-closed path instead
+ * (`resolveTextBlobSync` -> `ResidentBlobMissingError`). Do NOT route new byte-sensitive
+ * resident data through this warn-and-return path.
  */
 export declare function resolveImageDataUrl(blobStore: BlobStore, data: string): Promise<string>;
 /**
  * Resolve a blob reference back to base64 data.
  * If the data is not a blob reference, returns it unchanged.
- * If the blob is missing, logs a warning and returns a placeholder.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the blob is missing this warns
+ * and returns the reference as-is (downstream sees an invalid base64 ref but does not
+ * crash), preserving legacy-session resume. Byte-sensitive resident TEXT is fail-closed
+ * via `resolveTextBlobSync`; do NOT route new byte-sensitive resident data here.
  */
 export declare function resolveImageData(blobStore: BlobStore, data: string): Promise<string>;
 /** Synchronously resolve an externalized provider image data URL back to its original string. */
 export declare function resolveImageDataUrlSync(blobStore: BlobStore, data: string): string;
 /** Synchronously resolve a blob reference back to base64 data. */
 export declare function resolveImageDataSync(blobStore: BlobStore, data: string): string;
-/** Synchronously resolve a blob reference back to utf8 text. */
+/**
+ * Synchronously resolve a blob reference back to utf8 text.
+ *
+ * FAIL-CLOSED byte-sensitive path: a missing resident blob throws
+ * `ResidentBlobMissingError` rather than degrading, so a missing resident text blob can
+ * never silently leak a `blob:sha256:` ref into provider payloads, UI, or exports.
+ * (Contrast the legacy persisted-image warn-and-return resolvers above.)
+ */
 export declare function resolveTextBlobSync(blobStore: BlobStore, data: string, context?: {
     kind?: "text";
     sessionId?: string;
     sessionFile?: string;
 }): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataUrlSync}: a missing resident
+ * image-data-url blob throws `ResidentBlobMissingError` ("imageUrl") instead of warn-returning,
+ * so resident byte-sensitive provider image data can never leak a `blob:sha256:` ref into
+ * materialized entries, context, or provider payloads. The warn-and-return `resolveImageDataUrl*`
+ * resolvers remain ONLY for legacy persisted-image resume.
+ */
+export declare function resolveResidentImageDataUrlSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataSync}: a missing resident image blob
+ * throws `ResidentBlobMissingError` ("imageData") instead of warn-returning a placeholder.
+ */
+export declare function resolveResidentImageDataSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;

package/dist/types/skill-state/workflow-hud.d.ts

@@ -18,6 +18,8 @@ interface RalplanHudState extends WorkflowGateHudState {
     stage?: string;
     waiting?: string;
     iteration?: number;
+    iterationFromIndex?: number;
+    stages?: string;
     verdict?: string;
     latestSummary?: string;
     pendingApproval?: boolean;
@@ -61,6 +63,18 @@ interface TeamHudState extends WorkflowGateHudState {
     };
 }
 export declare function buildDeepInterviewHudSummary(state: DeepInterviewHudState): WorkflowHudSummary;
+export interface DeepInterviewHudDeriveOptions {
+    phase?: string;
+    specStatus?: string;
+    updatedAt?: string;
+}
+/**
+ * Single source of deep-interview HUD derivation. Reads a complete (normalized)
+ * mode-state envelope so recorder, `gjc state write`, reconcile, seed, and handoff
+ * all produce identical chips. Topology-aware `target`/`weakest` come from
+ * `state.topology`; `legacy_missing` topology omits those chips (no synthetic values).
+ */
+export declare function deriveDeepInterviewHud(payload: Record<string, unknown>, options?: DeepInterviewHudDeriveOptions): WorkflowHudSummary;
 export declare function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary;
 export declare function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary;
 export declare function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary;

package/dist/types/tools/ask.d.ts

@@ -20,7 +20,7 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
-declare const askSchema: z.ZodObject<{
+export declare const askSchema: z.ZodObject<{
     questions: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         question: z.ZodString;
@@ -29,6 +29,13 @@ declare const askSchema: z.ZodObject<{
         }, z.core.$strip>>;
         multi: z.ZodOptional<z.ZodBoolean>;
         recommended: z.ZodOptional<z.ZodNumber>;
+        deepInterview: z.ZodOptional<z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            round: z.ZodNumber;
+            component: z.ZodString;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AskToolInput = z.infer<typeof askSchema>;
@@ -73,6 +80,13 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
             }, z.core.$strip>>;
             multi: z.ZodOptional<z.ZodBoolean>;
             recommended: z.ZodOptional<z.ZodNumber>;
+            deepInterview: z.ZodOptional<z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                round: z.ZodNumber;
+                component: z.ZodString;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly strict = true;

package/dist/types/tools/subagent.d.ts

@@ -46,6 +46,12 @@ export interface SubagentSnapshot {
     progress?: AgentProgress;
     /** True when a live in-session progress producer exists for this subagent. */
     liveProgressAvailable?: boolean;
+    /** Model the subagent actually runs on (after any auth fallback). */
+    effectiveModel?: string;
+    /** Model originally requested via role/preset mapping; differs from effective on fallback. */
+    requestedModel?: string;
+    /** True when the requested model lacked credentials and fell back to the parent model. */
+    modelFellBack?: boolean;
 }
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -51,12 +51,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.5.0",
-		"@gajae-code/agent-core": "0.5.0",
-		"@gajae-code/ai": "0.5.0",
-		"@gajae-code/natives": "0.5.0",
-		"@gajae-code/tui": "0.5.0",
-		"@gajae-code/utils": "0.5.0",
+		"@gajae-code/stats": "0.5.1",
+		"@gajae-code/agent-core": "0.5.1",
+		"@gajae-code/ai": "0.5.1",
+		"@gajae-code/natives": "0.5.1",
+		"@gajae-code/tui": "0.5.1",
+		"@gajae-code/utils": "0.5.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",