@sayknow-cli/coding-agent 0.3.12 → 0.3.13

package/dist/types/task/simple-mode.d.ts

@@ -1,8 +0,0 @@
-export declare const TASK_SIMPLE_MODES: readonly ["default", "schema-free", "independent"];
-export type TaskSimpleMode = (typeof TASK_SIMPLE_MODES)[number];
-interface TaskSimpleModeCapabilities {
-    contextEnabled: boolean;
-    customSchemaEnabled: boolean;
-}
-export declare function getTaskSimpleModeCapabilities(mode: TaskSimpleMode): TaskSimpleModeCapabilities;
-export {};

package/dist/types/task/skc-command.d.ts

@@ -1,7 +0,0 @@
-interface SkcCommand {
-    cmd: string;
-    args: string[];
-    shell: boolean;
-}
-export declare function resolveSkcCommand(): SkcCommand;
-export {};

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

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

package/dist/types/task/subprocess-tool-registry.d.ts

@@ -1,72 +0,0 @@
-/**
- * Registry for handling tool events from subprocess agents.
- *
- * Tools can register handlers to:
- * - Extract structured data from their execution results
- * - Trigger subprocess termination on completion
- * - Provide custom rendering for realtime/final display
- */
-import type { Component } from "@sayknow-cli/tui";
-import type { Theme } from "../modes/theme/theme";
-/** Event from subprocess tool execution (parsed from JSONL) */
-export interface SubprocessToolEvent {
-    toolName: string;
-    toolCallId: string;
-    args?: Record<string, unknown>;
-    result?: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: unknown;
-    };
-    isError?: boolean;
-}
-/** Handler for subprocess tool events */
-export interface SubprocessToolHandler<TData = unknown> {
-    /**
-     * Extract structured data from tool result.
-     * Extracted data is accumulated in progress.extractedToolData[toolName][].
-     */
-    extractData?: (event: SubprocessToolEvent) => TData | undefined;
-    /**
-     * Whether this tool's completion should terminate the subprocess.
-     * Return true to send SIGTERM after the tool completes.
-     */
-    shouldTerminate?: (event: SubprocessToolEvent) => boolean;
-    /**
-     * Render a single data item inline during streaming progress.
-     * Called for each tool execution end event.
-     */
-    renderInline?: (data: TData, theme: Theme) => Component;
-    /**
-     * Render accumulated data in the final result view.
-     * Called once with all accumulated data for this tool.
-     */
-    renderFinal?: (allData: TData[], theme: Theme, expanded: boolean) => Component;
-}
-/** Registry for subprocess tool handlers */
-declare class SubprocessToolRegistryImpl {
-    #private;
-    /**
-     * Register a handler for a tool's subprocess events.
-     */
-    register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
-    /**
-     * Get the handler for a tool, if registered.
-     */
-    getHandler(toolName: string): SubprocessToolHandler | undefined;
-    /**
-     * Check if a tool has a registered handler.
-     */
-    hasHandler(toolName: string): boolean;
-    /**
-     * Get all registered tool names.
-     */
-    getRegisteredTools(): string[];
-}
-/** Singleton registry instance */
-export declare const subprocessToolRegistry: SubprocessToolRegistryImpl;
-/** Type helper for extracted tool data in progress/result */
-export type ExtractedToolData = Record<string, unknown[]>;
-export {};

package/dist/types/task/token-log.d.ts

@@ -1,30 +0,0 @@
-import type { ChatUsageSnapshot, CostEstimate } from "@sayknow-cli/agent-core";
-import type { TaskTokenLog, TaskTokenMetrics } from "./types";
-export interface TaskTokenLogChatBuckets {
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly cachedInputTokens: number;
-    readonly cacheWriteTokens: number;
-    readonly costUsd?: number;
-}
-export interface TaskTokenLogSessionManager {
-    getSessionId(): string;
-}
-export interface TaskTokenLogContext {
-    readonly subagentId: string;
-    readonly agent?: string;
-    readonly turn: number;
-    readonly at: string;
-    readonly model?: string;
-}
-export declare function taskTokenLogFromChat(chat: TaskTokenLogChatBuckets, ctx: TaskTokenLogContext): TaskTokenLog;
-export declare function taskTokenLogFromUsage(usage: ChatUsageSnapshot, ctx: TaskTokenLogContext & {
-    readonly cost?: CostEstimate;
-}): TaskTokenLog;
-export declare function resolveTaskTokenLogDir(cwd: string, sessionManager: TaskTokenLogSessionManager | undefined, envSessionId?: string | undefined): Promise<string | undefined>;
-export declare function persistTaskTokenLog(entry: TaskTokenLog, opts: {
-    dir: string;
-}): Promise<void>;
-export declare function readTaskTokenLogs(dir: string): Promise<TaskTokenLog[]>;
-export declare function computeTaskTokenMetrics(logs: readonly TaskTokenLog[]): TaskTokenMetrics;
-export declare function computeCacheHitRate(input: number, cacheRead: number): number;

