@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/wire.d.ts

@@ -0,0 +1,42 @@
+import { type KeyEntry, type KeyStore, type Provider } from './host.ts';
+/**
+ * Copilot offers its tools as OpenAI *custom* tools, which the completions API
+ * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
+ * takes them, and only the reasoning models serve it, so the wire API follows
+ * the model rather than being a flag nobody would know to set. Older models are
+ * listed rather than newer ones, so each new generation works without a release.
+ */
+export declare function wireApi(provider: Provider, id: string): string | undefined;
+export interface Wiring {
+    provider: Provider;
+    /** what the model is called on the wire */
+    model: string;
+    /** every `COPILOT_*` name and value, ready to hand to the child */
+    env: Record<string, string>;
+    /** names whose values are secret, for `--secret-env-vars` and for masking */
+    secret: string[];
+    /** anything true but unwelcome: a location that will be slow, a stale default */
+    warnings: string[];
+    /** Claude on Vertex: a loopback relay to start, whose url becomes the base url */
+    relay?: {
+        key: string;
+        project: string;
+        location: string;
+        keyFile: string;
+    };
+}
+/** Where the relay's url goes once it is listening. */
+export declare const RELAY_URL = "http://127.0.0.1:<relay>";
+/**
+ * Turns a zen key entry and a model id into copilot's environment.
+ *
+ * `COPILOT_PROVIDER_BASE_URL` is what activates BYOK at all, so every provider
+ * gets one — including OpenAI, whose url copilot would otherwise have reached
+ * through a GitHub account we are deliberately not using.
+ */
+export declare function wire(store: KeyStore, entry: KeyEntry, id: string): Wiring;
+/** Values a `--dry-run` may print. A key is four characters and an apology. */
+export declare function masked(env: Record<string, string>, secret: readonly string[]): string[];
+/** Non-fatal, said once, because a competing file is a silent override. */
+export declare function providersWarning(): string | undefined;
+//# sourceMappingURL=wire.d.ts.map

package/dist/meta/wire.js

