@gajae-code/coding-agent 0.12.0 → 0.12.2

package/dist/types/sdk/session.d.ts

@@ -12,6 +12,7 @@ import type { CustomCommandsLoadResult } from "../extensibility/custom-commands"
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "../extensibility/extensions";
 import { type ConstrainedPluginHook } from "../extensibility/gjc-plugins/constrained-hooks";
+import { type GjcRuntimeSnapshotProvider } from "../extensibility/gjc-plugins/runtime-quarantine";
 import { type Skill, type SkillWarning } from "../extensibility/skills";
 import type { FileSlashCommand } from "../extensibility/slash-commands";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -207,6 +208,11 @@ export interface CreateAgentSessionResult {
     lspServers?: LspStartupServerInfo[];
     /** Shared event bus for tool/extension communication */
     eventBus: EventBus;
+    /**
+     * Read-only view of GJC bundle runtime evidence for the activation generation
+     * this session published. Undefined when no GJC bundles participated.
+     */
+    gjcRuntimeSnapshot?: GjcRuntimeSnapshotProvider;
 }
 export type { PromptTemplate } from "../config/prompt-templates";
 export { Settings, type SkillsSettings } from "../config/settings";

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

@@ -12,7 +12,7 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { type Agent, type AgentContext, type AgentEvent, type AgentLoopConfig, type AgentMessage, type AgentState, type AgentTool, type MidRunMaintenanceOutcome, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
+import { type Agent, type AgentContext, type AgentEvent, type AgentLoopConfig, type AgentMessage, type AgentState, type AgentTool, type MidRunMaintenanceOutcome, type RunSettlementProof, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, Usage, UsageReport } from "@gajae-code/ai";
 import { type BtwTextExchange } from "./btw-contract";
@@ -75,16 +75,18 @@ import { type PromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
 import { type PythonResult } from "../eval/py/executor";
-import { type BashResult } from "../exec/bash-executor";
+import { type BashArtifactSaveResult, type BashResult } from "../exec/bash-executor";
 import type { TtsrManager } from "../export/ttsr";
 import type { LoadedCustomCommand } from "../extensibility/custom-commands";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { ExtensionRunner } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage, ExtensionTranscriptEntry } from "../extensibility/extensions/types";
+import type { GjcRuntimeSnapshotProvider } from "../extensibility/gjc-plugins/runtime-quarantine";
 import type { SessionSwitchEvent } from "../extensibility/shared-events";
 import { type Skill, type SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { type MemoryGuardClaimsLease } from "../gjc-runtime/memory-guard-owner-claims";
+import { GjcTeamWorkerHeartbeatReporter } from "../gjc-runtime/team-worker-heartbeat";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -208,6 +210,11 @@ export interface AgentSessionConfig {
     workerIntegrationRequest?: (signal: AbortSignal) => Promise<void>;
     /** Bound terminal worker-integration settlement for embedded hosts and deterministic lifecycle tests. */
     workerIntegrationTimeoutMs?: number;
+    /**
+     * Override the runtime-owned `gjc team` worker heartbeat reporter. Defaults to a
+     * reporter derived from the team worker environment, or none outside a worker pane.
+     */
+    teamWorkerHeartbeatReporter?: GjcTeamWorkerHeartbeatReporter;
     /** Loaded skills (already discovered by SDK) */
     skills?: Skill[];
     /** Skill loading warnings (already captured by SDK) */
@@ -466,6 +473,11 @@ interface EphemeralTurnResult {
     replyText: string;
     assistantMessage: AssistantMessage;
 }
+export interface AgentBashArtifactStore {
+    saveArtifact(content: string, toolType: string): Promise<string | undefined>;
+    getArtifactPath(id: string): Promise<string | null>;
+}
+export declare function saveAgentBashOriginalArtifact(store: AgentBashArtifactStore, originalText: string): Promise<BashArtifactSaveResult>;
 type IrcRosterClaim = {
     token: symbol;
     signature: string;
@@ -621,6 +633,7 @@ export declare class AgentSession {
      *  separately inside `sendCustomMessage`. */
     enqueueCustomMessageDisplay(text: string, mode: "steer" | "followUp"): string;
     getAgentId(): string | undefined;
+    registerToolSessionCleanup(cleanup: () => Promise<void> | void): () => void;
     getAsyncJobSnapshot(options?: {
         recentLimit?: number;
     }): AsyncJobSnapshot | null;
@@ -786,6 +799,8 @@ export declare class AgentSession {
      * to avoid racing against the delivery turn.
      */
     get hasPostPromptWork(): boolean;
+    /** Stable resource ownership identifier for the active prompt run. */
+    get activePromptHandle(): string | undefined;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
     get transcriptPromptGeneration(): number;
@@ -980,6 +995,12 @@ export declare class AgentSession {
         cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
         silent?: boolean;
     }): Promise<void>;
+    /**
+     * Abort a specific active prompt and prove whether its tracked resources settled.
+     */
+    abortPromptAndWait(handle: string, options: {
+        graceMs: number;
+    }): Promise<RunSettlementProof>;
     /** Atomically interrupt the active run and make text the next prompt. */
     cancelAndSubmit(text: string, options?: {
         queuedEntryId?: string;
@@ -1048,6 +1069,13 @@ export declare class AgentSession {
      * instead of promoting a transient runtime model to the resume default.
      */
     getSessionDefaultModelSelector(): string | undefined;
+    /**
+     * Resolve the model that `modelRoles.default` currently points to, independent
+     * of whatever model this session's log last recorded. Used by the TUI resume
+     * flow's `session.resumeModelBehavior: "ask"` prompt to offer the currently
+     * configured default as an alternative to the session's saved model.
+     */
+    resolveConfiguredDefaultModel(): Model | undefined;
     /**
      * Re-assert the session resume default ("provider/id") in the session log
      * WITHOUT touching the live runtime model. Appends a `model_change` with
@@ -1157,6 +1185,15 @@ export declare class AgentSession {
      * Get available thinking levels for current model.
      */
     getAvailableThinkingLevels(): ReadonlyArray<Effort>;
+    /**
+     * Runtime evidence published for the current GJC bundle activation
+     * generation, set once by `createAgentSession` after every producer has run.
+     * Undefined until that publication happens, so consumers report runtime
+     * status as unavailable rather than falsely clear.
+     */
+    gjcRuntimeSnapshot?: GjcRuntimeSnapshotProvider;
+    /** Activation generation a published snapshot must match to be merged. */
+    gjcActivationGeneration?: number;
     /**
      * Set steering mode.
      * Saves to settings.
@@ -1350,6 +1387,7 @@ export declare class AgentSession {
      */
     switchSession(sessionPath: string, options?: {
         transition?: SessionSwitchEvent["transition"];
+        onTransitionMutationStarted?: () => void;
     }): Promise<boolean>;
     /**
      * Create a branch from a specific entry.

package/dist/types/session/artifacts.d.ts

@@ -45,6 +45,14 @@ export declare class ArtifactManager {
     replaceNamedBytes(filename: string, bytes: Uint8Array): Promise<void>;
     publishManagedOutputGeneration(selectorFilename: string, outputFilenamePrefix: string, outputBytes: Uint8Array, metadataBytes: Uint8Array): Promise<void>;
     publishNamedNoReplace(filename: string, bytes: Uint8Array): Promise<void>;
+    /**
+     * Best-effort removal of a previously published named artifact. Used to roll
+     * back staged publications when a transactional operation (e.g. gated
+     * maintenance pruning) is rejected after publication succeeded. Returns false
+     * when the artifact could not be removed so callers can log the failure
+     * instead of silently treating the rollback as complete.
+     */
+    removeNamedBestEffort(filename: string): Promise<boolean>;
     /**
      * Atomically allocate next artifact ID.
      * IDs are sequential within the session.

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

@@ -1,3 +1,9 @@
+declare const TAKE_BLOB_BUFFER_OWNERSHIP: unique symbol;
+/** Limits for a single best-effort resident-cache garbage-collection pass. */
+export interface ResidentCacheGcSweepOptions {
+    readonly maxDirectories?: number;
+    readonly maxDurationMs?: number;
+}
 export interface BlobPutResult {
     hash: string;
     path: string;
@@ -11,6 +17,28 @@ export declare class BlobCorruptError extends Error {
     readonly path: string;
     constructor(hash: string, path: string);
 }
+/**
+ * A resident-cache path or blob failed the owner-only verification contract.
+ * SessionManager catches this error to demote the entire resident store to
+ * memory before retrying the triggering write.
+ */
+export declare class ResidentCacheTrustError extends Error {
+    readonly reason: string;
+    readonly path: string;
+    constructor(reason: string, path: string, options?: ErrorOptions);
+}
+/**
+ * Best-effort cleanup of abandoned resident-cache instances. The root is
+ * re-verified before scanning, work is bounded, and all failures fail closed.
+ */
+export declare function sweepResidentCacheRoot(root: string, options?: ResidentCacheGcSweepOptions): Promise<void>;
+/**
+ * Create a private resident-cache instance directory beneath a trusted profile
+ * root. The cache-owned root and nonce instance are both verified owner-only
+ * directories; callers must use {@link EphemeralBlobStore.adoptVerifiedDir}
+ * rather than the destructive EphemeralBlobStore constructor.
+ */
+export declare function openVerifiedResidentCacheInstanceDir(root: string): string;
 /**
  * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
  *
@@ -31,7 +59,13 @@ export declare class BlobStore {
      * cannot afford the microtask hops of the async version (e.g. OOM-safe session writes).
      * Returns once the bytes are in the kernel page cache.
      */
-    putSync(data: Buffer): BlobPutResult;
+    putSync(data: Buffer, _ownership?: typeof TAKE_BLOB_BUFFER_OWNERSHIP): BlobPutResult;
+    /**
+     * Store a buffer that the caller will not mutate after this call returns.
+     * Resident-cache implementations may retain that private buffer without an
+     * additional defensive copy.
+     */
+    putOwnedSync(data: Buffer): BlobPutResult;
     /**
      * Durably install binary data as an immutable content-addressed blob.
      *
@@ -51,19 +85,37 @@ export declare class BlobStore {
     /** Check if a blob exists. */
     has(hash: string): Promise<boolean>;
 }
+interface EphemeralBlobStoreOptions {
+    readonly adoptVerifiedDir?: boolean;
+}
+/** Resident-cache directories still tracked by this process. Test seam. */
+export declare function trackedResidentCacheDirsForTest(): string[];
 export declare class EphemeralBlobStore extends BlobStore {
     #private;
-    constructor(dir: string);
-    putSync(data: Buffer): BlobPutResult;
+    constructor(dir: string, options?: EphemeralBlobStoreOptions);
+    /**
+     * Adopt a directory returned by {@link openVerifiedResidentCacheInstanceDir}
+     * without the ordinary constructor's destructive remove-and-recreate path.
+     */
+    static adoptVerifiedDir(dir: string): EphemeralBlobStore;
+    put(data: Buffer): Promise<BlobPutResult>;
+    putSync(data: Buffer, ownership?: typeof TAKE_BLOB_BUFFER_OWNERSHIP): BlobPutResult;
     putImmutableSync(data: Buffer): CheckedBlobPutResult;
+    get(hash: string): Promise<Buffer | null>;
     getSync(hash: string): Buffer | null;
+    /** Return a trusted in-memory copy without reopening an invalidated cache path. */
+    getBufferedSync(hash: string): Buffer | null;
     getCheckedSync(hash: string): Buffer | null;
     clear(): void;
     dispose(): void;
 }
+export interface MemoryBlobStoreOptions {
+    /** A canonical store owns every reference in its session's resident entries. */
+    readonly ownership?: "cache" | "canonical";
+}
 export declare class MemoryBlobStore extends BlobStore {
     #private;
-    constructor();
+    constructor(options?: MemoryBlobStoreOptions);
     put(data: Buffer): Promise<BlobPutResult>;
     putSync(data: Buffer): BlobPutResult;
     putImmutableSync(data: Buffer): CheckedBlobPutResult;
@@ -158,3 +210,4 @@ export declare function resolveResidentImageDataSync(blobStore: BlobStore, data:
     sessionId?: string;
     sessionFile?: string;
 }): string;
+export {};

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -7,6 +7,7 @@ export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
 export declare const MANAGED_ARTIFACT_COPY_BATCH_SIZE = 256;
 export declare class ManagedPublishError extends Error {
     readonly classification: "destination_conflict" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "identity_mismatch" | "io_error" | "durability_failed";
+    readonly code: ManagedPublishError["classification"];
     readonly diagnostic: string;
     constructor(classification: ManagedPublishError["classification"], outcome: NativePublishOutcome);
 }
@@ -20,6 +21,12 @@ export interface ManagedStorageLock {
     assertOwned(): void;
     release(): Promise<void>;
 }
+export interface ManagedStorageLockSync {
+    path: string;
+    attemptId: string;
+    assertOwned(): void;
+    release(): void;
+}
 export interface ManagedFileSnapshot {
     bytes: Buffer;
     identity: {
@@ -31,6 +38,13 @@ export interface ManagedFileSnapshot {
         sha256: string;
     };
 }
+export declare const MANAGED_SESSION_SECURITY_CODES: readonly ["acl_denied", "acl_io_error", "acl_present", "acl_malformed", "acl_unknown", "acl_unavailable", "acl_apply_failed", "acl_verify_failed", "not_found", "not_directory", "network_unsupported", "reparse_point", "identity_unavailable", "identity_mismatch", "owner_mismatch", "mode_mismatch", "io_error"];
+export type ManagedSessionSecurityCode = (typeof MANAGED_SESSION_SECURITY_CODES)[number];
+export declare class ManagedSessionSecurityError extends Error {
+    readonly code: ManagedSessionSecurityCode;
+    constructor(code: ManagedSessionSecurityCode);
+}
+export declare function managedSessionSecurityCode(error: unknown): ManagedSessionSecurityCode | undefined;
 export declare function validateNativeSecurityResult(value: unknown, operation: "apply" | "verify", kind: "directory" | "file"): NativeOwnerOnlySecurityResult;
 /** Captured configured-root authority for managed paths only. */
 export interface ManagedDirectoryRoot {
@@ -51,19 +65,26 @@ export declare function retainManagedDirectoryAuthority(root: ManagedDirectoryRo
     ino: bigint;
 }): RecoveryFsRoot | undefined;
 export declare function assertManagedDirectoryRoot(root: ManagedDirectoryRoot): void;
+export declare function managedSecurityFailureClassification(error: unknown): string | undefined;
 /** Internal retained-root capability for one managed descendant subtree. */
 export declare class ManagedSessionDescendantStore {
     #private;
     constructor(root: ManagedDirectoryRoot, baseDir: string, retained?: {
         authority: RecoveryFsRoot;
         authorityBaseDir: string;
-    }, policy?: ManagedSessionSecurityPolicy);
+    }, policy?: ManagedSessionSecurityPolicy, profileAgentDir?: string);
     get dir(): string;
     get rootAuthority(): ManagedDirectoryRoot;
     get subtreeRootAuthority(): ManagedDirectoryRoot;
     get securityPolicy(): ManagedSessionSecurityPolicy;
+    get profileAgentDir(): string;
     deriveSubtree(relativePath: string): ManagedSessionDescendantStore;
     retainAuthority(): RecoveryFsRoot | undefined;
+    /**
+     * Release an authority this store opened itself. Retained authorities are owned by
+     * the security context that supplied them and are never closed here. Idempotent.
+     */
+    close(): void;
     assertBound(): void;
     verifyRootSecurity(): void;
     ensureDirectory(relativePath?: string): ManagedDirectoryRoot;
@@ -98,13 +119,18 @@ export declare function captureManagedFileNoFollow(pathname: string): ManagedFil
 /** Atomically publishes bytes without replacing an existing destination. */
 export declare function publishManagedFileNoReplace(destination: string, bytes: Uint8Array, assertOwned?: () => void, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 export declare function publishManagedFileNoReplaceSync(destination: string, bytes: Uint8Array, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): void;
-/** Replace one managed regular file while retaining the secured staging fd through publication. */
-export declare function replaceManagedFileSync(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): void;
-export declare function replaceManagedFile(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
+/**
+ * Atomically replace a managed file only when the destination is still the
+ * exact captured object. Unlike `replaceManagedFileSync`, this never performs
+ * an unconditional pathname rename.
+ */
+export declare function replaceManagedFileExactSync(destination: string, bytes: Uint8Array, expected: Pick<ManagedFileSnapshot, "identity">, root: ManagedDirectoryRoot): void;
 /** Copy the exact bytes captured from one no-follow source descriptor. */
 export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 /** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
 export declare function acquireManagedLock(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<ManagedStorageLock>;
+/** Acquire a synchronous lease lock for a short cross-process critical section. */
+export declare function acquireManagedLockSync(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): ManagedStorageLockSync;
 export interface ManagedArtifactTreeLimits {
     maxFiles?: number;
     maxTotalBytes?: number;

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

@@ -72,11 +72,16 @@ export interface SessionManagerObservabilityStats {
     coldSpillReadCount: number;
     residentTextReadCount: number;
     residentImageReadCount: number;
+    residentCacheAdoptFallbackCount: number;
+    residentCacheTrustRejectCount: number;
+    residentCacheWin32FallbackCount: number;
+    residentCacheDegradedReason?: string;
     publicMaterializerCallCount: number;
     getEntryMaterializerCallCount: number;
     getBranchMaterializerCallCount: number;
     getEntriesMaterializerCallCount: number;
     materializedEntriesCachePopulateCount: number;
+    materializedCacheDemotedCount: number;
     pathOnlyContextBuildCount: number;
 }
 export interface SessionMessageEntry extends SessionEntryBase {
@@ -506,12 +511,17 @@ export type SessionDestination = {
     readonly directory: string;
 };
 export type SessionDestinationInput = string | SessionDestination | undefined;
-interface ForkArtifactPublication {
+type ForkArtifactPublication = {
+    readonly kind: "managed";
     readonly snapshot: native.NativeDirectoryTreeSnapshot;
     readonly store: ManagedSessionDescendantStore;
     readonly cleanupStore: ManagedSessionDescendantStore;
     readonly cleanupRelativePath: string;
-}
+} | {
+    readonly kind: "explicit";
+    readonly artifactsDir: string;
+    readonly snapshot: native.NativeDirectoryTreeSnapshot;
+};
 /** Exported for testing */
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
 declare class RecentSessionInfo {
@@ -596,6 +606,13 @@ interface SessionManagerStateSnapshot {
     fileEntries: FileEntry[];
     materializedFileEntries: FileEntry[];
 }
+/** Benchmark-derived cap for strong materialized session snapshots. */
+export declare const MATERIALIZED_CACHE_MAX_BYTES: number;
+/** Test-only cache retention and transition seams; these are intentionally not user settings. */
+export declare const SessionManagerTestHooks: {
+    materializedCacheMaxBytesOverride?: number;
+    beforeResidentTransitionIndexBuild?: () => void;
+};
 export declare class SessionManager {
     #private;
     private cwd;
@@ -614,7 +631,7 @@ export declare class SessionManager {
     putBlob(data: Buffer): Promise<BlobPutResult>;
     captureState(): SessionManagerStateSnapshot;
     restoreState(snapshot: SessionManagerStateSnapshot): void;
-    /** Switch to a different session file (used for resume and branching) */
+    /** Switch to a different session file (used for resume and branching). */
     setSessionFile(sessionFile: string): Promise<void>;
     /** Start a new session. Closes any existing writer first. */
     newSession(options?: NewSessionOptions): Promise<string | undefined>;
@@ -652,9 +669,9 @@ export declare class SessionManager {
      * managed logical authorization. This is only for discarding an UNCOMMITTED
      * successor that a transaction (e.g. handoff) created via `newSession()` but
      * never durably authorized — such a session has no managed candidate listing
-     * yet, so `dropSession` would refuse it and leak its resident-cache/artifact
-     * root. Bounded to this manager's configured session root and refuses to touch
-     * the active session; tolerates missing files.
+     * yet, so `dropSession` would refuse it and leak its artifact root. Bounded to
+     * this manager's configured session root and refuses to touch the active session;
+     * tolerates missing files.
      */
     discardUncommittedSession(sessionPath: string): Promise<void>;
     /**

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

@@ -61,6 +61,8 @@ export interface SessionStorageWriterOpenOptions {
 export interface ManagedSessionSecurityContext {
     readonly kind: "managed";
     readonly agentDir: string;
+    /** Logical profile root for process-local caches; distinct from managed pathname authority. */
+    readonly profileAgentDir: string;
     readonly sessionsRoot: string;
     readonly sessionDir: string;
     readonly rootAuthority: ManagedDirectoryRoot;
@@ -69,6 +71,8 @@ export interface ManagedSessionSecurityContext {
 /** @internal Create the only accepted managed writer authority object. */
 export declare function createManagedSessionSecurityContext(input: {
     agentDir: string;
+    /** Optional for compatibility with existing authority-only callers. */
+    profileAgentDir?: string;
     sessionsRoot: string;
     sessionDir: string;
     rootAuthority: ManagedDirectoryRoot;

package/dist/types/session/streaming-output.d.ts

@@ -3,6 +3,29 @@ export declare const DEFAULT_MAX_LINES = 3000;
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_COLUMN = 1024;
 export declare const DEFAULT_ARTIFACT_MAX_BYTES: number;
+/**
+ * Terminal publisher used when managed artifact storage exposes an ID but no
+ * writable pathname. The sink supplies raw content retained up to its artifact
+ * hard cap; `omittedBytes` is the source-byte count already omitted by that cap.
+ * A successful publisher may report additional omitted bytes (for example, a
+ * downstream storage cap); those counts are added to the sink summary. Failed
+ * and unavailable results are surfaced through the bounded artifact diagnostic
+ * without exposing an unresolvable artifact URL.
+ */
+export type TerminalArtifactPublishResult = {
+    status: "published";
+    artifactId: string;
+    omittedBytes?: number;
+} | {
+    status: "unavailable";
+} | {
+    status: "failed";
+    diagnostic: string;
+};
+export type TerminalArtifactPublisher = (content: string, info: {
+    totalBytes: number;
+    omittedBytes: number;
+}) => Promise<TerminalArtifactPublishResult>;
 export interface OutputSummary {
     output: string;
     truncated: boolean;
@@ -18,10 +41,12 @@ export interface OutputSummary {
     columnDroppedBytes?: number;
     /** Number of distinct lines that hit the per-line column cap. */
     columnTruncatedLines?: number;
-    /** Artifact ID for internal URL access (artifact://<id>) when truncated */
+    /** Artifact ID for internal URL access (artifact://<id>) when output was persisted. */
     artifactId?: string;
     /** Bytes omitted from artifact storage after the artifact hard cap was reached. */
     artifactTruncatedBytes?: number;
+    /** Bounded diagnostic when artifact writer or terminal publisher creation, write, finalization, or publication failed. */
+    artifactFailureDiagnostic?: string;
 }
 export interface OutputSinkOptions {
     /**
@@ -30,6 +55,12 @@ export interface OutputSinkOptions {
      */
     artifactPath?: string;
     artifactId?: string;
+    /**
+     * Optional terminal publisher for managed artifact stores that do not expose a
+     * writable path. It is invoked only when visible spill/truncation requires an
+     * artifact, and receives raw content bounded by `artifactMaxBytes`.
+     */
+    artifactPublisher?: TerminalArtifactPublisher;
     /** Tail buffer budget (bytes). Default DEFAULT_MAX_BYTES. */
     spillThreshold?: number;
     /**
@@ -241,12 +272,10 @@ export declare class OutputSink {
      * minimizer rewrites the captured output after the raw bytes have already
      * been streamed.
      *
-     * After this call the buffer is authoritative: streaming counters realign
-     * to the replacement, the retained head window is cleared, and head
-     * retention is disabled so subsequent `push()` calls append directly to the
-     * tail buffer instead of repopulating the (now meaningless) head window
-     * — which would otherwise reorder content and trip the middle-elision
-     * branch in `dump()` against stale totals.
+     * After this call the replacement is authoritative: counters reflect its full
+     * size, the configured head+tail byte windows are retained with UTF-8-safe
+     * boundaries, and future head accumulation is disabled so later `push()` calls
+     * append directly to the tail without reordering the replacement.
      */
     replace(text: string): void;
     dump(notice?: string): Promise<OutputSummary>;

package/dist/types/setup/credential-import.d.ts

@@ -48,6 +48,18 @@ export interface DiscoveryOptions {
     env?: Record<string, string | undefined>;
     /** Override the platform (defaults to `process.platform`). */
     platform?: NodeJS.Platform;
+    /**
+     * Claude Code config directory holding `.credentials.json`.
+     *
+     * Defaults to the trusted `CLAUDE_CONFIG_DIR` value, else `<homeDir>/.claude`.
+     */
+    claudeConfigDir?: string;
+    /**
+     * Codex CLI home directory holding `auth.json`.
+     *
+     * Defaults to the trusted `CODEX_HOME` value, else `<homeDir>/.codex`.
+     */
+    codexHome?: string;
     /**
      * Reader for the macOS Keychain `Claude Code-credentials` entry. Defaults to
      * shelling out to `security`; injected in tests. Returns the raw JSON string,

package/dist/types/skill-state/active-state.d.ts

@@ -88,6 +88,16 @@ export interface SyncSkillActiveStateOptions {
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;
+/**
+ * Continuation inertness for compaction auto-continue, derived from each
+ * workflow's manifest contract: manifest-terminal and explicitly inert phases
+ * are inert; unknown skills or phases unknown to the skill's manifest are
+ * conservatively inert so a synthetic continuation never wakes an unrecognized
+ * workflow. Generic Ultragoal `blocked` remains continuation-active because its
+ * blocker may be autonomously resolvable; verified human pauses are represented
+ * by the inline goal's `paused` status instead.
+ */
+export declare function isWorkflowContinuationInert(skill: string, phase: string): boolean;
 export declare function listActiveSkills(raw: unknown): SkillActiveEntry[];
 export declare function normalizeSkillActiveState(raw: unknown): SkillActiveState | null;
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
@@ -95,6 +105,8 @@ export declare function collapsePlanningPipeline(entries: readonly SkillActiveEn
 export type VisibleSkillActiveStateCacheTier = "security" | "hud";
 export interface ReadVisibleSkillActiveStateOptions {
     tier?: VisibleSkillActiveStateCacheTier;
+    /** Bypass all signature/TTL caches for authorization decisions. */
+    bypassCache?: boolean;
 }
 interface ActiveStateStatSignature {
     path: string;

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

@@ -26,6 +26,12 @@ interface RalplanHudState extends WorkflowGateHudState {
     verdict?: string;
     latestSummary?: string;
     pendingApproval?: boolean;
+    autoHandoff?: {
+        configuredTarget: string;
+        effectiveTarget: string;
+        degradationReason: string | null;
+    };
+    planningStuck?: boolean;
     updatedAt?: string;
 }
 interface UltragoalLikeGoal {

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

@@ -19,7 +19,7 @@ import { SessionManager } from "../session/session-manager";
 import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
-import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+import { type AgentDefinition, type AgentProgress, type SingleResult } from "./types";
 import { type ExecutorExecutionMode } from "./ultragoal-redteam-activation";
 export declare function trimForkContextSeedForModel(seed: ForkContextSeed, model: Model | undefined): ForkContextSeed;
 /** Options for subagent execution */
@@ -79,6 +79,8 @@ export interface ExecutorOptions {
      * subagents, and a main-model fast-mode auto-disable does not clobber it.
      */
     inheritedServiceTier?: ServiceTier;
+    /** Resolve whether the effective subagent tier grants fast mode for the selected provider. */
+    isFastForSubagentProvider?: (provider?: string) => boolean;
     /** Override local:// protocol options so subagent shares parent's local:// root */
     localProtocolOptions?: LocalProtocolOptions;
     /**
@@ -122,7 +124,6 @@ interface FinalizeSubprocessOutputArgs {
     doneAborted: boolean;
     signalAborted: boolean;
     yieldItems?: YieldItem[];
-    reportFindings?: ReviewFinding[];
     outputSchema: unknown;
 }
 interface FinalizeSubprocessOutputResult {

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

@@ -1,10 +1,12 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai";
 import type { ToolSession } from "..";
+import { type SubagentRunOutcome } from "../async";
 import type { Theme } from "../modes/theme/theme";
-import { type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import { type SingleResult, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
 import { renderResult, renderCall as renderTaskCall } from "./render";
+export declare function subagentRunOutcomeFromSingleResult(finalText: string, singleResult: Pick<SingleResult, "aborted" | "exitCode" | "paused" | "setupFailure"> | undefined): string | SubagentRunOutcome;
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
@@ -30,6 +32,10 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly renderResult: typeof renderResult;
+    /**
+     * Session-lifetime durable artifact state is shared atomically by every
+     * TaskTool created for the same parent ToolSession.
+     */
     get parameters(): TaskToolSchemaInstance;
     renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme): import("@gajae-code/tui").Component;
     /** Dynamic description that reflects current disabled-agent settings */

package/dist/types/task/output-manager.d.ts

@@ -10,6 +10,7 @@ export declare class AgentOutputManager {
     #private;
     constructor(getArtifactsDir: () => string | null, options?: {
         parentPrefix?: string;
+        getAuthorizedArtifactsDirs?: () => readonly string[];
     });
     /**
      * Allocate a unique ID with numeric prefix.

package/dist/types/task/provider-retry-status.d.ts

@@ -1,6 +1,14 @@
 import type { AgentProgress, TaskToolDetails } from "./types";
 export type ProviderRetryKind = NonNullable<AgentProgress["retryState"]>["kind"];
 export declare function classifyProviderRetry(errorMessage: string): ProviderRetryKind;
+/**
+ * Prefer typed transport facts when present; fall back to message regex for
+ * message-only callers that never received `transportFailure.providerCode`.
+ */
+export declare function classifyProviderRetryFromTransport(facts: {
+    providerCode?: string;
+    errorMessage?: string;
+}): ProviderRetryKind;
 export declare function providerNameFromModel(model: string | undefined): string | undefined;
 export declare function providerRetryPhaseLabel(kind: ProviderRetryKind): string;
 export declare function providerProgressAgeLabel(retryState: NonNullable<AgentProgress["retryState"]>, nowMs: number): string;