@zenera/cli 1.1.25 → 1.1.26

package/dist/meta/finetune/sampler.js

@@ -29,13 +29,19 @@ export function resultOf(t, c) {
     return r;
 }
 export function nextCase(t) {
+    if (t.more !== undefined && t.tried.size >= t.more) {
+        return undefined;
+    }
     return selection(t).find((c) => {
         if (t.claimed.has(c.id)) {
             return false;
         }
         const r = resultOf(t, c);
-        // Once per start: a sandbox that is down would only fail it again at once.
-        return !r || (r.state === 'failed' && !t.tried.has(c.id));
+        if (r) {
+            // Once per start: a sandbox that is down would only fail it again at once.
+            return r.state === 'failed' && !t.tried.has(c.id);
+        }
+        return true;
     });
 }
 //# sourceMappingURL=sampler.js.map

package/dist/meta/finetune/train.d.ts

@@ -24,14 +24,18 @@ export interface Run {
     tokens?: ByModel;
     metrics?: RunMetrics;
     durationMs?: number;
+    /** skills an apply made for this case that the run never loaded */
+    missedSkills?: string[];
 }
 export declare class VoidRun extends StepError {
 }
 /** The container engine failed: every run after this one would fail the same way. */
 export declare class SandboxDown extends StepError {
 }
-/** The case keeps one analyze session per revision, so each analysis remembers the last. */
-export declare function sessionOf(t: Tuning, c: Case): string | undefined;
+/** One `zen run`. Writes run.json, or says why the run was void. */
+export declare function runOnce(t: Tuning, c: Case, dir: string, memory?: string, expect?: string[]): Promise<string | undefined>;
+/** The meta agent's answer is the human report: kept as analysis.md beside the feedback. A retry keeps its own envelope, so its tokens are counted too. */
+export declare function keepAnalysis(dir: string, stdout: string, replace?: boolean): void;
 export declare function markCompleted(t: Tuning, c: Case): void;
 export declare function markDifficult(t: Tuning, c: Case, phase: Phase, reason: string): void;
 /** Something outside the prose broke. The case keeps its tries and runs again at the next start. */

package/dist/meta/finetune/train.js

@@ -4,11 +4,12 @@ import { hostname } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { EXIT } from "../host.js";
 import { sessionKept } from "../tokens.js";
+import { writeAnalyzeBrief } from "./analyze-brief.js";
 import { batchInput } from "./dataset/export.js";
 import { DatasetStore } from "./dataset/store.js";
 import { errorIn, sizeOf, StepError } from "./failure.js";
-import { readFeedback } from "./feedback.js";
-import { caseTokens, writeFeedback } from "./report.js";
+import { feedbackId, forDataset, forProse, lead, readFeedback, } from "./feedback.js";
+import { attemptsOf, caseTokens, rubricScore, writeFeedback } from "./report.js";
 import { readJson } from "./tuning.js";
 import { envelopesIn, runMetrics, spent, tokensOf, } from "./usage.js";
 // ---------------------------------------------------------------------------
@@ -27,8 +28,15 @@ export async function train(t, s, c) {
             passed = run;
             break;
         }
+        const rubricOnly = datasetOnly(feedback);
+        if (rubricOnly) {
+            return markDifficult(t, c, 'nomem', rubricOnly);
+        }
         if (attempt < t.config.tries) {
-            await t.improvements.apply(feedback, s);
+            const { structural } = await t.improvements.apply(feedback, s);
+            if (structural) {
+                return markDifficult(t, c, 'nomem', `structural: ${structural}`);
+            }
         }
     }
     if (!passed) {
@@ -42,8 +50,15 @@ export async function train(t, s, c) {
             t.memories.submit(c, attempt, run);
             break;
         }
+        const rubricOnly = datasetOnly(feedback);
+        if (rubricOnly) {
+            return markDifficult(t, c, 'mem', rubricOnly);
+        }
         if (attempt < t.config.memTries) {
-            await t.improvements.apply(feedback, s);
+            const { structural } = await t.improvements.apply(feedback, s);
+            if (structural) {
+                return markDifficult(t, c, 'mem', `structural: ${structural}`);
+            }
         }
     }
     if (!cheaper) {
@@ -51,6 +66,14 @@ export async function train(t, s, c) {
     }
     markCompleted(t, c);
 }