@@ -0,0 +1,129 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { credentialError, envOf, invokedAs, yellow, } from "./host.js";
+const TYPES = {
+    openai: 'openai',
+    anthropic: 'anthropic',
+    google: 'openai',
+    vertex: 'openai',
+    openrouter: 'openai',
+};
+const BASE_URLS = {
+    openai: 'https://api.openai.com/v1',
+    anthropic: 'https://api.anthropic.com',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    openrouter: 'https://openrouter.ai/api/v1',
+};
+/**
+ * Copilot offers its tools as OpenAI *custom* tools, which the completions API
+ * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
+ * takes them, and only the reasoning models serve it, so the wire API follows
+ * the model rather than being a flag nobody would know to set. Older models are
+ * listed rather than newer ones, so each new generation works without a release.
+ */
+export function wireApi(provider, id) {
+    return provider === 'openai' && !/^(gpt-4|gpt-3\.5|chatgpt-)/.test(id)
+        ? 'responses'
+        : undefined;
+}
+/** Where the relay's url goes once it is listening. */
+export const RELAY_URL = 'http://127.0.0.1:<relay>';
+const vertexClaude = (id) => /^(anthropic\/)?claude-/.test(id);
+/**
+ * Turns a zen key entry and a model id into copilot's environment.
+ *
+ * `COPILOT_PROVIDER_BASE_URL` is what activates BYOK at all, so every provider
+ * gets one — including OpenAI, whose url copilot would otherwise have reached
+ * through a GitHub account we are deliberately not using.
+ */
+export function wire(store, entry, id) {
+    const provider = entry.provider;
+    const env = {};
+    const secret = [];
+    const warnings = [];
+    env.COPILOT_PROVIDER_TYPE = TYPES[provider];
+    env.COPILOT_MODEL = id;
+    if (provider === 'vertex' && vertexClaude(id)) {
+        const project = store.projectOf(entry)?.id;
+        if (entry.holds !== 'file' || !project) {
+            throw credentialError(`Claude on vertex needs a service account and a GCP project, not ${entry.provider}/${entry.name}`, 'add one: zen key add vertex --project <id>');
+        }
+        const model = id.replace(/^anthropic\//, '');
+        const key = randomBytes(24).toString('hex');
+        env.COPILOT_PROVIDER_TYPE = 'anthropic';
+        env.COPILOT_MODEL = model;
+        env.COPILOT_PROVIDER_BASE_URL = RELAY_URL;
+        env.COPILOT_PROVIDER_API_KEY = key;
+        return {
+            provider,
+            model,
+            env,
+            secret: ['COPILOT_PROVIDER_API_KEY'],
+            warnings,
+            relay: {
+                key,
+                project,
+                location: entry.location?.trim() || 'global',
+                keyFile: store.fileOf(entry),
+            },
+        };
+    }
+    if (provider === 'vertex') {
+        const project = store.projectOf(entry)?.id;
+        if (!project) {
+            throw credentialError(`no GCP project on ${entry.provider}/${entry.name}`, 'set one: zen key add vertex --project <id>');
+        }
+        const named = entry.location?.trim() || 'global';
+        const partner = id.includes('/') && !id.startsWith('google/');
+        // Gemini serves the `us`/`eu` multi-regions; partner models answer them with a 404 or 429.
+        const location = partner && (named === 'us' || named === 'eu') ? 'global' : named;
+        if (location === 'global' && !partner) {
+            warnings.push('location `global` adds about ten seconds of cold start');
+        }
+        env.COPILOT_PROVIDER_BASE_URL = `https://aiplatform.googleapis.com/v1/projects/${project}/locations/${location}/endpoints/openapi`;
+        // Vertex speaks publisher names on the wire and knows nothing of zen's
+        // provider prefix; the bare id stays as the model *id* so copilot can
+        // still match its catalogue for token limits and tool support.
+        env.COPILOT_PROVIDER_WIRE_MODEL = id.includes('/') ? id : `google/${id}`;
+        // Only Google's own ids are bare: `gpt-oss-…` would get GPT's custom `apply_patch`, which this endpoint rejects.
+        env.COPILOT_PROVIDER_MODEL_ID = id.startsWith('google/') ? id.slice('google/'.length) : id;
+    }
+    else {
+        const url = BASE_URLS[provider];
+        if (!url) {
+            throw credentialError(`no BYOK endpoint known for ${provider}`);
+        }
+        env.COPILOT_PROVIDER_BASE_URL = url;
+    }
+    const api = wireApi(provider, id);
+    if (api) {
+        env.COPILOT_PROVIDER_WIRE_API = api;
+    }
+    if (entry.holds === 'file') {
+        // A Google access token is good for an hour and a session is not, so
+        // copilot is told how to mint one rather than handed one that will be
+        // stale by the time it matters.
+        env.COPILOT_PROVIDER_API_KEY_COMMAND = `${invokedAs('zen')} key token ${entry.provider}`;
+        env[envOf(entry)] = store.fileOf(entry);
+    }
+    else {
+        env.COPILOT_PROVIDER_API_KEY = store.reveal(entry);
+        secret.push('COPILOT_PROVIDER_API_KEY');
+    }
+    return { provider, model: env.COPILOT_PROVIDER_WIRE_MODEL ?? id, env, secret, warnings };
+}
+/** Values a `--dry-run` may print. A key is four characters and an apology. */
+export function masked(env, secret) {
+    return Object.entries(env)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, value]) => `${name}=${secret.includes(name) ? '••••' : value}`);
+}
+/** Non-fatal, said once, because a competing file is a silent override. */
+export function providersWarning() {
+    const configured = process.env.COPILOT_PROVIDERS_CONFIG;
+    const path = configured ?? `${process.env.HOME ?? ''}/.copilot/providers.json`;
+    return existsSync(path)
+        ? yellow(`${path} may override the provider zen just wired`)
+        : undefined;
+}
+//# sourceMappingURL=wire.js.map

