@gajae-code/coding-agent 0.3.0 → 0.3.2

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

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

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

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

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

@@ -123,6 +123,7 @@ export interface InteractiveModeContext {
     }): void;
     showError(message: string): void;
     showWarning(message: string): void;
+    notifyConfigChanged?: () => Promise<void> | void;
     showNewVersionNotification(newVersion: string): void;
     clearEditor(): void;
     updatePendingMessagesDisplay(): void;
@@ -228,6 +229,7 @@ export interface InteractiveModeContext {
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): void;
     showSessionObserver(): void;
+    showJobsOverlay(): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;
     handleCtrlD(): void;

package/dist/types/sdk.d.ts

@@ -93,7 +93,9 @@ export interface CreateAgentSessionOptions {
     requireYieldTool?: boolean;
     /** Task recursion depth (for subagent sessions). Default: 0 */
     taskDepth?: number;
-    /** Parent Hindsight state to alias for subagent memory tools. */
+    /** Current role-agent type/name for nested task sessions. */
+    currentAgentType?: string;
+    /** Parent Hindsight state to alias for subagent private memory backend compatibility. */
     parentHindsightSessionState?: HindsightSessionState;
     /** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
     agentId?: string;

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

@@ -133,7 +133,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">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
 export interface AsyncJobSnapshot {
     running: AsyncJobSnapshotItem[];
     recent: AsyncJobSnapshotItem[];
@@ -358,6 +358,7 @@ export declare class AgentSession {
      *  Does NOT push to the agent's steering/followUp queue — that happens
      *  separately inside `sendCustomMessage`. */
     enqueueCustomMessageDisplay(text: string, mode: "steer" | "followUp"): string;
+    getAgentId(): string | undefined;
     getAsyncJobSnapshot(options?: {
         recentLimit?: number;
     }): AsyncJobSnapshot | null;
@@ -577,6 +578,10 @@ export declare class AgentSession {
     };
     /** Number of pending messages (includes steering, follow-up, and next-turn messages) */
     get queuedMessageCount(): number;
+    /** Whether the agent has queued steering messages that a `user_interrupt`
+     *  abort would resume into (steer-on-interrupt). Drives the Esc-on-steer UX:
+     *  the first Esc consumes the steer and auto-continues, a second Esc aborts. */
+    get hasQueuedSteering(): boolean;
     /** Get pending messages (read-only). Returns the public text-only view;
      *  internal `{text, tag?}` records are mapped to `.text` so callers
      *  (`updatePendingMessagesDisplay`, `restoreQueuedMessagesToEditor`) see
@@ -606,6 +611,11 @@ export declare class AgentSession {
         goalReason?: "interrupted" | "internal";
         timeoutMs?: number;
         cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
+        /** Suppress the "Operation aborted" line on the resulting aborted message
+         *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
+         *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
+         *  hand-off rather than a failure. */
+        silent?: boolean;
     }): Promise<void>;
     /**
      * Start a new session, optionally with initial messages and parent tracking.

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

@@ -1,7 +1,6 @@
 import { type CanonicalGjcWorkflowSkill } from "./active-state";
+export { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION, WORKFLOW_STATE_VERSION, } from "./workflow-state-version";
 export type { CanonicalGjcWorkflowSkill };
-export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
-export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;
 export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
 export type WorkflowStateReceiptStatus = "fresh" | "stale";
 export interface WorkflowStateContentChecksum {

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

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_VERSION = 2;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;

package/dist/types/task/executor.d.ts

@@ -37,6 +37,7 @@ export interface ExecutorOptions {
      * if the resolved subagent model has no working credentials. See #985.
      */
     parentActiveModelPattern?: string;
+    parentSessionId?: string;
     thinkingLevel?: ThinkingLevel;
     outputSchema?: unknown;
     /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */

package/dist/types/task/id.d.ts

