@gajae-code/coding-agent 0.11.11 → 0.12.1

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;
     /**
@@ -83,7 +114,10 @@ export interface TruncationResult {
     elidedLines?: number;
     lastLinePartial?: boolean;
     firstLineExceedsLimit?: boolean;
+    lastLineExceedsLimit?: boolean;
 }
+/** Direction vocabulary used by callers that select which end of content to retain. */
+export type TruncationDirection = "head" | "last" | "both";
 export interface TruncationOptions {
     /** Maximum number of lines (default: 3000) */
     maxLines?: number;
@@ -99,6 +133,8 @@ export interface TruncationOptions {
      * window receives `maxLines - maxHeadLines`. Default `floor(maxLines/2)`.
      */
     maxHeadLines?: number;
+    /** Direction to dispatch through truncateContent (head, last, or both). */
+    direction?: TruncationDirection;
 }
 /** Result from byte-level truncation helpers. */
 export interface ByteTruncationResult {
@@ -155,14 +191,64 @@ export declare function truncateTail(content: string, options?: TruncationOption
  */
 export declare function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string;
 /**
- * Truncate content keeping a head window and a tail window, eliding the middle.
+ * A retained source segment returned by {@link truncateMiddleWindows}.
+ * Line coordinates are 1-indexed and inclusive.
+ */
+export type ReadSegment = {
+    kind: "lines";
+    content: string;
+    lines: number;
+    bytes: number;
+    origin: {
+        startLine: number;
+        endLine: number;
+    };
+    lastLinePartial: false;
+} | {
+    kind: "partial-line";
+    content: string;
+    lines: 1;
+    bytes: number;
+    origin: {
+        startLine: number;
+        endLine: number;
+    };
+    sourceLineBytes: number;
+    lastLinePartial: true;
+};
+/** The actual windows retained by middle truncation. */
+export interface ReadWindow {
+    kind: "full" | "head-only" | "tail-only" | "middle";
+    head?: ReadSegment;
+    tail?: ReadSegment;
+    overlap: "disjoint" | "adjacent" | "overlapping";
+    elidedLines: number;
+    elidedBytes: number;
+    totalLines: number;
+    totalBytes: number;
+    /** @deprecated Non-enumerable compatibility reason for older consumers. */
+    truncatedBy?: "lines" | "bytes" | "middle";
+}
+/**
+ * Truncate content while exposing the exact retained head/tail windows.
  *
- * The combined output is `<head>\n<marker>\n<tail>` when truncation is needed.
- * `maxHeadBytes` defaults to `floor(maxBytes / 2)`; the tail receives the
- * remainder. Falls back to `truncateTail` / `truncateHead` if either side's
- * budget is empty or the content already fits.
+ * The budget split and fallback ordering intentionally mirror truncateMiddle.
+ * The overlap classification is performed before resolving an overlap to a
+ * full window, so callers can distinguish disjoint, adjacent and overlapping
+ * candidate windows even when no marker is needed.
+ */
+export declare function truncateMiddleWindows(content: string, options?: TruncationOptions): ReadWindow;
+/**
+ * Truncate content keeping a head window and a tail window, eliding the middle.
+ * The composed return shape remains field-for-field compatible with the
+ * historical implementation; callers that need coordinates use
+ * truncateMiddleWindows directly.
  */
 export declare function truncateMiddle(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Dispatch truncation using the caller-facing direction vocabulary.
+ */
+export declare function truncateContent(content: string, options?: TruncationOptions): TruncationResult;
 export declare class TailBuffer {
     #private;
     readonly maxBytes: number;
@@ -186,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

@@ -45,8 +45,6 @@ export interface SkillActiveEntry {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     source_state_revision?: number;
-    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-    committed_mode_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -87,11 +85,19 @@ export interface SyncSkillActiveStateOptions {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     sourceRevision?: number;
-    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-    committedModeRevision?: number;
 }
 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;
@@ -99,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

@@ -20,9 +20,18 @@ interface RalplanHudState extends WorkflowGateHudState {
     iteration?: number;
     iterationFromIndex?: number;
     stages?: string;
+    architectPasses?: number;
+    criticPasses?: number;
+    reviewPassBudget?: number;
     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";

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;

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

@@ -1,4 +1,4 @@
-import { type SingleResult, type TaskToolDetails } from "./types";
+import { type ReviewFindingsArtifactRef, type SingleResult, type TaskToolDetails } from "./types";
 export interface TaskRoi {
     tokens: number;
     contextTokens?: number;
@@ -29,6 +29,7 @@ export interface TaskResultReceipt {
     contextWindow?: number;
     modelOverride?: string | string[];
     modelSubstitutionWarning?: SingleResult["modelSubstitutionWarning"];
+    fastMode?: boolean;
     usage?: SingleResult["usage"];
     cost?: number;
     usageCostBreakdownComplete?: true;
@@ -37,6 +38,9 @@ export interface TaskResultReceipt {
         attempt: number;
         errorSummary: string;
     };
+    setupFailure?: {
+        summary: string;
+    };
     errorSummary?: string;
     abortSummary?: string;
     preview: string;
@@ -55,6 +59,8 @@ export interface TaskResultReceipt {
             severity?: string;
             summary: string;
         }>;
+        /** Canonical full-fidelity findings; inline summaries are display-only. */
+        findingsRef?: ReviewFindingsArtifactRef;
     };
     extractedToolCounts?: Record<string, number>;
     forkContext?: SingleResult["forkContext"];

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

@@ -368,6 +368,13 @@ export interface ReviewFinding {
     line_start: number;
     line_end: number;
 }
+/** Durable full-fidelity review findings artifact associated with a task result. */
+export interface ReviewFindingsArtifactRef {
+    uri: `artifact://${string}`;
+    sizeBytes: number;
+    sha256: string;
+    findingCount: number;
+}
 /** Review summary submitted by the reviewer agent */
 export interface ReviewSummary {
     overall_correctness: "correct" | "incorrect";
@@ -439,6 +446,8 @@ export interface AgentProgress {
     durationMs: number;
     modelOverride?: string | string[];
     modelSubstitutionWarning?: ModelSubstitutionWarning;
+    /** Whether the resolved subagent model runs under the effective fast service tier. */
+    fastMode?: boolean;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -469,6 +478,8 @@ export interface AgentProgress {
         attempt: number;
         errorMessage: string;
     };
+    /** Safe diagnostic retained in terminal progress when setup fails before the first LLM request. */
+    setupFailure?: SetupFailureSummary;
     /**
      * Snapshot of the most recent `task` tool call's in-flight `TaskToolDetails`,
      * captured from `tool_execution_update`. Lets the parent UI surface live
@@ -478,6 +489,12 @@ export interface AgentProgress {
      */
     inflightTaskDetails?: TaskToolDetails;
 }
+/** Bounded diagnostic retained when subagent setup fails before an LLM request starts. */
+export interface SetupFailureSummary {
+    summary: string;
+}
+/** Create a bounded diagnostic that preserves a setup failure's cause without exposing credentials or local paths. */
+export declare function createSetupFailureSummary(error: unknown): SetupFailureSummary;
 /** Result from a single agent execution */
 export interface SingleResult {
     index: number;
@@ -501,7 +518,11 @@ export interface SingleResult {
     contextWindow?: number;
     modelOverride?: string | string[];
     modelSubstitutionWarning?: ModelSubstitutionWarning;
+    /** Whether the resolved subagent model ran under the effective fast service tier. */
+    fastMode?: boolean;
     error?: string;
+    /** Safe diagnostic for a failure before the subagent sent its first LLM request. */
+    setupFailure?: SetupFailureSummary;
     aborted?: boolean;
     abortReason?: string;
     paused?: boolean;
@@ -521,6 +542,8 @@ export interface SingleResult {
     producedChanges?: boolean;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
+    /** Full wrapper-owned review evidence, kept separate from caller completion data. */
+    reviewFindingsRef?: ReviewFindingsArtifactRef;
     /**
      * Terminal retry failure, when the subagent exited because the auto-retry
      * loop gave up (retry-after exceeded the cap, or all attempts exhausted).

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

@@ -8,9 +8,9 @@
  */
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { AskAnswerSource } from "./index";
-/** Register `source` for `sessionId`. Returns a disposer that clears it. */
+/** Register `source` for `sessionId`. Returns a disposer that restores the prior source. */
 export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
-/** The answer source for `sessionId`, if one is registered. */
+/** The highest-priority 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;

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

@@ -1,5 +1,5 @@
 import type { AgentToolContext } from "@gajae-code/agent-core";
-import { type OutputSummary } from "../session/streaming-output";
+import { type OutputSummary, type TerminalArtifactPublisher } from "../session/streaming-output";
 export interface BashInteractiveResult extends OutputSummary {
     exitCode: number | undefined;
     cancelled: boolean;
@@ -13,4 +13,7 @@ export declare function runInteractiveBashPty(ui: NonNullable<AgentToolContext["
     env?: Record<string, string>;
     artifactPath?: string;
     artifactId?: string;
+    artifactPublisher?: TerminalArtifactPublisher;
+    spillThreshold?: number;
+    headBytes?: number;
 }): Promise<BashInteractiveResult>;

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

@@ -1,12 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
+import { type BashArtifactSaveResult } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
-export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string): Promise<string | undefined>;
+export type BashOriginalArtifactSaveResult = BashArtifactSaveResult;
+export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string, onResult?: (result: BashOriginalArtifactSaveResult) => void): Promise<string | undefined>;
 declare const bashSchemaBase: z.ZodObject<{
     command: z.ZodString;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/types/tools/browser/launch.d.ts

@@ -13,6 +13,13 @@ export declare const DEFAULT_VIEWPORT: {
 export declare const BROWSER_PROTOCOL_TIMEOUT_MS = 60000;
 export declare function loadPuppeteer(): Promise<typeof Puppeteer>;
 export declare function loadPuppeteerInWorker(safeDir: string): Promise<typeof Puppeteer>;
+/** Test seam: the browser launch overrides as resolved from trusted env. */
+export declare function resolveBrowserEnvOverridesForTest(): {
+    executablePath: string | undefined;
+    proxy: string | undefined;
+    proxyBypassLoopback: boolean;
+    ignoreCertErrors: boolean;
+};
 export interface LaunchHeadlessOptions {
     headless: boolean;
     viewport?: {

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

@@ -4,6 +4,7 @@ import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
+import { type TruncationDirection } from "../session/streaming-output";
 import type { RenderResult } from "../web/scrapers/types";
 import { type OutputMeta } from "./output-meta";
 export declare function isReadableUrlPath(value: string): boolean;
@@ -50,7 +51,12 @@ interface ReadUrlCacheEntry {
     artifactId?: string;
     details: ReadUrlToolDetails;
     image?: FetchImagePayload;
+    /** Complete URL output, including its preamble and body. */
     output: string;
+    /** UTF-16 code-unit offset of the preamble in `output`. */
+    preambleChars: number;
+    /** Offset of the preamble after `wrapUntrustedContent(output)` is persisted. */
+    wrappedPreambleChars?: number;
 }
 export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
     path: string;
@@ -59,11 +65,21 @@ export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
     ensureArtifact?: boolean;
     preferCached?: boolean;
 }): Promise<ReadUrlCacheEntry>;
+export declare const WRAP_PREFIX_CHARS: number;
+export declare function escapeUntrustedContent(content: string): string;
 export declare function wrapUntrustedContent(content: string): string;
+/**
+ * Remove only the outer URL-output wrapper before line pagination. The content
+ * remains escaped exactly as persisted; it is deliberately never unescaped.
+ */
+export declare function prepareReadUrlSelectorInput(output: string, preambleChars: number, wrappedPreambleChars?: number): {
+    text: string;
+    preambleChars: number;
+};
 export declare function executeReadUrl(session: ToolSession, params: {
     path: string;
     raw?: boolean;
-}, signal?: AbortSignal): Promise<AgentToolResult<ReadUrlToolDetails>>;
+}, signal?: AbortSignal, direction?: TruncationDirection): Promise<AgentToolResult<ReadUrlToolDetails>>;
 /** Render URL read call (URL preview) */
 export declare function renderReadUrlCall(args: {
     path?: string;

package/dist/types/tools/image-gen.d.ts

@@ -134,7 +134,11 @@ export declare function setConfiguredImageModel(config: ImageProviderConfig | nu
 export declare function getConfiguredImageModel(): ImageProviderConfig | null;
 /** Resolve the effective image model for a configured provider */
 export declare function resolveImageModel(provider: string, modelOverride: string | null): string;
+/** Test seam: the Google image key fallback as resolved from trusted env. */
+export declare function googleImageApiKeyFromEnvForTest(): string | undefined;
 export declare function isOpenAIHostedImageModel(model: Model | undefined): model is Model;
+/** Test seam: the image-request base URL as resolved from trusted env. */
+export declare function getOpenAIImageBaseUrlForTest(model: Model, authCredentialType?: "api_key" | "oauth"): string;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
 export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;

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

@@ -215,6 +215,8 @@ export interface ToolSession {
     strictToolNames?: boolean;
     /** Get artifacts directory for artifact:// URLs */
     getArtifactsDir?: () => string | null;
+    /** Additional artifacts directories explicitly authorized for this session's tree (parent/child/sibling reads). Derived only from the explicitly adopted/shared `ArtifactManager`; never enumerates unrelated live sessions. */
+    getAuthorizedArtifactsDirs?: () => readonly string[];
     /** Get the ArtifactManager backing this session (shared across parent + subagents). */
     getArtifactManager?: () => ArtifactManager | null;
     /** Allocate a new artifact path and ID for session-scoped truncated output. */
@@ -240,6 +242,8 @@ export interface ToolSession {
     settings: Settings;
     /** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
     serviceTier?: ServiceTier;
+    /** Whether the effective subagent tier grants fast mode for a resolved provider. */
+    isFastForSubagentProvider?: (provider?: string) => boolean;
     /** Plan mode state (if active) */
     getPlanModeState?: () => PlanModeState | undefined;
     /** Goal mode state (if active or paused) */

package/dist/types/tools/output-meta.d.ts

@@ -7,12 +7,15 @@
 import type { AgentTool } from "@gajae-code/agent-core";
 import { type Settings } from "../config/settings";
 import type { Theme } from "../modes/theme/theme";
-import { type OutputSummary, type TruncationResult } from "../session/streaming-output";
+import { type OutputSummary, type ReadWindow, type TruncationResult } from "../session/streaming-output";
 /**
  * Truncation metadata for the output notice.
  */
 export interface TruncationMeta {
     direction: "head" | "tail" | "middle";
+    /** Coordinate basis for shown/head/tail ranges. Omitted means file coordinates; "window" is the selected-range coordinate system. */
+    rangeBase?: "file" | "window";
+    noticeOwner?: "body";
     truncatedBy: "lines" | "bytes" | "middle";
     totalLines: number;
     totalBytes: number;
@@ -33,12 +36,22 @@ export interface TruncationMeta {
         start: number;
         end: number;
     };
+    /** Partial source-line preview retained by a directional window. */
+    partialLine?: {
+        line: number;
+        bytes: number;
+        sourceBytes: number;
+    };
     /** Bytes elided from the middle. */
     elidedBytes?: number;
     /** Lines elided from the middle. */
     elidedLines?: number;
-    /** Artifact ID if full output was saved */
+    /** Artifact ID when output was persisted; completeness is tracked separately below. */
     artifactId?: string;
+    /** Bytes omitted from an artifact after its hard storage cap was reached. */
+    artifactTruncatedBytes?: number;
+    /** Bounded diagnostic when artifact writer creation, write, or finalization failed. */
+    artifactFailureDiagnostic?: string;
     /** Next offset for pagination (head truncation only) */
     nextOffset?: number;
 }
@@ -96,11 +109,14 @@ export interface TruncationOptions {
     startLine?: number;
     totalFileLines?: number;
     artifactId?: string;
+    maxBytes?: number;
+    noticeOwner?: "body";
 }
 export interface TruncationSummaryOptions {
     direction: "head" | "tail" | "middle";
     startLine?: number;
     totalFileLines?: number;
+    noticeOwner?: "body";
 }
 export interface TruncationTextOptions {
     direction: "head" | "tail" | "middle";
@@ -108,6 +124,7 @@ export interface TruncationTextOptions {
     totalBytes?: number;
     maxBytes?: number;
     artifactId?: string;
+    noticeOwner?: "body";
 }
 /**
  * Fluent builder for OutputMeta.
@@ -125,7 +142,14 @@ export declare class OutputMetaBuilder {
     #private;
     /** Add truncation info from TruncationResult. No-op if not truncated. */
     truncation(result: TruncationResult, options: TruncationOptions): this;
-    /** Add truncation info from OutputSummary. No-op if not truncated. */
+    /** Add metadata from the actual head/tail windows retained by middle truncation. */
+    truncationWindows(windows: ReadWindow, options?: {
+        artifactId?: string;
+        noticeOwner?: "body";
+        maxBytes?: number;
+        rangeBase?: "file" | "window";
+    }): this;
+    /** Add truncation info from OutputSummary. No-op if not truncated or artifact evidence is absent. */
     truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
     /** Add truncation info from truncated output text. No-op if truncation not detected. */
     truncationFromText(text: string, options: TruncationTextOptions): this;
@@ -158,6 +182,10 @@ export declare class OutputMetaBuilder {
 /** Create a new OutputMetaBuilder. */
 export declare function outputMeta(): OutputMetaBuilder;
 export declare function formatFullOutputReference(artifactId: string): string;
+/**
+ * Format an artifact reference without claiming completeness when storage was hard-capped.
+ */
+export declare function formatArtifactReference(artifactId: string, artifactTruncatedBytes?: number): string;
 export declare function formatTruncationMetaNotice(truncation: TruncationMeta): string;
 /**
  * Format styled artifact reference with warning color and brackets.
@@ -191,6 +219,19 @@ export declare function stripOutputNotice(text: string, meta: OutputMeta | undef
  * middle elision with the same per-user configuration.
  */
 export declare function resolveOutputSinkHeadBytes(s: Settings | undefined): number;
+export declare const BASH_DEFAULT_OUTPUT_TAIL_BYTES = 1024;
+/**
+ * Bash uses a deliberately small tail window to nudge callers toward focused
+ * commands and dedicated search tools. An explicitly configured shared tail
+ * budget still wins.
+ */
+export declare function resolveBashOutputSinkTailBytes(s: Settings): number;
+/**
+ * Bash keeps only the tail unless the user explicitly opts into the shared
+ * head-retention setting. Schema defaults still apply to other streaming
+ * tools without silently turning Bash back into middle-elision mode.
+ */
+export declare function resolveBashOutputSinkHeadBytes(s: Settings): number;
 /**
  * Resolve the per-line column cap from session settings. Shared by streaming
  * executors (bash/python/ssh/eval via OutputSink) and the `read` tool's

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

@@ -112,6 +112,7 @@ export interface ToolScopeOptions {
     rawPaths: string[];
     cwd: string;
     getArtifactsDir?: () => string | null;
+    getAuthorizedArtifactsDirs?: () => readonly string[];
     /** 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. */