package/dist/meta.d.ts

@@ -1,3 +1,4 @@
+import type { ModelUsage, TokenUsage } from '@zenera/neo';
 import { spawn as nodeSpawn } from 'node:child_process';
 import { type KeyEntry, type KeyStore, type Provider } from './keys.ts';
 export declare const PROMPT_DIR = ".github/prompts";
@@ -60,7 +61,8 @@ export declare function misspelledProvider(ref: string): Provider | undefined;
  * Copilot offers its tools as OpenAI *custom* tools, which the completions API
  * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
  * takes them, and only the reasoning models serve it, so the wire API follows
- * the model rather than being a flag nobody would know to set.
+ * the model rather than being a flag nobody would know to set. Older models are
+ * listed rather than newer ones, so each new generation works without a release.
  */
 export declare function wireApi(provider: Provider, id: string): string | undefined;
 export interface Wiring {
@@ -195,6 +197,18 @@ export interface Log {
 }
 /** `<project>/.tmp/logs/meta.<when>.log`, opened for append. */
 export declare function openLog(dir: string, now?: Date): Log;
+/**
+ * Every meta session the project ran and how it ended, so `zen meta resume`
+ * needs no id. `running` is never overwritten by a run that was killed, so it
+ * reads the same as `failed`: not finished.
+ */
+export type SessionState = 'running' | 'done' | 'failed';
+export declare function recordSession(dir: string, id: string, state: SessionState): void;
+/**
+ * The newest session that did not finish, else the newest of all. A quick
+ * question asked after a long run stopped must not stand in for it.
+ */
+export declare function lastSession(dir: string): string | undefined;
 /**
  * Folds one event into the outcome and says what, if anything, to show for it.
  *
@@ -211,10 +225,66 @@ export interface Launch {
     sink?: Sink;
     log?: Log;
     width?: number;
+    /** said after the elapsed time on the status row, e.g. the tokens so far */
+    status?: () => string;
     /** injected by the tests, which have no copilot and want none */
     spawn?: typeof nodeSpawn;
 }
 export declare function launch(opts: Launch): Promise<Outcome>;