package/dist/types/task/token-log.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,508 +0,0 @@
-import type { ThinkingLevel } from "@sayknow-cli/agent-core";
-import type { Usage } from "@sayknow-cli/ai";
-import * as z from "zod/v4";
-import type { TaskResultReceipt } from "./receipt";
-import type { SpawnRoiReconciliation } from "./roi-reconciliation";
-import { type TaskSimpleMode } from "./simple-mode";
-import type { SpawnPlanReceipt } from "./spawn-gate";
-import type { NestedRepoPatch } from "./worktree";
-/** Source of an agent definition */
-export type AgentSource = "bundled" | "user" | "project";
-export type ForkContextPolicy = "forbidden" | "allowed";
-export type ForkContextMode = "none" | "receipt" | "last-turn" | "bounded" | "full";
-/** Maximum output bytes per agent */
-export declare const MAX_OUTPUT_BYTES: number;
-/** Maximum output lines per agent */
-export declare const MAX_OUTPUT_LINES: number;
-/** EventBus channel for raw subagent events */
-export declare const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
-/** EventBus channel for aggregated subagent progress */
-export declare const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
-/** EventBus channel for subagent lifecycle (start/end) */
-export declare const TASK_SUBAGENT_LIFECYCLE_CHANNEL = "task:subagent:lifecycle";
-/** Payload emitted on TASK_SUBAGENT_PROGRESS_CHANNEL */
-export interface SubagentProgressPayload {
-    index: number;
-    agent: string;
-    agentSource: AgentSource;
-    task: string;
-    assignment?: string;
-    progress: AgentProgress;
-    sessionFile?: string;
-}
-/** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
-export interface SubagentLifecyclePayload {
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    description?: string;
-    status: "started" | "completed" | "failed" | "aborted" | "paused";
-    sessionFile?: string;
-    index: number;
-}
-/** Single task item for parallel execution (default shape with context enabled). */
-export declare const taskItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodString;
-    assignment: z.ZodString;
-    inheritContext: z.ZodOptional<z.ZodEnum<{
-        bounded: "bounded";
-        full: "full";
-        "last-turn": "last-turn";
-        none: "none";
-        receipt: "receipt";
-    }>>;
-}, z.core.$strip>;
-export type TaskItem = z.infer<typeof taskItemSchema>;
-export declare const taskSchema: z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const taskSchemaNoIsolation: z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodEnum<{
-            bounded: "bounded";
-            full: "full";
-            "last-turn": "last-turn";
-            none: "none";
-            receipt: "receipt";
-        }>>;
-    }, z.core.$strip>>;
-    spawnPlan: z.ZodOptional<z.ZodObject<{
-        whyParallel: z.ZodString;
-        whyNotLocal: z.ZodString;
-        independence: z.ZodString;
-        expectedReceiptShape: z.ZodString;
-        maxInlineTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>];
-type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
-export type TaskSchema = typeof taskSchema;
-/** Active task tool parameter schema for the current simple-mode / isolation flags */
-export type TaskToolSchemaInstance = DynamicTaskSchema;
-export declare function getTaskSchema(options: {
-    isolationEnabled: boolean;
-    simpleMode: TaskSimpleMode;
-}): DynamicTaskSchema;
-export interface TaskParams {
-    agent: string;
-    context?: string;
-    schema?: string;
-    spawnPlan?: SpawnPlanReceipt;
-    tasks: TaskItem[];
-    isolated?: boolean;
-}
-/** A code review finding reported by the reviewer agent */
-export interface ReviewFinding {
-    title: string;
-    body: string;
-    priority: number;
-    confidence: number;
-    file_path: string;
-    line_start: number;
-    line_end: number;
-}
-/** Review summary submitted by the reviewer agent */
-export interface ReviewSummary {
-    overall_correctness: "correct" | "incorrect";
-    explanation: string;
-    confidence: number;
-}
-/** Structured review data extracted from reviewer agent */
-export interface ReviewData {
-    findings: ReviewFinding[];
-    summary?: ReviewSummary;
-}
-/** Agent definition (bundled or discovered) */
-export interface AgentDefinition {
-    name: string;
-    description: string;
-    systemPrompt: string;
-    tools?: string[];
-    spawns?: string[] | "*";
-    model?: string[];
-    thinkingLevel?: ThinkingLevel;
-    output?: unknown;
-    blocking?: boolean;
-    autoloadSkills?: string[];
-    hide?: boolean;
-    forkContext?: ForkContextPolicy;
-    bashAllowedPrefixes?: string[];
-    source: AgentSource;
-    filePath?: string;
-}
-export interface ModelSubstitutionWarning {
-    requested: string;
-    effective: string;
-    reason: "auth_unavailable" | "assistant_model_mismatch";
-}
-/** Progress tracking for a single agent */
-export interface AgentProgress {
-    index: number;
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    status: "pending" | "running" | "completed" | "failed" | "aborted" | "paused";
-    task: string;
-    assignment?: string;
-    description?: string;
-    lastIntent?: string;
-    currentTool?: string;
-    currentToolArgs?: string;
-    currentToolStartMs?: number;
-    recentTools: Array<{
-        tool: string;
-        args: string;
-        endMs: number;
-    }>;
-    recentOutput: string[];
-    toolCount: number;
-    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
-    tokens: number;
-    /**
-     * Current per-turn context size: latest assistant message's `usage.totalTokens`.
-     * This is the number to compare against `contextWindow` — what compaction
-     * decides on, what the user typically reads as "how full is the context".
-     * Distinct from `tokens`, which is a lifetime billing-volume counter.
-     */
-    contextTokens?: number;
-    /** Model's context window in tokens, when known. Lets the UI render `<curr>/<window>` gauges. */
-    contextWindow?: number;
-    /** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
-    cost: number;
-    durationMs: number;
-    modelOverride?: string | string[];
-    modelSubstitutionWarning?: ModelSubstitutionWarning;
-    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
-    extractedToolData?: Record<string, unknown[]>;
-    /**
-     * Auto-retry state when the subagent is sleeping between provider retries
-     * (e.g. 429 rate-limit with retry-after). Cleared when the retry resolves
-     * or fails. Surfacing this to the parent prevents the task tool from
-     * looking indefinitely "in progress" when a child is actually blocked on
-     * provider quota.
-     */
-    retryState?: {
-        attempt: number;
-        maxAttempts: number;
-        unbounded?: boolean;
-        delayMs: number;
-        errorMessage: string;
-        startedAtMs: number;
-    };
-    /**
-     * Terminal retry failure surfaced once the subagent gave up retrying
-     * (e.g. retry-after exceeded the cap, or all attempts exhausted). Carries
-     * the final error so the parent UI can render "blocked: rate-limited"
-     * instead of waiting for a status that never arrives.
-     */
-    retryFailure?: {
-        attempt: number;
-        errorMessage: string;
-    };
-    /**
-     * Snapshot of the most recent `task` tool call's in-flight `TaskToolDetails`,
-     * captured from `tool_execution_update`. Lets the parent UI surface live
-     * nested-subagent progress while this agent is still inside its own `task`
-     * call. Cleared when the call ends — finalized data lives in
-     * `extractedToolData.task` after that.
-     */
-    inflightTaskDetails?: TaskToolDetails;
-}
-/** Result from a single agent execution */
-export interface SingleResult {
-    index: number;
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    task: string;
-    assignment?: string;
-    description?: string;
-    lastIntent?: string;
-    exitCode: number;
-    output: string;
-    stderr: string;
-    truncated: boolean;
-    durationMs: number;
-    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
-    tokens: number;
-    /** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
-    contextTokens?: number;
-    /** Model's context window in tokens, when known. */
-    contextWindow?: number;
-    modelOverride?: string | string[];
-    modelSubstitutionWarning?: ModelSubstitutionWarning;
-    error?: string;
-    aborted?: boolean;
-    abortReason?: string;
-    paused?: boolean;
-    /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
-    usage?: Usage;
-    /** Output path for the task result */
-    outputPath?: string;
-    /** Patch path for isolated worktree output */
-    patchPath?: string;
-    /** Branch name for isolated branch-mode output */
-    branchName?: string;
-    /** Nested repo patches to apply after parent merge */
-    nestedPatches?: NestedRepoPatch[];
-    /** Whether isolated execution produced a non-empty root or nested patch. */
-    producedChanges?: boolean;
-    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
-    extractedToolData?: Record<string, unknown[]>;
-    /**
-     * Terminal retry failure, when the subagent exited because the auto-retry
-     * loop gave up (retry-after exceeded the cap, or all attempts exhausted).
-     * Lets the parent task tool surface a "blocked: rate-limited" outcome
-     * instead of a generic failure.
-     */
-    retryFailure?: {
-        attempt: number;
-        errorMessage: string;
-    };
-    /** Output metadata for agent:// URL integration */
-    outputMeta?: {
-        lineCount: number;
-        charCount: number;
-        byteSize?: number;
-        sha256?: string;
-    };
-    /** Fork-context seed accounting for this subagent, when inherited parent context was cloned. */
-    forkContext?: {
-        mode: ForkContextMode;
-        clonedTokens: number;
-    };
-    /**
-     * Advisory fork-context mode recommendation for this task (logged only;
-     * never changes the actual mode selection).
-     */
-    forkContextAdvisory?: {
-        recommendedMode: ForkContextMode;
-        reasons: string[];
-    };
-}
-/** Tool details for TUI rendering */
-export interface TaskToolDetails {
-    projectAgentsDir: string | null;
-    results: TaskResultReceipt[];
-    totalDurationMs: number;
-    /** Aggregated usage across all subagents. */
-    usage?: Usage;
-    /** Aggregate cloned tokens copied into fork-context seeds across subagents. */
-    forkContextClonedTokens?: number;
-    roiSummary?: {
-        childCount: number;
-        totalTokens: number;
-        totalCostTotal?: number;
-        totalClonedTokens?: number;
-        /** Advisory ids for terminal children that spent tokens without detectable output/review/changes. */
-        lowRoiChildIds: string[];
-    };
-    roiReconciliation?: SpawnRoiReconciliation;
-    progress?: AgentProgress[];
-    async?: {
-        state: "running" | "paused" | "queued" | "completed" | "failed";
-        jobId: string;
-        type: "task";
-    };
-}
-/**
- * Persisted per-turn / per-subagent token record (Phase 0 instrumentation).
- *
- * Additive: this does not alter any existing task result shape. It is the
- * durable, model-independent unit the deterministic orchestration-token
- * benchmark (`@sayknow-cli/orchestration-token-benchmark`) consumes to measure
- * token efficiency without any live-model calls.
- */
-export interface TaskTokenLog {
-    /** Subagent id, or "root" for the orchestrator's own turn. */
-    subagentId: string;
-    /** Agent name for attribution, when known. */
-    agent?: string;
-    /** 1-based turn index within the subagent's session. */
-    turn: number;
-    /** ISO-8601 timestamp the turn completed. */
-    at: string;
-    /** Cost-bearing input tokens (excludes cache reads), mirrors `Usage.input`. */
-    input: number;
-    /** Total output tokens for the turn, mirrors `Usage.output`. */
-    output: number;
-    /** Tokens read from the prompt cache, mirrors `Usage.cacheRead`. */
-    cacheRead: number;
-    /** Tokens written to the prompt cache, mirrors `Usage.cacheWrite`. */
-    cacheWrite: number;
-    /** input + output + cacheRead + cacheWrite. */
-    totalTokens: number;
-    /** Latest per-turn context-window occupancy, when known. */
-    contextTokens?: number;
-    /** Estimated USD cost for the turn, when known. */
-    cost?: number;
-    /** Model id used for the turn, when known. */
-    model?: string;
-}
-/**
- * Deterministic aggregate token metrics computed from a set of `TaskTokenLog`
- * entries. The cache-hit-rate field is the primary prompt-cache signal called
- * out by the prefix-stability invariant (see the approved plan).
- */
-export interface TaskTokenMetrics {
-    /** Number of token-log entries aggregated. */
-    turns: number;
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    totalTokens: number;
-    /** cacheRead / (input + cacheRead); 0 when there is no input-class traffic. */
-    cacheHitRate: number;
-}
-export {};