@@ -0,0 +1,7 @@
+export declare const TASK_ID_PATTERN: RegExp;
+export declare const TASK_ID_DESCRIPTION = "filesystem-safe identifier matching ^[A-Za-z0-9][A-Za-z0-9_-]{0,47}$";
+export declare function isValidTaskId(id: string): boolean;
+export declare function getTaskIdValidationError(id: unknown): string | undefined;
+export declare function validateTaskId(id: string): string;
+export declare function isValidAllocatedTaskId(id: string): boolean;
+export declare function validateAllocatedTaskId(id: string): string;

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

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { Model } from "@gajae-code/ai";
 import type { ToolSession } from "..";
 import type { Theme } from "../modes/theme/theme";
 import { type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
@@ -7,9 +8,13 @@ import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
+export { isValidAllocatedTaskId, isValidTaskId, TASK_ID_DESCRIPTION, TASK_ID_PATTERN, validateAllocatedTaskId, validateTaskId, } from "./id";
 export { AgentOutputManager } from "./output-manager";
+export type { TaskResultReceipt } from "./receipt";
+export { assertNoRawTaskFields, buildTaskReceipt, buildTaskRoi, buildTaskRoiSummary, findRawTaskLeakKeys, sanitizeTaskToolDetails, } from "./receipt";
 export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
+export declare function resolveForkContextMaxTokens(configured: number, model: Model | undefined): number;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *

package/dist/types/task/receipt.d.ts

@@ -0,0 +1,85 @@
+import type { SingleResult, TaskToolDetails } from "./types";
+export interface TaskRoi {
+    tokens: number;
+    contextTokens?: number;
+    clonedTokens?: number;
+    costTotal?: number;
+    outputBytes?: number;
+    outputLines?: number;
+    producedChanges: boolean;
+    materialContribution: boolean;
+    lowRoi: boolean;
+}
+export interface TaskResultReceipt {
+    index: number;
+    id: string;
+    agent: string;
+    agentSource: SingleResult["agentSource"];
+    task: string;
+    assignment?: string;
+    description?: string;
+    status: "completed" | "failed" | "aborted" | "merge_failed" | "paused";
+    exitCode: number;
+    aborted?: boolean;
+    paused?: boolean;
+    truncated: boolean;
+    durationMs: number;
+    tokens: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    modelOverride?: string | string[];
+    usage?: SingleResult["usage"];
+    cost?: number;
+    branchName?: string;
+    retryFailure?: {
+        attempt: number;
+        errorSummary: string;
+    };
+    errorSummary?: string;
+    abortSummary?: string;
+    preview: string;
+    previewTruncated: boolean;
+    outputRef?: {
+        uri: string;
+        sizeBytes: number;
+        lineCount: number;
+        sha256?: string;
+    };
+    outputUnavailable?: boolean;
+    review?: {
+        overallCorrectness?: string;
+        findingCount: number;
+        findings?: Array<{
+            severity?: string;
+            summary: string;
+        }>;
+    };
+    extractedToolCounts?: Record<string, number>;
+    forkContext?: SingleResult["forkContext"];
+    roi?: TaskRoi;
+}
+/**
+ * Heuristic task ROI signal built only from receipt-safe accounting fields.
+ * Advisory only: these flags never change task success/failure semantics.
+ */
+export declare function buildTaskRoi(raw: SingleResult): TaskRoi;
+export declare function buildTaskRoiSummary(receipts: readonly TaskResultReceipt[]): TaskToolDetails["roiSummary"];
+export declare function buildTaskReceipt(raw: SingleResult): TaskResultReceipt;
+/**
+ * Raw, pre-sanitization task details: the internal shape produced during task
+ * execution, where `results` are full `SingleResult` objects. The public
+ * `TaskToolDetails` exposes only receipts.
+ */
+export interface RawTaskToolDetails {
+    projectAgentsDir: string | null;
+    results: SingleResult[];
+    totalDurationMs: number;
+    usage?: TaskToolDetails["usage"];
+    async?: TaskToolDetails["async"];
+    forkContextClonedTokens?: number;
+    roiSummary?: TaskToolDetails["roiSummary"];
+}
+/** Central converter from raw task details to receipt-only public details. */
+export declare function sanitizeTaskToolDetails(raw: RawTaskToolDetails): TaskToolDetails;
+export declare function findRawTaskLeakKeys(value: unknown): string[];
+export declare function assertNoRawTaskFields(value: unknown, surface: string): void;

package/dist/types/task/spawn-gate.d.ts

@@ -0,0 +1,38 @@
+/** The hard, locked batch threshold enforced by the runtime gate. */
+export declare const DEFAULT_SPAWN_THRESHOLD = 4;
+/** The justification a large batch or reviewer-spawned explorer must supply to pass the hard gate. */
+export interface SpawnPlanReceipt {
+    whyParallel: string;
+    whyNotLocal: string;
+    independence: string;
+    expectedReceiptShape: string;
+    maxInlineTokens: number;
+}
+export interface SpawnGateRequest {
+    /** Number of children the batch wants to spawn. */
+    childCount: number;
+    /** The spawn-plan receipt, when provided. */
+    plan?: SpawnPlanReceipt;
+}
+export interface ReviewerExploreGateRequest {
+    /** Agent type/name doing the spawning, when known. */
+    spawningAgentType?: string | null;
+    /** Target agent type/name requested by the task call. */
+    targetAgent: string;
+    /** The spawn-plan receipt, when provided. */
+    plan?: SpawnPlanReceipt;
+}
+export type SpawnGateOutcome = "allowed" | "rejected";
+export interface SpawnGateDecision {
+    outcome: SpawnGateOutcome;
+    /** Human-readable reason, suitable for a blocked-result message. */
+    reason: string;
+    /** Whether a plan was required for this request. */
+    planRequired: boolean;
+    /** Missing plan field names when rejected for an incomplete plan. */
+    missingFields: readonly string[];
+}
+export declare function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[];
+export declare function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision;
+export declare function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision;
+export declare function evaluateReviewerExploreGate(request: ReviewerExploreGateRequest): SpawnGateDecision;

package/dist/types/task/types.d.ts

@@ -1,11 +1,14 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Usage } from "@gajae-code/ai";
 import * as z from "zod/v4";