+/** Not done, and every finding is about the case itself: another try on the same prose learns nothing. */
+function datasetOnly(f) {
+    const dataset = f.improvements.filter(forDataset);
+    if (dataset.length === 0 || forProse(f).length > 0) {
+        return undefined;
+    }
+    return `specification: ${dataset.map((i) => lead(i.change)).join('; ')}`;
+}
 /** A run its analysis finds void is set aside and run again: it says nothing about the prose. */
 async function tryOnce(t, s, c, phase, attempt, memory) {
     for (let voids = 1;; voids++) {
@@ -97,8 +120,12 @@ async function zenRun(t, s, c, phase, attempt, memory) {
         t.at(s, phase, attempt, 'run');
         t.improvements.runs++;
         const began = Date.now();
+        // The skills the apply after the last try made for this case: this run should load them.
+        const expect = attempt > 1
+            ? t.improvements.skillsFor(feedbackId(c.id, phase, attempt - 1, t.round(c)))
+            : [];
         try {
-            const why = await t.journal.step({ kind: 'run', dir }, () => runOnce(t, c, dir, memory));
+            const why = await t.journal.step({ kind: 'run', dir }, () => runOnce(t, c, dir, memory, expect));
             const ran = why ? undefined : readJson(file);
             t.ended(s, {
                 what: why ? 'void' : 'ran',
@@ -116,7 +143,7 @@ async function zenRun(t, s, c, phase, attempt, memory) {
     return readJson(file);
 }
 /** One `zen run`. Writes run.json, or says why the run was void. */
-async function runOnce(t, c, dir, memory) {
+export async function runOnce(t, c, dir, memory, expect = []) {
     mkdirSync(dir, { recursive: true });
     const mem = join(dir, 'memory');
     rmSync(mem, { recursive: true, force: true });
@@ -180,6 +207,7 @@ async function runOnce(t, c, dir, memory) {
     if (metrics?.sandbox) {
         throw new SandboxDown(metrics.sandbox, join(runDir, 'graph.mmd'));
     }
+    const missed = expect.filter((name) => !metrics?.skills.includes(name));
     const run = {
         dir: runDir,
         memory: mem,
@@ -192,6 +220,7 @@ async function runOnce(t, c, dir, memory) {
         ...(meta?.usage ? { usage: meta.usage } : {}),
         ...(metrics ? { tokens: tokensOf(metrics), metrics } : {}),
         ...(meta?.durationMs !== undefined ? { durationMs: meta.durationMs } : {}),
+        ...(missed.length > 0 ? { missedSkills: missed } : {}),
     };
     writeFileSync(join(dir, 'run.json'), `${JSON.stringify(run, null, 2)}\n`);
     return undefined;
@@ -199,11 +228,7 @@ async function runOnce(t, c, dir, memory) {
 // ---------------------------------------------------------------------------
 // zen meta run /analyze
 // ---------------------------------------------------------------------------
-/** The case keeps one analyze session per revision, so each analysis remembers the last. */
-export function sessionOf(t, c) {
-    const file = join(t.caseDir(c), 'session');
-    return existsSync(file) ? readFileSync(file, 'utf8').trim() || undefined : undefined;
-}
+/** One analyze session per try, kept in its folder: the brief carries the earlier tries. */
 async function analyze(t, s, c, phase, attempt, run) {
     const dir = t.attemptDir(c, phase, attempt);
     const file = join(dir, 'feedback.json');
@@ -225,7 +250,7 @@ async function analyze(t, s, c, phase, attempt, run) {
             attempt,
             result: feedback.verdict === 'void'
                 ? `void: ${feedback.infra}`
-                : `${feedback.verdict}${graded.length ? ` ${graded.filter((g) => g === 'pass').length}/${graded.length}` : ''}${feedback.done ? ', done' : ''}`,
+                : `${feedback.verdict}${graded.length ? ` ${rubricScore(feedback)}` : ''}${feedback.done ? ', done' : ''}`,
             took: Date.now() - began,
             tokens: spent(envelopesIn(dir, 'analyze')),
         });
@@ -241,12 +266,18 @@ async function analyze(t, s, c, phase, attempt, run) {
 async function analyzeOnce(t, s, c, phase, attempt, run, file) {
     const dir = dirname(file);
     const known = t.known(c, phase, attempt);
-    let session = sessionOf(t, c);
-    if (!session) {
-        session = randomUUID();
-        mkdirSync(t.caseDir(c), { recursive: true });
-        writeFileSync(join(t.caseDir(c), 'session'), `${session}\n`);
-    }
+    let session = randomUUID();
+    writeFileSync(join(dir, 'session'), `${session}\n`);
+    const all = attemptsOf(t, c);
+    const at = all.findIndex((a) => a.phase === phase && a.attempt === attempt);
+    const brief = await writeAnalyzeBrief(t, dir, {
+        run,
+        case: c,
+        phase,
+        attempt,
+        earlier: at >= 0 ? all.slice(0, at) : all,
+        ...(run.missedSkills?.length ? { missed: run.missedSkills } : {}),
+    });
     const hash = t.system.hash();
     const applies = t.improvements.started;
     const events = join(dir, 'analyze.events.jsonl');
@@ -264,6 +295,8 @@ async function analyzeOnce(t, s, c, phase, attempt, run, file) {
     const from = sizeOf(log);
     const res = await t.zen([
         ...continuing(),
+        '--prompt-file',
+        brief,
         '/analyze',
         run.dir,
         `case=${c.id}`,
@@ -271,13 +304,14 @@ async function analyzeOnce(t, s, c, phase, attempt, run, file) {
         `phase=${phase}`,
         `attempt=${attempt}`,
         `feedback=${file}`,
+        ...(run.missedSkills?.length ? [`missed-skills=${run.missedSkills.join(',')}`] : []),
     ], log);
     keepAnalysis(dir, res.stdout);
     // `zen meta run` starts a new session when the meta model changed since this one; follow it.
     const started = sessionIn(res.stdout);
     if (started && started !== session) {
         session = started;
-        writeFileSync(join(t.caseDir(c), 'session'), `${session}\n`);
+        writeFileSync(join(dir, 'session'), `${session}\n`);
     }
     const rubricIds = c.rubric.map((r) => r.id);
     let read = readFeedback(file, known, rubricIds);
@@ -319,7 +353,7 @@ function sessionIn(stdout) {
     }
 }
 /** The meta agent's answer is the human report: kept as analysis.md beside the feedback. A retry keeps its own envelope, so its tokens are counted too. */
-function keepAnalysis(dir, stdout, replace = true) {
+export function keepAnalysis(dir, stdout, replace = true) {
     let envelope;
     try {
         envelope = JSON.parse(stdout);
@@ -345,7 +379,7 @@ function note(t, c, f, run, session) {
         run: run.dir,
         verdict: f.verdict,
         ...(Object.keys(rubric).length > 0 ? { rubric } : {}),
-        text: f.verdict === 'void' ? `void: ${f.infra}` : f.summary || f.verdict,
+        text: f.verdict === 'void' ? `void: ${f.infra}` : lead(f.summary) || f.verdict,
         by: { session, prompt: 'analyze', host: hostname() },
     });
 }

package/dist/meta/finetune/tui.d.ts

@@ -8,9 +8,9 @@ export interface Part {
 }
 export type Line = Part[];
 /** The overview: under way, tokens, log - as many log rows as the height leaves. */
-export declare function mainLines(s: Snapshot, selected: number, width: number, height: number, theme: Theme): Line[];
+export declare function mainLines(s: Snapshot, selected: number, width: number, height: number, theme: Theme, url?: string): Line[];
 /** One step's agent, line by line as it works. */
-export declare function followLines(s: Snapshot, key: string, width: number, height: number, theme: Theme): Line[];
+export declare function followLines(s: Snapshot, key: string, width: number, height: number, theme: Theme, url?: string): Line[];
 /** Draws the tuning until the returned function is called. */
-export declare function watch(t: Tuning, interrupt: () => void): Promise<() => void>;
+export declare function watch(t: Tuning, interrupt: () => void, url?: string): Promise<() => void>;
 //# sourceMappingURL=tui.d.ts.map

package/dist/meta/finetune/tui.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, render, Text, useInput, useWindowSize } from 'ink';
+import { spawn } from 'node:child_process';
 import React, { useEffect, useState } from 'react';
 import { resolveTheme } from "../host.js";
 import { since } from "./report.js";
@@ -21,16 +22,28 @@ function footer(width, keys, theme) {
         [{ text: keys, color: theme.chrome.color }],
     ];
 }
-function keysFor(s, following) {
+function keysFor(s, following, url) {
     if (s.state === 'stopping') {
         return 'stopping: the steps under way finish first · ctrl-c again kills them';
     }
     if (s.state !== 'running') {
         return s.state;
     }
+    const open = url ? 'o open in browser · ' : '';
     return following
-        ? 'esc back · s stop · ctrl-c stop, twice kills'
-        : 'up/down choose · enter follow · s stop · ctrl-c stop, twice kills';
+        ? `esc back · ${open}s stop · ctrl-c stop, twice kills`
+        : `up/down choose · enter follow · ${open}s stop · ctrl-c stop, twice kills`;
+}
+/** The platform opener, without a shell, so the address stays one argument. */
+function openInBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'explorer'
+            : 'xdg-open';
+    spawn(command, [url], { stdio: 'ignore', detached: true })
+        .on('error', () => { })
+        .unref();
 }
 function header(s, theme) {
     const c = s.counts;
@@ -108,7 +121,7 @@ const logCells = (cells, width) => {
     return `${fit(where, 31)} ${fit(result, Math.max(10, width - 75))} ${fit(took, 7)} ${tokens}`;
 };
 /** The overview: under way, tokens, log - as many log rows as the height leaves. */
-export function mainLines(s, selected, width, height, theme) {
+export function mainLines(s, selected, width, height, theme, url) {
     const quiet = theme.chrome.color;
     const out = [...header(s, theme)];
     if (s.now.length > 0) {
@@ -179,7 +192,7 @@ export function mainLines(s, selected, width, height, theme) {
             ]);
         }
     }
-    return [...out, ...footer(width, keysFor(s, false), theme)];
+    return [...out, ...footer(width, keysFor(s, false, url), theme)];
 }
 function activity(e, theme) {
     const at = { text: `${clock(e.t)}  `, color: theme.chrome.color };
@@ -204,10 +217,16 @@ function activity(e, theme) {
                 ];
         case 'say':
             return [at, { text: 'says   ', color: theme.accent }, { text: e.text }];
+        case 'think':
+            return [
+                at,
+                { text: 'thinks ', color: theme.accent },
+                { text: e.text, color: theme.chrome.color },
+            ];
     }
 }
 /** One step's agent, line by line as it works. */
-export function followLines(s, key, width, height, theme) {
+export function followLines(s, key, width, height, theme, url) {
     const r = s.now.find((x) => x.key === key);
     const out = [];
     if (!r) {
@@ -230,9 +249,9 @@ export function followLines(s, key, width, height, theme) {
             out.push(activity(e, theme));
         }
     }
-    return [...out, ...footer(width, keysFor(s, true), theme)];
+    return [...out, ...footer(width, keysFor(s, true, url), theme)];
 }
-function Live({ t, theme, interrupt, }) {
+function Live({ t, theme, interrupt, url, }) {
     const [snap, setSnap] = useState();
     const [selected, setSelected] = useState(0);
     const [follow, setFollow] = useState();
@@ -250,6 +269,12 @@ function Live({ t, theme, interrupt, }) {
             interrupt();
             return;
         }
+        if (input === 'o') {
+            if (url) {
+                openInBrowser(url);
+            }
+            return;
+        }
         if (follow) {
             if (key.escape) {
                 setFollow(undefined);
@@ -271,8 +296,8 @@ function Live({ t, theme, interrupt, }) {
     }
     const height = Math.max(8, rows - 1);
     const all = follow
-        ? followLines(snap, follow, columns, height, theme)
-        : mainLines(snap, at, columns, height, theme);
+        ? followLines(snap, follow, columns, height, theme, url)
+        : mainLines(snap, at, columns, height, theme, url);
     // Too short a terminal loses rows from the middle, never the keys at the bottom.
     const lines = all.length > height ? [...all.slice(0, height - 2), ...all.slice(-2)] : all;
     return (_jsx(Box, { flexDirection: "column", children: lines.map((parts, i) => (_jsx(Text, { wrap: "truncate-end", children: parts.length === 0
@@ -280,9 +305,9 @@ function Live({ t, theme, interrupt, }) {
                 : parts.map((p, j) => (_jsx(Text, { color: p.color, bold: p.bold, children: p.text }, j))) }, i))) }));
 }
 /** Draws the tuning until the returned function is called. */
-export async function watch(t, interrupt) {
+export async function watch(t, interrupt, url) {
     const theme = await resolveTheme();
-    const instance = render(_jsx(Live, { t: t, theme: theme, interrupt: interrupt }), {
+    const instance = render(_jsx(Live, { t: t, theme: theme, interrupt: interrupt, url: url }), {
         stdout: process.stderr,
         exitOnCtrlC: false,
     });

package/dist/meta/finetune/tuning.d.ts

@@ -5,6 +5,7 @@ import { Improvements } from './improvements.ts';
 import { Journal } from './journal.ts';
 import type { Snapshot } from './live.ts';
 import { Memories } from './memories.ts';
+import { Rechecks } from './recheck.ts';
 import { SystemVersions } from './system.ts';
 import type { ByStage } from './usage.ts';
 export declare const FINETUNE_DIR = "finetune";
@@ -19,6 +20,16 @@ export interface Config {
     /** merge the submitted memories after this many more arrive */
     mergeEvery: number;
     seed: number;
+    /** completed cases run again after each apply, to catch what it broke */
+    recheck: number;
+    /** bytes one apply may add to what the agents always read */
+    budget: number;
+    /** percent over the start past which an apply may add nothing */
+    maxGrowth: number;
+    /** bytes one on-demand skill may hold */
+    skillCap: number;
+    /** skills one agent may see */
+    maxSkills: number;
     classes?: string[];
     ids?: string[];
     rubric?: boolean;
@@ -33,6 +44,11 @@ export interface Worker {
     attempt?: number;
     step: Step;
     since: number;
+    /** a recheck: the apply whose version it runs on, and the try's folder */
+    recheck?: {
+        apply: string;
+        dir: string;
+    };
 }
 /** A case in flight. It holds a worker only while it runs or is analyzed; parked, it holds none. */
 export interface Seat {
@@ -84,6 +100,7 @@ export declare class Tuning {
     readonly system: SystemVersions;
     readonly journal: Journal;
     readonly improvements: Improvements;
+    readonly rechecks: Rechecks;
     readonly memories: Memories;
     stopping: boolean;
     finished: boolean;
@@ -94,6 +111,8 @@ export declare class Tuning {
     drained: boolean;
     /** cases started by this process: a failed one is not taken twice in one start */
     readonly tried: Set<string>;
+    /** `--more`: cases of any kind this start may take; not kept in loop.json */
+    more: number | undefined;
     /** cases failed since the last step that went through */
     failures: number;
     /** what the last status page counted */
@@ -104,6 +123,8 @@ export declare class Tuning {
     } | undefined;
     /** called with every live snapshot */
     readonly watchers: Set<(s: Snapshot) => void>;
+    /** the latest live snapshot */
+    live: Snapshot | undefined;
     /** the latest step failures, newest first */
     readonly errors: StepFailure[];
     constructor(root: string, config: Config, zen: Zen, tickMs?: number);
@@ -135,6 +156,10 @@ export declare class Tuning {
         id: string;
         rev: number;
     }, phase: Phase, attempt: number): string;
+    /** The folder of the try a worker is on: the case's own, or a recheck's. */
+    workDir(w: Worker & {
+        case: Case;
+    }): string;
     /** What the loop knows of a try, which a feedback file is never trusted for. */
     known(c: {
         id: string;
@@ -159,7 +184,8 @@ export declare class Tuning {
     /** A step failed: kept for the live view, and in events.jsonl with its log. */
     error(where: string, message: string, log?: string): void;
     event(e: Omit<Event, 'at'>): void;
-    report(): void;
+    /** `live`: only what moves by the second is read again; the rest comes from the last full report. */
+    report(live?: boolean): void;
 }
 /** The real `zen`: this same binary, in its own process group so Ctrl-C reaches only us. */
 export declare function spawnZen(root: string, children: Set<ChildProcess>): Zen;

package/dist/meta/finetune/tuning.js

@@ -7,6 +7,7 @@ import { forget, remember } from "./children.js";
 import { Improvements } from "./improvements.js";
 import { Journal } from "./journal.js";
 import { Memories } from "./memories.js";
+import { Rechecks } from "./recheck.js";
 import { writeStatus } from "./report.js";
 import { SystemVersions } from "./system.js";
 // ---------------------------------------------------------------------------
@@ -26,6 +27,11 @@ export const DEFAULTS = {
     memTries: 3,
     mergeEvery: 3,
     seed: 1,
+    recheck: 3,
+    budget: 1500,
+    maxGrowth: 50,
+    skillCap: 12_000,
+    maxSkills: 10,
 };
 export class Stopped extends Error {
     constructor() {
@@ -48,6 +54,7 @@ export class Tuning {
     system;
     journal;
     improvements;
+    rechecks;
     memories;
     stopping = false;
     finished = false;
@@ -58,12 +65,16 @@ export class Tuning {
     drained = false;
     /** cases started by this process: a failed one is not taken twice in one start */
     tried = new Set();
+    /** `--more`: cases of any kind this start may take; not kept in loop.json */
+    more;
     /** cases failed since the last step that went through */
     failures = 0;
     /** what the last status page counted */
     progress;
     /** called with every live snapshot */
     watchers = new Set();
+    /** the latest live snapshot */
+    live;
     /** the latest step failures, newest first */
     errors = [];
     constructor(root, config, zen, tickMs = 1000) {
@@ -80,6 +91,7 @@ export class Tuning {
         this.system = new SystemVersions(root, join(this.dir, 'systems'));
         this.journal = new Journal(join(this.dir, 'journal.jsonl'));
         this.improvements = new Improvements(this);
+        this.rechecks = new Rechecks(this);
         this.memories = new Memories(this);
     }
     get stopFile() {
@@ -139,6 +151,10 @@ export class Tuning {
     attemptDir(c, phase, attempt) {
         return join(this.caseDir(c), `${pad(attempt)}-${phase}`);
     }
+    /** The folder of the try a worker is on: the case's own, or a recheck's. */
+    workDir(w) {
+        return w.recheck?.dir ?? this.attemptDir(w.case, w.phase ?? 'nomem', w.attempt ?? 1);
+    }
     /** What the loop knows of a try, which a feedback file is never trusted for. */
     known(c, phase, attempt) {
         const round = this.round(c);
@@ -163,6 +179,7 @@ export class Tuning {
                         case: s.case,
                         phase: undefined,
                         attempt: undefined,
+                        recheck: undefined,
                         step: 'idle',
                         since: Date.now(),
                     });
@@ -188,6 +205,7 @@ export class Tuning {
             case: undefined,
             phase: undefined,
             attempt: undefined,
+            recheck: undefined,
             step: 'idle',
             since: Date.now(),
         });
@@ -233,9 +251,10 @@ export class Tuning {
         this.recent.length = Math.min(this.recent.length, 50);
         this.report();
     }
-    report() {
+    /** `live`: only what moves by the second is read again; the rest comes from the last full report. */
+    report(live = false) {
         try {
-            writeStatus(this);
+            writeStatus(this, live);
         }
         catch {
             // A status page that failed to render must not stop the tuning.

package/dist/meta/finetune/usage.d.ts

@@ -40,6 +40,8 @@ export interface RunMetrics {
     branches: number;
     compactions: number;
     handoffs: number;
+    /** skills loaded, preloads included, in the order first loaded */
+    skills: string[];
     /** the first error a sandbox tool got from the container engine, not from a command */
     sandbox?: string;
 }
@@ -57,6 +59,8 @@ export declare function runTokens(runDir: string): ByModel | undefined;
 export declare function envelopeTokens(file: string): ByModel | undefined;
 /** Every envelope in `dir` named `<stem>.json` or `<stem>-<n>.json` - retries keep their own. */
 export declare function envelopesIn(dir: string, stem: string): ByModel | undefined;
+/** An apply's own envelopes, and - for applies from before rechecks - its guard's runs: `guard/<attempt>/<case>/<try>/`. */
+export declare function applyTokens(dir: string): ByModel | undefined;
 /** 1234 → 1.2k, 2184341 → 2.2M. */
 export declare function short(n: number): string;
 //# sourceMappingURL=usage.d.ts.map

package/dist/meta/finetune/usage.js

@@ -88,6 +88,7 @@ export function runMetrics(runDir) {
         branches: 0,
         compactions: 0,
         handoffs: 0,
+        skills: [],
     };
     const seen = new Set();
     const count = (o, ms) => {
@@ -140,6 +141,14 @@ export function runMetrics(runDir) {
             case 'handoff':
                 m.handoffs++;
                 return;
+            case 'load_skills':
+                for (const s of Array.isArray(o.skills) ? o.skills : []) {
+                    const name = s?.name;
+                    if (typeof name === 'string' && !m.skills.includes(name)) {
+                        m.skills.push(name);
+                    }
+                }
+                return;
         }
     };
     // A branch lane starts where its parent lane was when the fork began.
@@ -212,6 +221,32 @@ export function envelopesIn(dir, stem) {
     const parts = names.map((n) => envelopeTokens(join(dir, n))).filter((p) => !!p);
     return parts.length > 0 ? mergeModels(...parts) : undefined;
 }
+/** An apply's own envelopes, and - for applies from before rechecks - its guard's runs: `guard/<attempt>/<case>/<try>/`. */
+export function applyTokens(dir) {
+    const parts = [envelopesIn(dir, 'apply')];
+    const under = (d) => {
+        try {
+            return readdirSync(d, { withFileTypes: true })
+                .filter((e) => e.isDirectory())
+                .map((e) => join(d, e.name));
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const tryDir of under(join(dir, 'guard')).flatMap(under).flatMap(under)) {
+        parts.push(envelopesIn(tryDir, 'analyze'));
+        try {
+            const run = JSON.parse(readFileSync(join(tryDir, 'run.json'), 'utf8'));
+            parts.push(run.tokens);
+        }
+        catch {
+            // A void run wrote none.
+        }
+    }
+    const found = parts.filter((p) => !!p);
+    return found.length > 0 ? mergeModels(...found) : undefined;
+}
 /** 1234 → 1.2k, 2184341 → 2.2M. */
 export function short(n) {
     if (n >= 1_000_000) {

package/dist/meta/finetune/view.d.ts

@@ -0,0 +1,9 @@
+export interface Viewing {
+    url: string;
+    close(): Promise<void>;
+}
+/** The address another live process serves the tuning on, if one does. */
+export declare function liveView(projectDir: string): string | undefined;
+/** Serves the project, opening at STATUS.md, until `close`. */
+export declare function startView(projectDir: string): Promise<Viewing>;
+//# sourceMappingURL=view.d.ts.map

package/dist/meta/finetune/view.js

@@ -0,0 +1,27 @@
+import { liveHolder, ownLock } from '@zenera/neo';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { FINETUNE_DIR } from "./tuning.js";
+const lockFile = (projectDir) => join(projectDir, FINETUNE_DIR, 'view.json');
+/** The address another live process serves the tuning on, if one does. */
+export function liveView(projectDir) {
+    return liveHolder(lockFile(projectDir))?.url;
+}
+/** Serves the project, opening at STATUS.md, until `close`. */
+export async function startView(projectDir) {
+    const { serveView } = await import('@zenera/view');
+    const server = await serveView({ root: projectDir, start: `/${FINETUNE_DIR}/STATUS.md` });
+    const file = lockFile(projectDir);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(ownLock({ url: server.url }), null, 2)}\n`);
+    return {
+        url: server.url,
+        close: async () => {
+            if (liveHolder(file)?.pid === process.pid) {
+                rmSync(file, { force: true });
+            }
+            await server.close();
+        },
+    };
+}
+//# sourceMappingURL=view.js.map

package/dist/meta/host.d.ts

@@ -4,11 +4,12 @@ export { paths, readJson, writeJson } from '../home.ts';
 export { envOf, type KeyEntry, type KeyStore, type Provider } from '../keys.ts';
 export { PROVIDER_NAMES, splitRef } from '../modelref.ts';
 export { duration } from '../narrate.ts';
-export { copyTree, MEMORY_RULES, TEMPLATES } from '../scaffold.ts';
+export { copyTree, SHARED_RULES, TEMPLATES } from '../scaffold.ts';
 export { bold, CliError, confirm, credentialError, cut, cyan, dim, EXIT, green, invalidError, json, note, pad, plain, red, styled, table, usageError, write, writeAll, yellow, } from '../term.ts';
 export { safe } from '../trace.ts';
 export { formatInline, formatMarkdown } from '../tui/markdown.ts';
 export { resolveTheme, type Theme } from '../tui/theme.ts';
 export { boxWidth } from '../tui/wrap.ts';
 export { META_PROMPT_ENV, META_SESSION_ENV } from '../usage.ts';
+export { validateProject, type Report as ProjectReport } from '../validate.ts';
 //# sourceMappingURL=host.d.ts.map