zidane 4.0.2 → 4.1.3

package/dist/skills.d.ts

@@ -1,322 +1,3 @@
-import { A as AgentHooks, V as SkillActivationState, X as SkillConfig, _ as SkillSource, Y as SkillDiagnostic, $ as SkillsConfig } from './agent-BAHrGtqu.js';
-export { a as ActivationVia, b as ActiveSkill, D as DeactivationReason, W as SkillActivationStateOptions, Z as SkillResource, at as createSkillActivationState } from './agent-BAHrGtqu.js';
-import { Hookable } from 'hookable';
-import { a as ExecutionContext, c as ExecutionHandle } from './types-Bai5rKpa.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-
-/**
- * `allowed-tools` enforcement middleware.
- *
- * Installed by the agent on `tool:gate` and `mcp:tool:gate`. Computes the
- * union of `allowedTools` patterns across currently-active skills; blocks any
- * tool call whose `displayName` is not in that union. The three injected
- * skills tools (`skills_use` / `skills_read` / `skills_run_script`) are
- * implicitly allowed so a skill declaring an allow-list cannot lock out the
- * scaffolding that lets it run at all.
- *
- * The match target is `displayName` (wire / LLM-facing name), not the
- * canonical name, because skill authors write allow-list entries to match
- * what the model sees.
- */
-
-/** Tools that are always allowed regardless of the active skills' allow-list. */
-declare const IMPLICITLY_ALLOWED_SKILL_TOOLS: readonly string[];
-/**
- * Register `tool:gate` / `mcp:tool:gate` handlers that enforce the union of
- * `allowedTools` across active skills.
- *
- * No-op when no active skill declares an allow-list (permissive default —
- * matches the spec's "experimental" note for `allowed-tools`).
- *
- * Returns an `uninstall` fn. The agent calls this at run end to detach the
- * handlers and prevent cross-run hook leaks.
- */
-declare function installAllowedToolsGate(hooks: Hookable<AgentHooks>, state: SkillActivationState): () => void;
-
-/**
- * Skill catalog generation.
- *
- * Builds the system prompt section that discloses available skills to the
- * agent — tier 1 of progressive disclosure per the Agent Skills spec.
- *
- * The catalog's behavioral prose branches on which activation mechanism is
- * active for the run:
- *
- * - When the `skills_use` tool is auto-injected (the default for a non-empty
- *   catalog), the prose tells the model to call `skills_use` with the skill's
- *   name. The agent returns a structured `<skill_content>` block.
- * - When the skills tool is opted out (`SkillsConfig.tool: false`), the prose
- *   falls back to the file-read pattern — the model reads `SKILL.md` itself
- *   via its file-read tool.
- */
-
-interface BuildCatalogOptions {
-    /**
-     * When true (the default), the prose instructs the model to call
-     * `skills_use`. Set to false when `SkillsConfig.tool === false` so the
-     * system prompt matches the active activation mechanism.
-     */
-    skillsToolRegistered?: boolean;
-    /**
-     * Name of the tool the model should use to read `SKILL.md` files when
-     * `skillsToolRegistered` is false. Defaults to `'read_file'`.
-     */
-    readToolName?: string;
-}
-/**
- * Build the skill catalog XML and behavioral instructions for the system prompt.
- */
-declare function buildCatalog(skills: SkillConfig[], options?: BuildCatalogOptions): string;
-
-/**
- * Skill discovery and parsing.
- *
- * Scans filesystem directories for SKILL.md files following the
- * Agent Skills specification (agentskills.io/specification).
- *
- * Parsing is intentionally **lenient** — per the spec's client-implementation
- * guide: warn, don't block. Diagnostics are attached to the returned
- * SkillConfig for host UIs to surface; only unrecoverable errors (missing
- * description, unparseable YAML) skip the skill entirely.
- */
-
-interface ParsedSkillFile {
-    frontmatter: Record<string, unknown>;
-    body: string;
-    diagnostics: SkillDiagnostic[];
-}
-/**
- * Parse a SKILL.md file into frontmatter + body.
- *
- * Uses a simple regex-based YAML extractor that handles:
- * - Flat key: value pairs
- * - Quoted values
- * - One-level nested maps (for `metadata:`)
- * - Lenient recovery from unquoted-colon values (e.g.
- *   `description: Use when: the user asks …`) via a quote-wrap retry.
- */
-declare function parseFrontmatter(content: string): ParsedSkillFile;
-interface ParseSkillOptions {
-    /** Source tag to attach to the returned SkillConfig. */
-    source?: SkillSource;
-}
-/**
- * Parse a SKILL.md file into a SkillConfig (lenient).
- *
- * Returns `null` only when the skill is fundamentally unusable:
- * - The file is missing
- * - The description is absent (required by spec for disclosure)
- *
- * All other issues are surfaced as `SkillConfig.diagnostics` with severity
- * `warning`. Deprecated top-level fields (`paths`, `model`, `thinking`) are
- * auto-migrated into `metadata['zidane.*']`.
- */
-declare function parseSkillFile(filePath: string, options?: ParseSkillOptions): Promise<SkillConfig | null>;
-/** A scan path paired with the source tag that should be attached to any skills found in it. */
-interface SourcedScanPath {
-    path: string;
-    source: SkillSource;
-}
-/**
- * Return the default scan paths tagged by source. Project-scope paths come
- * first; their skills therefore win on name collisions against user-scope
- * skills (first-found wins in discovery).
- */
-declare function getDefaultScanPaths(): SourcedScanPath[];
-/**
- * Infer a source tag for a user-provided scan path.
- * Paths under `$HOME` are treated as 'user'; everything else as 'project'.
- */
-declare function inferSource(path: string): SkillSource;
-/**
- * Discover skills from sourced filesystem paths.
- * Each path is scanned for subdirectories containing SKILL.md.
- * Earlier paths have higher priority (first-found wins on name collision).
- */
-declare function discoverSkills(paths: SourcedScanPath[]): Promise<SkillConfig[]>;
-
-/**
- * Shell interpolation for skill instructions.
- *
- * The `!\`command\`` syntax runs shell commands as a preprocessing step
- * before skill content is sent to the agent. The command output replaces
- * the placeholder — the agent only sees the final result.
- *
- * Example:
- *   - PR diff: !\`gh pr diff\`
- *   → - PR diff: <actual diff output>
- */
-
-/**
- * Interpolate shell commands in skill instructions.
- *
- * Runs each !\`command\` through the execution context and replaces
- * the placeholder with the command's stdout. If a command fails,
- * the placeholder is replaced with an error message.
- *
- * @param instructions - Raw skill instructions with potential !\`command\` patterns
- * @param execution - The execution context to run commands in
- * @param handle - The active execution handle
- * @returns Instructions with all !\`command\` patterns replaced by output
- */
-declare function interpolateShellCommands(instructions: string, execution: ExecutionContext, handle: ExecutionHandle): Promise<string>;
-
-/**
- * Skill resolution — discovers filesystem skills, writes dynamic skills,
- * merges everything, and applies filtering.
- */
-
-/**
- * Resolved-skills bundle: the materialized list plus a `cleanup` fn that
- * removes any temporary directory created for `config.write` skills.
- *
- * Inline skills must live on disk for the lifetime of the agent (the
- * `skills_read` / `skills_run_script` tools resolve relative paths against
- * `baseDir`), so cleanup is deferred to `agent.destroy()`. When no temp
- * directory was created, `cleanup` is a no-op.
- */
-interface ResolvedSkillsBundle {
-    skills: SkillConfig[];
-    cleanup: () => void;
-}
-/**
- * Resolve all skills from a SkillsConfig:
- *
- * 1. Materialize `config.write` entries to a temp directory, tagged as `inline`
- * 2. Combine with default + user-provided scan paths (project-first, user-next)
- * 3. Run lenient discovery
- * 4. Apply filters: `exclude`, `enabled` allowlist, optional project-skill trust gate
- *
- * Returns `{ skills, cleanup }` — call `cleanup()` on agent destroy to remove
- * the temp directory created for inline `config.write` skills. The agent
- * factory wires this automatically; standalone callers must invoke it
- * themselves to avoid leaking OS temp.
- */
-declare function resolveSkills(config: SkillsConfig): Promise<ResolvedSkillsBundle>;
-
-/**
- * Strict validators for Agent Skills.
- *
- * Applied on the authoring path (`defineSkill`, `writeSkillToDisk`). Parser-time
- * validation is intentionally lenient — see `parseSkillFile` for diagnostic collection.
- */
-
-/**
- * A single issue surfaced by skill-authoring validation.
- * Distinct from `ValidationResult` in `tools/validation.ts` (tool-input JSON
- * schema validation) — different domain, different module.
- */
-interface SkillValidationIssue {
-    /** Stable machine-readable code for consumer matching. */
-    code: string;
-    /** Human-readable description. */
-    message: string;
-    /** Frontmatter field name the issue relates to, when applicable. */
-    field?: string;
-}
-interface SkillValidationResult {
-    valid: boolean;
-    errors: SkillValidationIssue[];
-}
-/**
- * Validate a skill name per the spec:
- * - 1–64 characters
- * - Lowercase alphanumeric + hyphens only
- * - Must not start or end with a hyphen
- * - Must not contain consecutive hyphens
- *
- * The parent-directory match is validated separately (it requires knowing the
- * skill's `location`, which this function does not).
- */
-declare function validateSkillName(name: string): boolean;
-/**
- * Strict validation for a skill that is about to be authored / written to disk.
- * Rejects anything that would violate the spec. Use the lenient parser path
- * (`parseSkillFile`) for loading third-party skills.
- */
-declare function validateSkillForWrite(skill: SkillConfig): SkillValidationResult;
-/**
- * Validate that `relPath` stays inside `baseDir` when resolved.
- *
- * Rejects:
- * - Absolute paths (`/etc/passwd`, `C:\…`)
- * - Parent traversal (`..` segments that escape baseDir)
- * - Null-byte tricks
- *
- * Returns `{ valid: true, absolutePath }` on success or `{ valid: false, error }`
- * with a human-readable reason.
- */
-declare function validateResourcePath(relPath: string, baseDir: string): {
-    valid: true;
-    absolutePath: string;
-} | {
-    valid: false;
-    error: string;
-};
-/**
- * Parse a single `allowed-tools` entry into its tool name + optional argument pattern.
- *
- * Examples:
- * - `Read` → `{ tool: 'Read' }`
- * - `Bash(git:*)` → `{ tool: 'Bash', argPrefix: 'git' }`
- */
-declare function parseAllowedToolPattern(entry: string): {
-    tool: string;
-    argPrefix?: string;
-} | null;
-/**
- * Check whether a tool call (identified by its wire/displayName and argument input)
- * matches a skill's allow-list entry.
- *
- * Matching rules (Zidane's interpretation of the spec's unspecified syntax):
- * - Exact match: displayName === pattern (no parens).
- * - Prefix match: for `Tool(arg:*)`, displayName === 'Tool' AND **any** string
- *   value in the input object starts with `arg`. This is intentionally
- *   permissive: it doesn't depend on a convention about which property carries
- *   the "command" (schemas vary across tools), and for the common
- *   `shell({ command: 'git …' })` shape it behaves identically to a "primary
- *   string" rule.
- * - For tools whose inputs carry no string values, the arg-match returns false.
- */
-declare function matchesAllowedTool(displayName: string, input: Record<string, unknown>, pattern: string): boolean;
-/**
- * Test whether a tool call is allowed by the union of `allowedTools` across a set
- * of active skills. Returns `true` when the union is empty (permissive default)
- * OR when any entry matches.
- */
-declare function isToolAllowedByUnion(displayName: string, input: Record<string, unknown>, union: readonly string[]): boolean;
-
-/**
- * Skill writer — materializes inline SkillConfig objects to disk as proper
- * SKILL.md files so they participate fully in the filesystem-based skill system.
- *
- * Strict-validates each skill before writing (see `validateSkillForWrite`).
- */
-
-/**
- * Write a `SkillConfig` to disk as a proper skill directory with SKILL.md.
- * Returns the path to the written SKILL.md file.
- *
- * Throws if the skill fails `validateSkillForWrite` — the authoring path is
- * strict on purpose. For loading third-party skills, use `parseSkillFile`
- * directly (lenient).
- */
-declare function writeSkillToDisk(skill: SkillConfig, targetDir: string): string;
-/**
- * Write multiple `SkillConfig` objects to a target directory.
- * Each skill gets its own subdirectory with a SKILL.md file.
- * Returns the target directory path (for use as a scan path).
- */
-declare function writeSkillsToDisk(skills: SkillConfig[], targetDir: string): string;
-
-/**
- * Define an inline skill configuration.
- *
- * Strict-validates at author-time — throws if the config would be rejected by
- * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.
- */
-declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
-    source?: SkillConfig['source'];
-}): SkillConfig;
-
-export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillConfig, SkillDiagnostic, SkillSource, type SkillValidationIssue, type SkillValidationResult, SkillsConfig, type SourcedScanPath, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };
+import { C as SkillsConfig, S as SkillSource, a as ActivationVia, b as SkillDiagnostic, c as SkillActivationState, l as SkillActivationStateOptions, o as ActiveSkill, s as DeactivationReason, u as createSkillActivationState, x as SkillResource, y as SkillConfig } from "./agent-BoV5Twdl.js";
+import { S as installAllowedToolsGate, _ as inferSource, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, g as getDefaultScanPaths, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, v as parseFrontmatter, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-DPsd0qwm.js";
+export { ActivationVia, ActiveSkill, DeactivationReason, IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillActivationStateOptions, SkillConfig, SkillDiagnostic, SkillResource, SkillSource, SkillValidationIssue, SkillValidationResult, SkillsConfig, SourcedScanPath, buildCatalog, createSkillActivationState, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/skills.js

@@ -1,47 +1,24 @@
-import {
-  defineSkill
-} from "./chunk-JCOB6IYO.js";
-import {
-  IMPLICITLY_ALLOWED_SKILL_TOOLS,
-  buildCatalog,
-  createSkillActivationState,
-  discoverSkills,
-  getDefaultScanPaths,
-  inferSource,
-  installAllowedToolsGate,
-  interpolateShellCommands,
-  isToolAllowedByUnion,
-  matchesAllowedTool,
-  parseAllowedToolPattern,
-  parseFrontmatter,
-  parseSkillFile,
-  resolveSkills,
-  validateResourcePath,
-  validateSkillForWrite,
-  validateSkillName,
-  writeSkillToDisk,
-  writeSkillsToDisk
-} from "./chunk-6STZTA4N.js";
-import "./chunk-LNN5UTS2.js";
-export {
-  IMPLICITLY_ALLOWED_SKILL_TOOLS,
-  buildCatalog,
-  createSkillActivationState,
-  defineSkill,
-  discoverSkills,
-  getDefaultScanPaths,
-  inferSource,
-  installAllowedToolsGate,
-  interpolateShellCommands,
-  isToolAllowedByUnion,
-  matchesAllowedTool,
-  parseAllowedToolPattern,
-  parseFrontmatter,
-  parseSkillFile,
-  resolveSkills,
-  validateResourcePath,
-  validateSkillForWrite,
-  validateSkillName,
-  writeSkillToDisk,
-  writeSkillsToDisk
-};
+import { _ as validateResourcePath, a as discoverSkills, b as createSkillActivationState, c as parseFrontmatter, f as IMPLICITLY_ALLOWED_SKILL_TOOLS, g as parseAllowedToolPattern, h as matchesAllowedTool, i as writeSkillsToDisk, l as parseSkillFile, m as isToolAllowedByUnion, n as resolveSkills, o as getDefaultScanPaths, p as installAllowedToolsGate, r as writeSkillToDisk, s as inferSource, t as interpolateShellCommands, u as buildCatalog, v as validateSkillForWrite, y as validateSkillName } from "./interpolate-CukJwP2G.js";
+//#region src/skills/index.ts
+/**
+* Define an inline skill configuration.
+*
+* Strict-validates at author-time — throws if the config would be rejected by
+* `writeSkillToDisk` or the spec. Source defaults to `'inline'`.
+*/
+function defineSkill(config) {
+	const normalized = {
+		...config,
+		source: config.source ?? "inline"
+	};
+	const result = validateSkillForWrite(normalized);
+	if (!result.valid) {
+		const summary = result.errors.map((e) => `  - [${e.code}] ${e.message}`).join("\n");
+		throw new Error(`Invalid skill "${normalized.name}":\n${summary}`);
+	}
+	return normalized;
+}
+//#endregion
+export { IMPLICITLY_ALLOWED_SKILL_TOOLS, buildCatalog, createSkillActivationState, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };
+
+//# sourceMappingURL=skills.js.map

package/dist/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","names":[],"sources":["../src/skills/index.ts"],"sourcesContent":["import type { SkillConfig } from './types'\nimport { validateSkillForWrite } from './validate'\n\nexport {\n  type ActivationVia,\n  type ActiveSkill,\n  createSkillActivationState,\n  type DeactivationReason,\n  type SkillActivationState,\n  type SkillActivationStateOptions,\n} from './activation'\nexport {\n  IMPLICITLY_ALLOWED_SKILL_TOOLS,\n  installAllowedToolsGate,\n} from './allowed-tools'\nexport { buildCatalog } from './catalog'\nexport {\n  discoverSkills,\n  getDefaultScanPaths,\n  inferSource,\n  parseFrontmatter,\n  parseSkillFile,\n} from './discovery'\nexport type { SourcedScanPath } from './discovery'\nexport { interpolateShellCommands } from './interpolate'\nexport { resolveSkills } from './resolve'\nexport type {\n  SkillConfig,\n  SkillDiagnostic,\n  SkillResource,\n  SkillsConfig,\n  SkillSource,\n} from './types'\nexport {\n  isToolAllowedByUnion,\n  matchesAllowedTool,\n  parseAllowedToolPattern,\n  validateResourcePath,\n  validateSkillForWrite,\n  validateSkillName,\n} from './validate'\nexport type { SkillValidationIssue, SkillValidationResult } from './validate'\nexport { writeSkillsToDisk, writeSkillToDisk } from './writer'\n\n// ---------------------------------------------------------------------------\n// defineSkill helper\n// ---------------------------------------------------------------------------\n\n/**\n * Define an inline skill configuration.\n *\n * Strict-validates at author-time — throws if the config would be rejected by\n * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.\n */\nexport function defineSkill(config: Omit<SkillConfig, 'source'> & { source?: SkillConfig['source'] }): SkillConfig {\n  const normalized: SkillConfig = {\n    ...config,\n    source: config.source ?? 'inline',\n  }\n  const result = validateSkillForWrite(normalized)\n  if (!result.valid) {\n    const summary = result.errors.map(e => `  - [${e.code}] ${e.message}`).join('\\n')\n    throw new Error(`Invalid skill \"${normalized.name}\":\\n${summary}`)\n  }\n  return normalized\n}\n"],"mappings":";;;;;;;;AAsDA,SAAgB,YAAY,QAAuF;CACjH,MAAM,aAA0B;EAC9B,GAAG;EACH,QAAQ,OAAO,UAAU;EAC1B;CACD,MAAM,SAAS,sBAAsB,WAAW;CAChD,IAAI,CAAC,OAAO,OAAO;EACjB,MAAM,UAAU,OAAO,OAAO,KAAI,MAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,UAAU,CAAC,KAAK,KAAK;EACjF,MAAM,IAAI,MAAM,kBAAkB,WAAW,KAAK,MAAM,UAAU;;CAEpE,OAAO"}

package/dist/stats-DoKUtF5T.js

@@ -0,0 +1,58 @@
+//#region src/stats.ts
+/**
+* Depth-first walk over the stats tree, returning every `TurnUsage` entry
+* — parent loop first, then each child subtree in completion order.
+*
+* Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /
+* `cacheCreation` live only on per-turn entries, and the top-level
+* `AgentStats` deliberately doesn't carry cumulative forms (one source of
+* truth, no risk of drift). Anything that needs a tree-wide sum walks
+* through this.
+*/
+function flattenTurns(stats) {
+	const out = [];
+	collectTurns(stats, out);
+	return out;
+}
+function collectTurns(stats, out) {
+	if (stats.turnUsage) out.push(...stats.turnUsage);
+	if (stats.children) for (const child of stats.children) collectTurns(child.stats, out);
+}
+/**
+* Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,
+* output, cache, cost, and turn-count across every turn the tree attributed
+* to that model — naturally handling cross-model runs (vision-fallback,
+* model-shifted subagents, mixed-provider workflows).
+*
+* Turns missing `modelId` (mock providers, providers that don't echo a model
+* id) are bucketed under the literal string `'(unknown)'`.
+*/
+function statsByModel(stats) {
+	const out = /* @__PURE__ */ new Map();
+	for (const turn of flattenTurns(stats)) {
+		const key = turn.modelId ?? "(unknown)";
+		let entry = out.get(key);
+		if (!entry) {
+			entry = {
+				input: 0,
+				output: 0,
+				cost: 0,
+				cacheRead: 0,
+				cacheCreation: 0,
+				turns: 0
+			};
+			out.set(key, entry);
+		}
+		entry.input += turn.input;
+		entry.output += turn.output;
+		entry.cost += turn.cost ?? 0;
+		entry.cacheRead += turn.cacheRead ?? 0;
+		entry.cacheCreation += turn.cacheCreation ?? 0;
+		entry.turns += 1;
+	}
+	return out;
+}
+//#endregion
+export { statsByModel as n, flattenTurns as t };
+
+//# sourceMappingURL=stats-DoKUtF5T.js.map

package/dist/stats-DoKUtF5T.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats-DoKUtF5T.js","names":[],"sources":["../src/stats.ts"],"sourcesContent":["/**\n * Pure derivations over `AgentStats`.\n *\n * Both helpers are tree-shakeable — import only what you need. They never\n * touch agent state, never do I/O, and always operate on the recursive\n * `AgentStats` tree returned by `agent.run()`.\n */\n\nimport type { AgentStats, TurnUsage } from './types'\n\n/**\n * Per-model usage rollup produced by {@link statsByModel}.\n *\n * `turns` counts the number of `TurnUsage` entries attributed to the model\n * across the whole tree (parent loop + every recursively-spawned child).\n * Cache and cost numbers are summed from the same set of turns.\n */\nexport interface ModelUsage {\n  input: number\n  output: number\n  cost: number\n  cacheRead: number\n  cacheCreation: number\n  turns: number\n}\n\n/**\n * Depth-first walk over the stats tree, returning every `TurnUsage` entry\n * — parent loop first, then each child subtree in completion order.\n *\n * Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /\n * `cacheCreation` live only on per-turn entries, and the top-level\n * `AgentStats` deliberately doesn't carry cumulative forms (one source of\n * truth, no risk of drift). Anything that needs a tree-wide sum walks\n * through this.\n */\nexport function flattenTurns(stats: AgentStats): TurnUsage[] {\n  const out: TurnUsage[] = []\n  collectTurns(stats, out)\n  return out\n}\n\nfunction collectTurns(stats: AgentStats, out: TurnUsage[]): void {\n  if (stats.turnUsage)\n    out.push(...stats.turnUsage)\n  if (stats.children) {\n    for (const child of stats.children)\n      collectTurns(child.stats, out)\n  }\n}\n\n/**\n * Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,\n * output, cache, cost, and turn-count across every turn the tree attributed\n * to that model — naturally handling cross-model runs (vision-fallback,\n * model-shifted subagents, mixed-provider workflows).\n *\n * Turns missing `modelId` (mock providers, providers that don't echo a model\n * id) are bucketed under the literal string `'(unknown)'`.\n */\nexport function statsByModel(stats: AgentStats): Map<string, ModelUsage> {\n  const out = new Map<string, ModelUsage>()\n  for (const turn of flattenTurns(stats)) {\n    const key = turn.modelId ?? '(unknown)'\n    let entry = out.get(key)\n    if (!entry) {\n      entry = { input: 0, output: 0, cost: 0, cacheRead: 0, cacheCreation: 0, turns: 0 }\n      out.set(key, entry)\n    }\n    entry.input += turn.input\n    entry.output += turn.output\n    entry.cost += turn.cost ?? 0\n    entry.cacheRead += turn.cacheRead ?? 0\n    entry.cacheCreation += turn.cacheCreation ?? 0\n    entry.turns += 1\n  }\n  return out\n}\n"],"mappings":";;;;;;;;;;;AAoCA,SAAgB,aAAa,OAAgC;CAC3D,MAAM,MAAmB,EAAE;CAC3B,aAAa,OAAO,IAAI;CACxB,OAAO;;AAGT,SAAS,aAAa,OAAmB,KAAwB;CAC/D,IAAI,MAAM,WACR,IAAI,KAAK,GAAG,MAAM,UAAU;CAC9B,IAAI,MAAM,UACR,KAAK,MAAM,SAAS,MAAM,UACxB,aAAa,MAAM,OAAO,IAAI;;;;;;;;;;;AAapC,SAAgB,aAAa,OAA4C;CACvE,MAAM,sBAAM,IAAI,KAAyB;CACzC,KAAK,MAAM,QAAQ,aAAa,MAAM,EAAE;EACtC,MAAM,MAAM,KAAK,WAAW;EAC5B,IAAI,QAAQ,IAAI,IAAI,IAAI;EACxB,IAAI,CAAC,OAAO;GACV,QAAQ;IAAE,OAAO;IAAG,QAAQ;IAAG,MAAM;IAAG,WAAW;IAAG,eAAe;IAAG,OAAO;IAAG;GAClF,IAAI,IAAI,KAAK,MAAM;;EAErB,MAAM,SAAS,KAAK;EACpB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,KAAK,QAAQ;EAC3B,MAAM,aAAa,KAAK,aAAa;EACrC,MAAM,iBAAiB,KAAK,iBAAiB;EAC7C,MAAM,SAAS;;CAEjB,OAAO"}