+import type { TaskResultReceipt } from "./receipt";
 import { type TaskSimpleMode } from "./simple-mode";
+import type { SpawnPlanReceipt } from "./spawn-gate";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 export type ForkContextPolicy = "forbidden" | "allowed";
+export type ForkContextMode = "none" | "receipt" | "last-turn" | "bounded" | "full";
 /** Maximum output bytes per agent */
 export declare const MAX_OUTPUT_BYTES: number;
 /** Maximum output lines per agent */
@@ -41,7 +44,13 @@ export declare const taskItemSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     assignment: z.ZodString;
-    inheritContext: z.ZodOptional<z.ZodBoolean>;
+    inheritContext: z.ZodOptional<z.ZodEnum<{
+        bounded: "bounded";
+        full: "full";
+        "last-turn": "last-turn";
+        none: "none";
+        receipt: "receipt";
+    }>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -50,7 +59,20 @@ export declare const taskSchema: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const taskSchemaNoIsolation: z.ZodObject<{
@@ -59,7 +81,20 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
@@ -68,7 +103,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -76,7 +124,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -84,7 +145,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -92,7 +166,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -100,7 +187,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -108,7 +208,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
@@ -123,6 +236,7 @@ export interface TaskParams {
     agent: string;
     context?: string;
     schema?: string;
+    spawnPlan?: SpawnPlanReceipt;
     tasks: TaskItem[];
     isolated?: boolean;
 }
@@ -273,6 +387,8 @@ export interface SingleResult {
     branchName?: string;
     /** Nested repo patches to apply after parent merge */
     nestedPatches?: NestedRepoPatch[];
+    /** Whether isolated execution produced a non-empty root or nested patch. */
+    producedChanges?: boolean;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -289,16 +405,32 @@ export interface SingleResult {
     outputMeta?: {
         lineCount: number;
         charCount: number;
+        byteSize?: number;
+        sha256?: string;
+    };
+    /** Fork-context seed accounting for this subagent, when inherited parent context was cloned. */
+    forkContext?: {
+        mode: ForkContextMode;
+        clonedTokens: number;
     };
 }
 /** Tool details for TUI rendering */
 export interface TaskToolDetails {
     projectAgentsDir: string | null;
-    results: SingleResult[];
+    results: TaskResultReceipt[];
     totalDurationMs: number;
     /** Aggregated usage across all subagents. */
     usage?: Usage;
-    outputPaths?: string[];
+    /** Aggregate cloned tokens copied into fork-context seeds across subagents. */
+    forkContextClonedTokens?: number;
+    roiSummary?: {
+        childCount: number;
+        totalTokens: number;
+        totalCostTotal?: number;
+        totalClonedTokens?: number;
+        /** Advisory ids for terminal children that spent tokens without detectable output/review/changes. */
+        lowRoiChildIds: string[];
+    };
     progress?: AgentProgress[];
     async?: {
         state: "running" | "paused" | "queued" | "completed" | "failed";

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

@@ -52,6 +52,12 @@ export interface CronDeleteToolDetails {
 export declare function clearOwnerSchedules(ownerId: string | undefined): void;
 /** Reset every owner's schedule store. Test-only. */
 export declare function resetCronRegistryForTests(): void;
+/** Subscribe to cron schedule-set changes. Returns an unsubscribe function. */
+export declare function onCronChange(cb: () => void): () => void;
+/** Snapshot the scheduled cron jobs for an owner (or all owners when omitted). */
+export declare function listCronSnapshots(ownerId?: string): CronJobSnapshot[];
+/** Delete a scheduled cron job by owner-scoped id. Returns true when removed. */
+export declare function deleteCronJobById(ownerId: string | undefined, id: string): boolean;
 export declare function validateCronExpression(expression: string): void;
 export declare function findNextCronMatchMs(expression: string, afterMs: number, deadlineMs?: number): number | undefined;
 export declare function calculateCronFireTimeMs(params: {

package/dist/types/tools/hindsight-recall.d.ts

@@ -14,8 +14,6 @@ export declare class HindsightRecallTool implements AgentTool<typeof hindsightRe
         query: z.ZodString;
     }, z.core.$strip>;
     readonly strict = true;
-    readonly loadMode = "discoverable";
-    readonly summary = "Search hindsight memory for relevant prior context";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): HindsightRecallTool | null;
     execute(_id: string, params: HindsightRecallParams, signal?: AbortSignal): Promise<AgentToolResult>;

package/dist/types/tools/hindsight-reflect.d.ts

@@ -16,8 +16,6 @@ export declare class HindsightReflectTool implements AgentTool<typeof hindsightR
         context: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly strict = true;
-    readonly loadMode = "discoverable";
-    readonly summary = "Reflect on recent work and write hindsight memory";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): HindsightReflectTool | null;
     execute(_id: string, params: HindsightReflectParams, signal?: AbortSignal): Promise<AgentToolResult>;

package/dist/types/tools/hindsight-retain.d.ts

@@ -20,8 +20,6 @@ export declare class HindsightRetainTool implements AgentTool<typeof hindsightRe
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly strict = true;
-    readonly loadMode = "discoverable";
-    readonly summary = "Store important facts in hindsight memory";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): HindsightRetainTool | null;
     execute(_id: string, params: HindsightRetainParams): Promise<AgentToolResult>;

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

@@ -37,9 +37,6 @@ export * from "./debug";
 export * from "./eval";
 export * from "./find";
 export * from "./gh";
-export * from "./hindsight-recall";
-export * from "./hindsight-reflect";
-export * from "./hindsight-retain";
 export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
@@ -102,6 +99,8 @@ export interface ToolSession {
     requireYieldTool?: boolean;
     /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
+    /** Current role-agent type/name for nested task sessions. */
+    currentAgentType?: string;
     /** Get session file */
     getSessionFile: () => string | null;
     /** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
@@ -243,7 +242,10 @@ export declare const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[];
 export declare function computeEssentialBuiltinNames(settings: Settings): string[];
 /**
  * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
- * `BUILTIN_TOOLS[name](session)` to construct a tool directly.
+ * `BUILTIN_TOOLS[name](session)` to construct a public coding-harness tool directly.
+ *
+ * Hindsight memory helpers are intentionally excluded: memory is a private backend
+ * integration, not a public gajae-code tool surface.
  */
 export declare const BUILTIN_TOOLS: Record<string, ToolFactory>;
 export declare const HIDDEN_TOOLS: Record<string, ToolFactory>;

package/dist/types/tools/path-utils.d.ts

@@ -116,6 +116,7 @@ export declare function resolveReadPath(filePath: string, cwd: string): string;
 export interface ToolScopeOptions {
     rawPaths: string[];
     cwd: string;
+    getArtifactsDir?: () => string | null;
     /** Verb used in the "Cannot {action} internal URL without a backing file: …" message. */
     internalUrlAction: string;
     /** Collect absolute paths flagged immutable by their internal-URL handler. */