@sayknow-cli/coding-agent 0.3.12 → 0.3.15

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

@@ -0,0 +1,309 @@
+/**
+ * Provenance and lifecycle primitives for tmux-resident SKC owners.
+ * This module intentionally accepts and stores only opaque identifiers and
+ * process/cgroup metadata; it never reads panes, prompts, environment, or logs.
+ */
+export declare const TMUX_OWNER_ISOLATION_SCHEMA_VERSION = 1;
+export declare const TMUX_OWNER_ISOLATION_MAX_LINE_BYTES: number;
+export declare const TMUX_OWNER_ISOLATION_MAX_DIAGNOSTIC_CHARS = 512;
+export declare function tmuxOwnerIsolationBootstrapArgv(): string[];
+export type CgroupClassification = "not_applicable" | "safe" | "unsafe_service" | "unverifiable";
+export type ServerState = "absent" | "safe" | "unsafe" | "unverifiable";
+export type PlanErrorCode = "scope_unavailable" | "server_unsafe" | "server_unverifiable" | "server_race" | "scope_bootstrap_failed";
+export type ExpectedTerminalResult = "owner_term_then_session_cleanup";
+export type TerminalSignal = "SIGTERM" | "SIGHUP" | "SIGINT" | "SIGKILL" | "EXIT" | "MANUAL" | "UNKNOWN";
+export type VerdictClassification = "expected_operator_shutdown" | "unexpected_owner_loss" | "non_operator_cleanup";
+export type TerminalObserver = "sidecar" | "raw_monitor";
+export interface CgroupInfo {
+    classification: CgroupClassification;
+    scope?: string;
+    diagnostic?: string;
+}
+/** Classify only public cgroup path metadata; malformed Linux data fails closed. */
+export declare function classifyCgroup(input: {
+    platform: NodeJS.Platform;
+    cgroupText?: string | null;
+}): CgroupInfo;
+export declare function ownerProcessStartTime(platform: NodeJS.Platform, stat: string | null): string | null;
+export interface TmuxServerProof {
+    state: ServerState;
+    pid?: number;
+    startTime?: string;
+    cgroup?: CgroupInfo;
+    sessionNames?: string[];
+}
+export interface PlanRequest {
+    schema_version: 1;
+    op: "plan";
+    platform: NodeJS.Platform;
+    session_id: string;
+    owner_generation: string;
+    cwd: string;
+    state_dir: string;
+    socket_key: string;
+    tmux_argv: string[];
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationRequest {
+    schema_version: 1;
+    op: "publish_generation";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationResult {
+    schema_version: 1;
+    ok: true;
+    code: "generation_published";
+    generation: string;
+}
+export interface AttemptCapability {
+    token: string;
+    session_name: string;
+    socket_key: string;
+    server_absent_before: boolean;
+    baseline: OwnerGenerationBaseline;
+    expires_at: string;
+}
+export interface DirectExecution {
+    mode: "direct";
+    argv: string[];
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: boolean;
+    server_pid?: number;
+    server_start_time?: string;
+}
+export interface ScopedExecution {
+    mode: "scoped";
+    argv: string[];
+    stdin_line: string;
+    expected_scope: string;
+    attempt: AttemptCapability;
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: true;
+}
+export type PlanExecution = DirectExecution | ScopedExecution;
+export interface PlanSuccess {
+    schema_version: 1;
+    ok: true;
+    code: "not_required" | "unsafe_scope_required";
+    execution: PlanExecution;
+    classification: CgroupInfo;
+    server_state: ServerState;
+}
+export interface TmuxOwnerIsolationExecutionSuccess {
+    ok: true;
+    code: "executed";
+    execution: PlanExecution;
+    server: TmuxServerProof;
+    server_key: string;
+    server_pid: number;
+    server_start_time: string;
+    server_session: string;
+    native_session_id?: string;
+}
+export interface PlanFailure {
+    schema_version: 1;
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type PlanResponse = PlanSuccess | PlanFailure;
+export interface OwnerIsolationProbe {
+    readCallerCgroup(): Promise<string | null>;
+    probeServer(socketKey: string, tmuxArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Synchronous probe boundary for managed launch paths. */
+export interface OwnerIsolationProbeSync {
+    readCallerCgroup(): string | null;
+    probeServer(socketKey: string): TmuxServerProof;
+    recordAttempt(input: {
+        stateDir: string;
+        sessionId: string;
+        generation: string;
+        attempt: AttemptCapability;
+    }): void;
+}
+export interface TmuxOwnerIsolationExecutionFailure {
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type TmuxOwnerIsolationExecutionResult = TmuxOwnerIsolationExecutionSuccess | TmuxOwnerIsolationExecutionFailure;
+/** Synchronous spawn boundary; callers pass argv and scoped stdin unchanged. */
+export interface TmuxOwnerIsolationExecutionDependencies {
+    socketKey: string;
+    spawn(argv: string[], stdinLine?: string): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string): TmuxServerProof;
+    /** Reads the published owner generation immediately around direct execution. */
+    isCurrentGeneration?(): boolean;
+    cleanupSpawned?(input: {
+        execution: DirectExecution;
+        nativeSessionId: string;
+        server: TmuxServerProof;
+    }): void;
+}
+export declare function isExactScopedBootstrapSuccessReceipt(stdout: string): boolean;
+/**
+ * Synchronous equivalent of the target-server truth table for managed callers.
+ * Attempt persistence is injected so a caller can use its existing atomic state writer.
+ */
+export declare function planTmuxOwnerIsolationSync(request: PlanRequest, probe: OwnerIsolationProbeSync): PlanResponse;
+/**
+ * Runs one planned argv exactly and re-proves the target server before callers
+ * perform profile, attach, or cleanup operations.
+ */
+export declare function executeTmuxOwnerIsolationPlanSync(plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies): TmuxOwnerIsolationExecutionResult;
+/** Implements the target-server truth table before any tmux operation. */
+export declare function planTmuxOwnerIsolation(request: PlanRequest, probe: OwnerIsolationProbe): Promise<PlanResponse>;
+export interface BootstrapRequest {
+    schema_version: 1;
+    op: "bootstrap";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    expected_scope: string;
+    tmux_argv: string[];
+    attempt: AttemptCapability;
+}
+export interface BootstrapResult {
+    schema_version: 1;
+    ok: boolean;
+    code: "bootstrapped" | "scope_bootstrap_failed";
+    native_session_id?: string;
+    server_pid?: number;
+    server_start_time?: string;
+    session_name?: string;
+    diagnostic?: string;
+}
+export interface BootstrapDependencies {
+    readSelfCgroup(): Promise<string | null>;
+    spawn(argv: string[]): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string, tmuxControlArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Self-proves the scope and synchronously invokes the exact supplied argv. */
+export declare function bootstrapTmuxOwnerIsolation(request: BootstrapRequest, deps: BootstrapDependencies): Promise<BootstrapResult>;
+export interface OwnerIntent {
+    schema_version: 1;
+    intent_id: string;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    expected_terminal: {
+        signal: "SIGTERM";
+        result: ExpectedTerminalResult;
+    };
+    dispatch_id: string;
+    created_at: string;
+    expires_at: string;
+    state: "pending";
+}
+export interface OwnerVerdict {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    result: string;
+    observer: TerminalObserver;
+    classification: VerdictClassification;
+    reason: string;
+    intent_id?: string;
+    dedupe_key: string;
+}
+export interface OwnerIncident {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    dedupe_key: string;
+    created_at: string;
+    classification: "unexpected_owner_loss";
+}
+export interface ObserveTerminalRequest {
+    schema_version: 1;
+    op: "observe_terminal";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    observer: TerminalObserver;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    exit_kind: string;
+    reason: string;
+    operator_dispatch_id?: string;
+}
+export interface LifecyclePaths {
+    root: string;
+    generation: string;
+    generationFile: string;
+    generationMarkerFile: string;
+    intentFile: string;
+    verdictFile: string;
+    verdictAliasFile: string;
+    incidentFile: string;
+    lockDatabaseFile: string;
+    journalFile: string;
+}
+export declare function lifecyclePaths(stateDir: string, sessionId: string, generation: string): LifecyclePaths;
+export declare function replaceOwnerGeneration(stateDir: string, sessionId: string, generation?: string, expectedBaseline?: OwnerGenerationBaseline): Promise<string>;
+export type OwnerGenerationBaseline = {
+    state: "absent";
+} | {
+    state: "current";
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    published_at: string;
+};
+export declare function captureOwnerGenerationBaseline(stateDir: string, sessionId: string): Promise<OwnerGenerationBaseline>;
+/** Captures the full immutable generation record for a planned owner launch. */
+export declare function captureOwnerGenerationBaselineSync(stateDir: string, sessionId: string): OwnerGenerationBaseline;
+export declare function isOwnerGenerationBaselineCurrentSync(stateDir: string, sessionId: string, baseline: OwnerGenerationBaseline): boolean;
+/** Synchronous publication for managed launch paths, serialized by a SQLite write transaction. */
+export declare function replaceOwnerGenerationSync(stateDir: string, sessionId: string, generation: string, expectedBaseline: OwnerGenerationBaseline): string;
+/** Publishes a raw-owner generation through the canonical SQLite-serialized CAS path. */
+export declare function publishOwnerGenerationSync(request: PublishGenerationRequest): PublishGenerationResult;
+export declare function createOwnerIntent(stateDir: string, input: Omit<OwnerIntent, "schema_version" | "intent_id" | "state">): Promise<OwnerIntent>;
+/** Publish exactly one terminal verdict. Existing valid verdicts always win. */
+export declare function observeOwnerTerminal(request: ObserveTerminalRequest): Promise<OwnerVerdict>;
+/** Strictly validate the persisted authorization, optionally against its terminal observation. */
+export declare function isValidOwnerIntent(intent: unknown, request?: ObserveTerminalRequest): intent is OwnerIntent;
+/** Accept only real UTC timestamps in the canonical evidence serialization. */
+export declare function isCanonicalUtcTimestamp(value: unknown): value is string;
+/** Strictly validate a complete persisted verdict, optionally against its observation. */
+export declare function isValidOwnerVerdict(verdict: unknown, request?: ObserveTerminalRequest): verdict is OwnerVerdict;
+export interface ExactOwnerCloseRequest {
+    stateDir: string;
+    sessionId: string;
+    generation: string;
+    serverKey: string;
+    pid: number;
+    startTime: string;
+    dispatchId: string;
+    createdAt: string;
+    expiresAt: string;
+}
+export interface ExactOwnerCloseDependencies {
+    readStartTime(pid: number): Promise<string | null>;
+    sendSigterm(pid: number): Promise<void>;
+    waitForVerdict(): Promise<OwnerVerdict | null>;
+    cleanupSession(): Promise<void>;
+}
+/** Authorizes only an exact, start-time-validated SIGTERM before compatibility cleanup. */
+export declare function closeExactTmuxOwner(request: ExactOwnerCloseRequest, deps: ExactOwnerCloseDependencies): Promise<OwnerVerdict>;
+export declare function parseOwnerIsolationRequest(line: string): PlanRequest | BootstrapRequest | PublishGenerationRequest | ObserveTerminalRequest | null;
+export declare function serializeOwnerIsolationResponse(response: PlanResponse | BootstrapResult | PublishGenerationResult | OwnerVerdict): string;

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

@@ -1,3 +1,4 @@
+import { type OwnerIsolationProbeSync, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
 export interface SkcTmuxSessionStatus {
     name: string;
     attached: boolean;
@@ -11,6 +12,8 @@ export interface SkcTmuxSessionStatus {
     sessionId?: string;
     sessionStateFile?: string;
     version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
     panePids: number[];
     profile?: string;
 }
@@ -22,6 +25,8 @@ export interface SkcTmuxSessionTagsForGc {
     sessionId?: string;
     sessionStateFile?: string;
     version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
     createdAt?: string;
     attached?: boolean;
     panePids?: number[];
@@ -30,6 +35,44 @@ export interface SkcTmuxSessionsForGc {
     tagged: SkcTmuxSessionStatus[];
     untagged: SkcTmuxSessionStatus[];
 }
+export interface ProvenTmuxSessionIdentity {
+    nativeSessionId: string;
+    serverPid: number;
+    serverStartTime: string;
+}
+export interface ExpectedSkcTmuxSessionIdentity {
+    nativeSessionId: string;
+    ownerGeneration: string;
+    sessionId: string;
+    sessionStateFile: string;
+    project: string;
+    createdAt: string;
+}
+export interface ExactOwnerIdentity {
+    sessionId: string;
+    stateDir: string;
+    socketKey: string;
+    generation: string;
+    pid: number;
+    startTime: string;
+}
+export interface ForceCloseOwnerDependencies {
+    resolveOwner(sessionName: string, env: NodeJS.ProcessEnv): Promise<ExactOwnerIdentity>;
+    signalTerm(pid: number): void;
+    readProcessStartTime(pid: number): Promise<string | null>;
+    cleanupSession(sessionTarget: string, env: NodeJS.ProcessEnv): void;
+    now(): Date;
+    sleep(ms: number): Promise<void>;
+    listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
+}
+export type CreateOwnerIsolationTestDependencies = {
+    probe?: Partial<OwnerIsolationProbeSync>;
+    execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
+};
+/** @internal Test-only seam; production create always uses live fail-closed probes. */
+export declare function __setCreateOwnerIsolationForTests(dependencies: CreateOwnerIsolationTestDependencies | null): void;
+/** @internal Test-only seam; production mutations always use live fail-closed proofs. */
+export declare function __setMutationServerProofForTests(dependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null): void;
 export declare function listSkcTmuxSessions(env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus[];
 /** @internal */
 export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): SkcTmuxSessionsForGc;
@@ -38,25 +81,14 @@ export declare function findSkcTmuxSessionByName(sessionName: string, env?: Node
 export declare function findSkcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus | undefined;
 export declare function statusSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
 export declare function createSkcTmuxSession(env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
+/** Proves a managed reusable name still resolves to one immutable session on one server. */
+export declare function proveSkcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv): ProvenTmuxSessionIdentity;
 /** @internal */
 export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionTagsForGc;
-export declare function removeSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
+export declare function removeSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedIdentity?: ExpectedSkcTmuxSessionIdentity): SkcTmuxSessionStatus;
 /**
- * Force-close a SKC-managed tmux session, even if a live pane is attached.
- *
- * This is the lifecycle-control counterpart to {@link removeSkcTmuxSession}: it
- * intentionally does NOT refuse live/attached panes (hard-kill is the contract),
- * but it keeps every safety check so it can only ever kill a genuinely
- * SKC-managed session:
- * - re-reads the exact tmux profile immediately before kill (never a non-SKC
- *   session, even one that collides by name);
- * - when `expectedSessionId` is given, requires the `@skc-session-id` tag match;
- * - when `expectedStateFile` is given, requires the `@skc-session-state-file`
- *   tag match.
- *
- * Returns the prior status (for audit). Throws a tagged error otherwise:
- * `skc_tmux_session_not_found`, `skc_tmux_session_not_managed`,
- * `skc_tmux_session_id_mismatch`, or `skc_tmux_session_state_file_mismatch`.
+ * Requests an exact tagged owner shutdown. Session cleanup is compatibility-only
+ * and follows a validated SIGTERM verdict; it never authorizes the close.
  */
-export declare function forceCloseSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string): SkcTmuxSessionStatus;
+export declare function forceCloseSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string, deps?: Partial<ForceCloseOwnerDependencies>): Promise<SkcTmuxSessionStatus>;
 export declare function attachSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

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

@@ -1,7 +1,7 @@
 import type { AgentDefinition, AgentSource } from "./types";
 export declare class AgentParsingError extends Error {
-    readonly source?: unknown;
-    constructor(error: Error, source?: unknown);
+    readonly source?: unknown | undefined;
+    constructor(error: Error, source?: unknown | undefined);
     toString(): string;
 }
 /**

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

@@ -11,6 +11,7 @@ import { Settings } from "../config/settings";
 import { type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
+import { AgentRegistry } from "../registry/agent-registry";
 import type { ForkContextSeed } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
@@ -61,6 +62,8 @@ export interface ExecutorOptions {
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;
     settings?: Settings;
+    /** Parent session's registry; shared by child sessions for IRC routing and roster visibility. */
+    agentRegistry?: AgentRegistry;
     /**
      * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
      * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the

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

@@ -1,4 +1,4 @@
-import type { SingleResult, TaskToolDetails } from "./types";
+import { type SingleResult, type TaskToolDetails } from "./types";
 export interface TaskRoi {
     tokens: number;
     contextTokens?: number;
@@ -31,6 +31,7 @@ export interface TaskResultReceipt {
     modelSubstitutionWarning?: SingleResult["modelSubstitutionWarning"];
     usage?: SingleResult["usage"];
     cost?: number;
+    usageCostBreakdownComplete?: true;
     branchName?: string;
     retryFailure?: {
         attempt: number;
@@ -77,6 +78,7 @@ export interface RawTaskToolDetails {
     results: SingleResult[];
     totalDurationMs: number;
     usage?: TaskToolDetails["usage"];
+    usageCostBreakdownComplete?: TaskToolDetails["usageCostBreakdownComplete"];
     async?: TaskToolDetails["async"];
     forkContextClonedTokens?: number;
     roiSummary?: TaskToolDetails["roiSummary"];

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

@@ -46,11 +46,11 @@ export declare const taskItemSchema: z.ZodObject<{
     description: z.ZodString;
     assignment: z.ZodString;
     inheritContext: z.ZodOptional<z.ZodEnum<{
-        bounded: "bounded";
-        full: "full";
-        "last-turn": "last-turn";
         none: "none";
         receipt: "receipt";
+        "last-turn": "last-turn";
+        bounded: "bounded";
+        full: "full";
     }>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
@@ -61,11 +61,11 @@ export declare const taskSchema: z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -83,11 +83,11 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -105,11 +105,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -126,11 +126,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -147,11 +147,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -168,11 +168,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -189,11 +189,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -210,11 +210,11 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         description: z.ZodString;
         assignment: z.ZodString;
         inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
             none: "none";
             receipt: "receipt";
+            "last-turn": "last-turn";
+            bounded: "bounded";
+            full: "full";
         }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
@@ -387,6 +387,8 @@ export interface SingleResult {
     paused?: boolean;
     /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
     usage?: Usage;
+    /** True only when every usage-contributing assistant supplied a complete, non-negative raw cost breakdown. */
+    usageCostBreakdownComplete?: true;
     /** Output path for the task result */
     outputPath?: string;
     /** Patch path for isolated worktree output */
@@ -430,6 +432,10 @@ export interface SingleResult {
         reasons: string[];
     };
 }
+/** True only for complete, factual five-bucket cost accounting. */
+export declare function hasCompleteUsageCostBreakdown(usage: unknown): boolean;
+/** True only when every usage-contributing result has explicit, complete cost provenance. */
+export declare function hasCompleteAggregateUsageCostBreakdown(results: readonly Pick<SingleResult, "usage" | "usageCostBreakdownComplete">[]): boolean;
 /** Tool details for TUI rendering */
 export interface TaskToolDetails {
     projectAgentsDir: string | null;
@@ -437,6 +443,8 @@ export interface TaskToolDetails {
     totalDurationMs: number;
     /** Aggregated usage across all subagents. */
     usage?: Usage;
+    /** True only when every usage-contributing subagent supplied a complete raw cost breakdown. */
+    usageCostBreakdownComplete?: true;
     /** Aggregate cloned tokens copied into fork-context seeds across subagents. */
     forkContextClonedTokens?: number;
     roiSummary?: {

package/dist/types/tools/ask-answer-registry.d.ts

@@ -6,8 +6,13 @@
  * through the extension/runner/controller wiring. A session has at most one
  * source; registering returns a disposer.
  */
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
 import type { AskAnswerSource } from "./index";
 /** Register `source` for `sessionId`. Returns a disposer that clears it. */
 export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
 /** The answer source for `sessionId`, if one is registered. */
 export declare function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined;
+/** Publish a session's current workflow-gate emitter after mode initialization. */
+export declare function notifyWorkflowGateEmitterChanged(sessionId: string, emitter: WorkflowGateEmitter | undefined): void;
+/** Observe workflow-gate emitter installation even when it occurs after session_start. */
+export declare function registerWorkflowGateEmitterListener(sessionId: string, listener: (emitter: WorkflowGateEmitter | undefined) => void): () => void;

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

@@ -86,7 +86,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         label: string;
         commandCwd: string;
     }>;
-    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {
     command?: string;

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -60,6 +60,12 @@ export interface RunInTabOptions {
 }
 export interface ReleaseTabOptions {
     kill?: boolean;
+    /**
+     * Absolute end-to-end deadline (`Date.now()`-based, ms) for the whole teardown chain.
+     * Shared across a `releaseAllTabs` loop so close/close-all honors ONE aggregate budget.
+     * Omitted (the GC/session-teardown callers) keeps the original unbounded behavior.
+     */
+    deadlineAt?: number;
 }
 export declare function getTab(name: string): TabSession | undefined;
 /** Read-only, GC-facing projection of a live tab. Never exposes the mutable `tabs` map. */