+/** Resumes after copilot's own retries run out; `--retries` overrides. */
+export declare const DEFAULT_RESUMES = 5;
+/** What the resumed session is told, since `-p` has to say something. */
+export declare const RESUME_PROMPT = "The previous model call failed. Continue the task from where you stopped.";
+export declare function resumeDelayMs(attempt: number): number;
+/**
+ * Why the run is worth resuming, or undefined when waiting cannot help.
+ *
+ * Only a refusal that time can cure counts: a rate limit, the provider's own
+ * failure, a connection that timed out. A 400 or a bad key fails the same way
+ * however often it is sent - except the one below.
+ */
+export declare function transient(out: Outcome): string | undefined;
+export interface MetaCall {
+    model: string;
+    usage: TokenUsage;
+    cacheWriteTokens?: number;
+    startedAt: string;
+    durationMs: number;
+    session?: string;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * One line of the span file, as a model call - anything else is undefined.
+ * Only counts are read off it: whatever else a span may carry, none of it
+ * reaches the ledger.
+ */
+export declare function readSpan(line: string): MetaCall | undefined;
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export declare function splitLines(carry: string, chunk: string): {
+    lines: string[];
+    carry: string;
+};
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export declare function tailSpans(path: string, onCall: (call: MetaCall) => void, everyMs?: number): {
+    stop: () => void;
+};
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export declare class Tally {
+    calls: number;
+    usage: TokenUsage;
+    add(call: MetaCall): void;
+    toString(): string;
+}
+/** 950, 12.3k, 1.8M. */
+export declare function compact(n: number): string;
+/**
+ * Copilot's own per-model totals from the last `session.shutdown` in a session's
+ * events - cumulative over every resume of it. Reasoning folded into output,
+ * as everywhere in zen.
+ */
+export declare function shutdownModels(events: string): ModelUsage[] | undefined;
+export declare function sessionTotals(sessionId: string): ModelUsage[] | undefined;
 /** Non-fatal, said once, because a competing file is a silent override. */
 export declare function providersWarning(): string | undefined;
 export {};

package/dist/meta.js

@@ -1,10 +1,13 @@
 import { spawn as nodeSpawn } from 'node:child_process';
-import { createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { appendFileSync, closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync, } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { invokedAs } from "./args.js";
 import { paths, readJson, writeJson } from "./home.js";
 import { envOf } from "./keys.js";
+import { duration } from "./narrate.js";
 import { credentialError, cut, cyan, dim, note, pad, plain, red, styled, usageError, write, yellow, } from "./term.js";
 import { formatInline, formatMarkdown } from "./tui/markdown.js";
 import { boxWidth } from "./tui/wrap.js";
@@ -174,10 +177,13 @@ const BASE_URLS = {
  * Copilot offers its tools as OpenAI *custom* tools, which the completions API
  * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
  * takes them, and only the reasoning models serve it, so the wire API follows
- * the model rather than being a flag nobody would know to set.
+ * the model rather than being a flag nobody would know to set. Older models are
+ * listed rather than newer ones, so each new generation works without a release.
  */
 export function wireApi(provider, id) {
-    return provider === 'openai' && /^(gpt-5|o[34])/.test(id) ? 'responses' : undefined;
+    return provider === 'openai' && !/^(gpt-4|gpt-3\.5|chatgpt-)/.test(id)
+        ? 'responses'
+        : undefined;
 }
 /**
  * Turns a zen key entry and a model id into copilot's environment.
@@ -529,6 +535,41 @@ export function openLog(dir, now = new Date()) {
         },
     };
 }
+const sessionLog = (dir) => `${dir}/.tmp/logs/meta.sessions`;
+/** The single-id file older versions wrote. */
+const legacySession = (dir) => `${dir}/.tmp/logs/meta.session`;
+export function recordSession(dir, id, state) {
+    mkdirSync(`${dir}/.tmp/logs`, { recursive: true });
+    appendFileSync(sessionLog(dir), `${new Date().toISOString()}\t${id}\t${state}\n`);
+}
+/**
+ * The newest session that did not finish, else the newest of all. A quick
+ * question asked after a long run stopped must not stand in for it.
+ */
+export function lastSession(dir) {
+    let text;
+    try {
+        text = readFileSync(sessionLog(dir), 'utf8');
+    }
+    catch {
+        try {
+            return readFileSync(legacySession(dir), 'utf8').trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const latest = new Map();
+    for (const line of text.split('\n')) {
+        const [, id, state] = line.split('\t');
+        if (id && state) {
+            latest.delete(id);
+            latest.set(id, state);
+        }
+    }
+    const newestFirst = [...latest].reverse();
+    return (newestFirst.find(([, state]) => state !== 'done') ?? newestFirst[0])?.[0];
+}
 /** Everything the sink is told, kept by the log too — and the detail only there. */
 function tee(sink, log) {
     return {
@@ -630,8 +671,8 @@ export async function launch(opts) {
     // after the model line is indistinguishable from a hang.
     const began = Date.now();
     const beat = setInterval(() => {
-        const seconds = Math.round((Date.now() - began) / 1000);
-        sink.status?.(`working: ${seconds}s`);
+        const extra = opts.status?.();
+        sink.status?.(`working: ${duration(Date.now() - began)}${extra ? ` · ${extra}` : ''}`);
     }, FRAME_MS);
     beat.unref();
     child.stderr?.on('data', (chunk) => {
@@ -658,7 +699,7 @@ export async function launch(opts) {
             absorb(event, out, sink, width);
         }
         const code = await new Promise((resolve) => {
-            child.on('close', (value) => resolve(value ?? 0));
+            child.on('close', (value, signal) => resolve(value ?? (signal ? 1 : 0)));
         });
         if (out.exitCode === 0 && code !== 0) {
             out.exitCode = code;
@@ -673,6 +714,262 @@ export async function launch(opts) {
     }
     return out;
 }
+// ---------------------------------------------------------------------------
+// Resuming
+//
+// Copilot retries a failed model call itself, five times over about a minute,
+// and has no setting to change that. A run that outlasts it is still a session
+// on disk, so the retry happens one level up: wait, then resume that session.
+// ---------------------------------------------------------------------------
+/** Resumes after copilot's own retries run out; `--retries` overrides. */
+export const DEFAULT_RESUMES = 5;
+/** The first wait; it doubles per resume, up to `RESUME_MAX_MS`. */
+const RESUME_INITIAL_MS = 30_000;
+const RESUME_MAX_MS = 300_000;
+/** What the resumed session is told, since `-p` has to say something. */
+export const RESUME_PROMPT = 'The previous model call failed. Continue the task from where you stopped.';
+export function resumeDelayMs(attempt) {
+    return Math.min(RESUME_INITIAL_MS * 2 ** attempt, RESUME_MAX_MS);
+}
+/**
+ * Why the run is worth resuming, or undefined when waiting cannot help.
+ *
+ * Only a refusal that time can cure counts: a rate limit, the provider's own
+ * failure, a connection that timed out. A 400 or a bad key fails the same way
+ * however often it is sent - except the one below.
+ */
+export function transient(out) {
+    if (out.exitCode === 0 || !out.sessionId) {
+        return undefined;
+    }
+    const at = out.events.findLastIndex((e) => e.type === 'session.error');
+    const data = out.events[at]?.data;
+    if (!data) {
+        return undefined;
+    }
+    const status = Number(data.statusCode ?? 0);
+    if (data.errorType === 'rate_limit' || status === 429) {
+        return 'rate-limited (429)';
+    }
+    if (status === 408 || status >= 500) {
+        return `the provider failed (${status})`;
+    }
+    if (/timed out|connection error|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up/i.test(String(data.message ?? ''))) {
+        return 'the connection failed';
+    }
+    if (status === 400 && injected(out.events.slice(0, at))) {
+        return 'refused a tool call copilot made itself (400)';
+    }
+    return undefined;
+}
+/**
+ * Whether the turn that failed began with a tool call copilot wrote, not the
+ * model. When a background command finishes, copilot adds a `read_bash` of its
+ * own; Gemini 3 rejects any tool call in the current turn that lacks its thought
+ * signature, so that request is a 400 every time. A new user message - the
+ * resume - starts a turn that no longer holds it.
+ */
+function injected(before) {
+    for (let i = before.length - 1; i >= 0; i--) {
+        const event = before[i];
+        if (event.type === 'system.notification') {
+            return true;
+        }
+        if (event.type === 'user.message') {
+            return false;
+        }
+        if (event.type === 'assistant.message') {
+            if (event.data?.model) {
+                return false;
+            }
+            const requests = event.data?.toolRequests;
+            if (Array.isArray(requests) && requests.length > 0) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** An OTel time: `[seconds, nanoseconds]` in this exporter; epoch ms either way. */
+function epochMs(t) {
+    if (Array.isArray(t) && typeof t[0] === 'number') {
+        return t[0] * 1000 + Number(t[1] ?? 0) / 1e6;
+    }
+    if (typeof t === 'number') {
+        return t;
+    }
+    return typeof t === 'string' ? Date.parse(t) : undefined;
+}
+/**
+ * One line of the span file, as a model call - anything else is undefined.
+ * Only counts are read off it: whatever else a span may carry, none of it
+ * reaches the ledger.
+ */
+export function readSpan(line) {
+    let span;
+    try {
+        span = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const attrs = (span.attributes ?? {});
+    if (span.type !== 'span' || attrs['gen_ai.operation.name'] !== 'chat') {
+        return undefined;
+    }
+    const num = (key) => Number(attrs[key] ?? 0) || 0;
+    const start = epochMs(span.startTime) ?? 0;
+    const end = epochMs(span.endTime) ?? start;
+    // Copilot counts reasoning beside the output; zen counts it inside.
+    const reasoning = num('gen_ai.usage.reasoning.output_tokens');
+    const cacheWrite = num('gen_ai.usage.cache_creation.input_tokens') ||
+        num('gen_ai.usage.cache_creation_input_tokens');
+    return {
+        model: String(attrs['gen_ai.response.model'] ?? attrs['gen_ai.request.model'] ?? '?'),
+        usage: {
+            inputTokens: num('gen_ai.usage.input_tokens'),
+            cachedInputTokens: num('gen_ai.usage.cache_read.input_tokens') ||
+                num('gen_ai.usage.cache_read_input_tokens'),
+            outputTokens: num('gen_ai.usage.output_tokens') + reasoning,
+            reasoningTokens: reasoning,
+        },
+        ...(cacheWrite ? { cacheWriteTokens: cacheWrite } : {}),
+        startedAt: new Date(start).toISOString(),
+        durationMs: Math.max(0, Math.round(end - start)),
+        session: typeof attrs['gen_ai.conversation.id'] === 'string'
+            ? attrs['gen_ai.conversation.id']
+            : undefined,
+        traceId: typeof span.traceId === 'string' ? span.traceId : undefined,
+        spanId: typeof span.spanId === 'string' ? span.spanId : undefined,
+    };
+}
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export function splitLines(carry, chunk) {
+    const parts = `${carry}${chunk}`.split('\n');
+    const rest = parts.pop() ?? '';
+    return { lines: parts.filter((l) => l.trim()), carry: rest };
+}
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export function tailSpans(path, onCall, everyMs = 1000) {
+    let offset = 0;
+    let carry = '';
+    const poll = () => {
+        let fd;
+        try {
+            const size = statSync(path).size;
+            if (size <= offset) {
+                return;
+            }
+            fd = openSync(path, 'r');
+            const buf = Buffer.alloc(size - offset);
+            readSync(fd, buf, 0, buf.length, offset);
+            offset = size;
+            const split = splitLines(carry, buf.toString('utf8'));
+            carry = split.carry;
+            for (const line of split.lines) {
+                const call = readSpan(line);
+                if (call) {
+                    onCall(call);
+                }
+            }
+        }
+        catch {
+            // Not there yet: copilot creates it at the first span.
+        }
+        finally {
+            if (fd !== undefined) {
+                closeSync(fd);
+            }
+        }
+    };
+    const timer = setInterval(poll, everyMs);
+    timer.unref();
+    return {
+        stop: () => {
+            clearInterval(timer);
+            poll();
+        },
+    };
+}
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export class Tally {
+    calls = 0;
+    usage = {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+    };
+    add(call) {
+        this.calls += 1;
+        this.usage = {
+            inputTokens: this.usage.inputTokens + call.usage.inputTokens,
+            cachedInputTokens: this.usage.cachedInputTokens + call.usage.cachedInputTokens,
+            outputTokens: this.usage.outputTokens + call.usage.outputTokens,
+            reasoningTokens: this.usage.reasoningTokens + call.usage.reasoningTokens,
+        };
+    }
+    toString() {
+        const u = this.usage;
+        const cached = u.cachedInputTokens ? ` (${compact(u.cachedInputTokens)} cached)` : '';
+        return (`${this.calls} call${this.calls === 1 ? '' : 's'} · ${compact(u.inputTokens)} in${cached}` +
+            ` · ${compact(u.outputTokens)} out`);
+    }
+}
+/** 950, 12.3k, 1.8M. */
+export function compact(n) {
+    if (n < 1000) {
+        return String(n);
+    }
+    if (n < 1e6) {
+        return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+    }
+    return `${(n / 1e6).toFixed(n < 1e7 ? 2 : 1)}M`;
+}
+/**
+ * Copilot's own per-model totals from the last `session.shutdown` in a session's
+ * events - cumulative over every resume of it. Reasoning folded into output,
+ * as everywhere in zen.
+ */
+export function shutdownModels(events) {
+    const line = events
+        .split('\n')
+        .reverse()
+        .find((l) => l.includes('"session.shutdown"'));
+    if (!line) {
+        return undefined;
+    }
+    let metrics;
+    try {
+        metrics = JSON.parse(line).data?.modelMetrics ?? {};
+    }
+    catch {
+        return undefined;
+    }
+    return Object.entries(metrics).map(([model, m]) => {
+        const u = m.usage ?? {};
+        const reasoning = Number(u.reasoningTokens ?? 0);
+        return {
+            model,
+            calls: Number(m.requests?.count ?? 0),
+            usage: {
+                inputTokens: Number(u.inputTokens ?? 0),
+                cachedInputTokens: Number(u.cacheReadTokens ?? 0),
+                outputTokens: Number(u.outputTokens ?? 0) + reasoning,
+                reasoningTokens: reasoning,
+            },
+        };
+    });
+}
+export function sessionTotals(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    try {
+        return shutdownModels(readFileSync(join(home, 'session-state', sessionId, 'events.jsonl'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Non-fatal, said once, because a competing file is a silent override. */
 export function providersWarning() {
     const configured = process.env.COPILOT_PROVIDERS_CONFIG;

package/dist/modelref.d.ts

@@ -0,0 +1,16 @@
+import type { Provider } from './keys.ts';
+export declare const PROVIDER_NAMES: ReadonlySet<string>;
+/**
+ * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider
+ * counts as a prefix, because `google/gemini-3.8-flash` is also a perfectly good
+ * bare id on an endpoint that speaks publisher names.
+ *
+ * The colon form is the library's own — `openai:gpt-5.6-sol`, and with an api
+ * selector `openai/responses:gpt-5.6-sol` — which is what arrives when the ref
+ * came from `agents.yaml`.
+ */
+export declare function splitRef(ref: string): {
+    provider?: Provider;
+    id: string;
+};
+//# sourceMappingURL=modelref.d.ts.map

package/dist/modelref.js

@@ -0,0 +1,41 @@
+// ---------------------------------------------------------------------------
+// Model refs as people type them
+//
+// `vertex/gemini-3.8-flash` from a person, `openai:gpt-5.6-sol` from
+// `agents.yaml`. Read by `zen inspect ask` and by `zen meta`, so it lives with
+// neither.
+// ---------------------------------------------------------------------------
+export const PROVIDER_NAMES = new Set([
+    'openai',
+    'anthropic',
+    'google',
+    'vertex',
+    'openrouter',
+]);
+/**
+ * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider
+ * counts as a prefix, because `google/gemini-3.8-flash` is also a perfectly good
+ * bare id on an endpoint that speaks publisher names.
+ *
+ * The colon form is the library's own — `openai:gpt-5.6-sol`, and with an api
+ * selector `openai/responses:gpt-5.6-sol` — which is what arrives when the ref
+ * came from `agents.yaml`.
+ */
+export function splitRef(ref) {
+    const colon = ref.indexOf(':');
+    if (colon > 0) {
+        const head = ref.slice(0, colon).split('/')[0];
+        if (PROVIDER_NAMES.has(head)) {
+            return { provider: head, id: ref.slice(colon + 1) };
+        }
+    }
+    const slash = ref.indexOf('/');
+    if (slash < 0) {
+        return { id: ref };
+    }
+    const head = ref.slice(0, slash);
+    return PROVIDER_NAMES.has(head)
+        ? { provider: head, id: ref.slice(slash + 1) }
+        : { id: ref };
+}
+//# sourceMappingURL=modelref.js.map