@turri-dev/cli 0.1.6-next.336dd6e → 0.1.7-next.8f13f3a

package/dist/jellyfish.js

@@ -1,114 +1,247 @@
 import { sgr } from "./regenerate/plain-palette.js";
-/** The pixels' colours on a dark background and a light one - the tentacles darker on light, where neon does not show. */
+/** How much of a pixel shows. */
+const ALPHA = { p: 1, m: 1, i: 1, e: 1, h: 1, o: 1, N: 1, n: 0.5, c: 0.6 };
+/** The pixels' colours on a dark background and a light one - the tentacles blue whale on light, where neon does not show. */
 export const JELLYFISH_COLOURS = {
-    dark: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#8eebee", n: "#5ce1e6", l: "#85a3b2", g: "#3e5a6b" },
-    light: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#3e5a6b", n: "#1e3442", l: "#85a3b2", g: "#85a3b2" },
+    dark: { p: "#ff5c8d", m: "#a9479a", i: "#5b57d9", e: "#732553", h: "#ff7fa6", o: "#ff7a3d", N: "#5ce1e6", n: "#5ce1e6", c: "#5ce1e6" },
+    light: { p: "#ff5c8d", m: "#a9479a", i: "#5b57d9", e: "#732553", h: "#ff7fa6", o: "#ff7a3d", N: "#1e3442", n: "#1e3442", c: "#1e3442" },
 };
-/**
- * How shut the bell is, frame by frame - a quarter second each: shut quickly, held a moment, opened slowly, at rest
- * until the next stroke.
- */
-const SHUT = [0.1, 0.55, 0.9, 1, 0.85, 0.7, 0.56, 0.44, 0.33, 0.23, 0.14, 0.06];
-const LARGE = {
-    width: 24,
-    height: 26,
-    open: [6, 12, 16, 18, 20, 22, 22, 24, 24],
-    shut: [6, 10, 14, 16, 18, 18, 18, 20, 20],
-    glint: [[-3, 2], [-4, 2], [-5, 3], [-6, 4], [-6, 5]],
-    shine: [-2, 2],
-    gut: [".oo..oo.", "oooooooo", "oooooooo", ".oo..oo."],
-    gutRow: 4,
-    strands: [
-        { at: -8, length: 10, sway: 1.1, ink: "N" },
-        { at: -4.5, length: 13, sway: 1.3, ink: "N" },
-        { at: -1, length: 14, sway: 0.8, ink: "n" },
-        { at: 2, length: 13, sway: 0.8, ink: "n" },
-        { at: 5.5, length: 13, sway: 1.3, ink: "N" },
-        { at: 9, length: 10, sway: 1.1, ink: "N" },
-    ],
-};
-const SMALL = {
-    width: 18,
-    height: 20,
-    open: [4, 10, 12, 14, 16, 18, 18],
-    shut: [4, 8, 10, 12, 14, 14, 14],
-    glint: [[-2, 1], [-3, 2], [-4, 3]],
-    shine: [-1, 1],
-    gut: ["oo..oo", "oooooo", "oo..oo"],
-    gutRow: 3,
-    strands: [
-        { at: -6, length: 8, sway: 0.9, ink: "N" },
-        { at: -3, length: 10, sway: 1, ink: "N" },
-        { at: -0.5, length: 11, sway: 0.7, ink: "n" },
-        { at: 1.5, length: 10, sway: 0.7, ink: "n" },
-        { at: 4, length: 10, sway: 1, ink: "N" },
-        { at: 7, length: 8, sway: 0.9, ink: "N" },
-    ],
+/** What a pixel short of whole is laid over, to draw it in half blocks: abyss, or white. */
+const BACKGROUND = { dark: "#0a0f1a", light: "#f4f7f9" };
+/** How much of a pixel shows, for a picture's alpha. */
+export function jellyfishAlpha(pixel) {
+    return ALPHA[pixel] ?? 0;
+}
+/** The lifecycle's grid, and the sea floor the polyp stands on. */
+const WIDTH = 40;
+const HEIGHT = 60;
+const FLOOR = 59;
+const put = (grid, x, y, pixel, bounded = true) => {
+    x = Math.round(x);
+    y = Math.round(y);
+    if (bounded && (x < 0 || x > WIDTH - 1 || y < 0 || y > FLOOR))
+        return;
+    grid.set(`${x},${y}`, pixel);
 };
-/** One frame of a design: its height in rows of its width in pixels, "." where there is none. */
-function frame(design, t) {
-    const grid = Array.from({ length: design.height }, () => Array(design.width).fill("."));
-    const centre = design.width / 2;
-    const set = (y, x, pixel, over = true) => {
-        if (y < 0 || y >= design.height || x < 0 || x >= design.width)
-            return;
-        if (over || grid[y][x] === ".")
-            grid[y][x] = pixel;
-    };
-    const shut = SHUT[t % SHUT.length];
-    // Shut, it has risen a pixel.
-    const top = shut > 0.6 ? 0 : 1;
-    const widths = design.open.map((open, row) => 2 * Math.round((open - (open - design.shut[row]) * shut) / 2));
-    widths.forEach((width, row) => {
-        for (let x = centre - width / 2; x < centre + width / 2; x++)
-            set(top + row, x, "p");
-    });
-    const rimWidth = widths.at(-1);
-    const rim = top + widths.length;
-    // The underside along the bottom row, the rim scalloped under it.
-    for (let x = centre - rimWidth / 2 + 2; x < centre + rimWidth / 2 - 2; x++)
-        set(rim - 1, x, "e");
-    for (let x = centre - rimWidth / 2; x < centre + rimWidth / 2; x += 2)
-        set(rim, x + 1, "p");
-    // A glint up on the left, curving with the dome, and a pixel of shine.
-    for (const [dx, dy] of design.glint)
-        set(top + dy, centre + dx, "h");
-    set(top + design.shine[1], centre + design.shine[0], "w");
-    const gutLeft = centre - Math.floor(design.gut[0].length / 2);
-    design.gut.forEach((line, dy) => [...line].forEach((pixel, dx) => pixel === "o" && set(top + design.gutRow + dy, gutLeft + dx, "o")));
-    // The tentacles: rooted under the bell, drawn in as it shuts, swaying - the further down, the later.
-    const phase = (2 * Math.PI * t) / SHUT.length;
-    design.strands.forEach((strand, i) => {
-        const root = centre - 0.5 + strand.at * (rimWidth / design.open.at(-1));
-        for (let y = 0; y < strand.length; y++) {
-            const x = Math.round(root + strand.sway * Math.sin(phase - y * 0.55 + i * 0.8) * Math.min(1, y / 3));
-            const left = strand.length - y;
-            // The tips come apart, every other pixel, fading - into code.
-            if (left <= 3 && y % 2 === 1)
+/** The bell's colour down its height: pink, through its midtone, to its shadow - dithered where one meets the next. */
+const band = (t, x, y) => t < 0.3 ? "p" : t < 0.42 ? ((x + y) % 2 ? "p" : "m") : t < 0.62 ? "m" : t < 0.74 ? ((x + y) % 2 ? "m" : "i") : "i";
+/** An ellipse filled with the bell's colours, or its top half - a dome. */
+function shape(grid, cx, cy, rx, ry, dome, bounded = true) {
+    for (let y = Math.floor(cy - ry); y <= Math.ceil(cy + ry); y++) {
+        if (dome && y > cy)
+            continue;
+        for (let x = Math.floor(cx - rx); x <= Math.ceil(cx + rx); x++) {
+            const dx = (x + 0.5 - cx) / rx;
+            const dy = (y + 0.5 - cy) / ry;
+            if (dx * dx + dy * dy > 1)
                 continue;
-            set(rim + 1 + y, x, left > 5 ? strand.ink : left > 2 ? "l" : "g", false);
-            // The oral arms are frilled.
-            if (strand.ink === "n" && left > 5 && (y + t) % 3 === 0)
-                set(rim + 1 + y, x + (strand.at < 0 ? -1 : 1), "n", false);
+            const t = dome ? (y - (cy - ry)) / ry : (y - (cy - ry)) / (2 * ry);
+            put(grid, x, y, band(Math.max(0, Math.min(1, t)), x, y), bounded);
         }
-    });
-    return grid.map((row) => row.join(""));
+    }
 }
-export const JELLYFISH_WIDTH = LARGE.width;
-export const JELLYFISH_HEIGHT = LARGE.height;
-/** The large jellyfish's frames, a stroke: what the pictures are rendered from. */
-export const JELLYFISH_FRAMES = SHUT.map((_, t) => frame(LARGE, t));
-/** The small jellyfish's frames, a stroke: what a terminal without images draws, in half blocks. */
-export const JELLYFISH_TEXT_FRAMES = SHUT.map((_, t) => frame(SMALL, t));
+/** The bell's rim: every fourth pixel from the middle left out, the rest eggplant. */
+function rim(grid, y) {
+    for (let x = 0; x < WIDTH + 1; x++) {
+        const key = `${x},${y}`;
+        if (!grid.has(key))
+            continue;
+        if (Math.abs(x - 20) % 4 === 2)
+            grid.delete(key);
+        else
+            grid.set(key, "e");
+    }
+}
+/** The glint on the bell, up on the left. */
+const GLINT = [[11, 6], [12, 5], [13, 5], [10, 7], [11, 7], [14, 4]];
+/** Where each of the thirteen tentacles hangs, how long it is, and its place in the sway. */
+const TENTACLES = [8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32].map((x, i) => ({ x, length: 16 + ((i * 7) % 12), i }));
+/** The jellyfish at a scale `k`, its rim on row `cy`, its tentacles grown `grown` of the way. */
+function medusa(grid, k, cy, grown) {
+    shape(grid, 20.5, cy, 14.5 * k, 16 * k, true);
+    if (k > 0.45)
+        rim(grid, Math.floor(cy));
+    if (k > 0.8) {
+        for (const [gx, gy] of GLINT) {
+            const x = Math.round(20 + (gx - 20) * k);
+            const y = Math.round(cy + (gy - 18) * k);
+            if (grid.has(`${x},${y}`))
+                put(grid, x, y, "h");
+        }
+    }
+    const gutY = cy - 7 * k;
+    const halfWidth = Math.max(1.5, 2.5 * k);
+    const halfHeight = Math.max(0.6, 1.5 * k);
+    for (let y = Math.round(gutY - halfHeight); y < gutY + halfHeight; y++)
+        for (let x = Math.round(20 - halfWidth); x < 20 + halfWidth; x++)
+            put(grid, x, y, "o");
+    if (k > 0.7) {
+        for (let x = 19; x <= 21; x++) {
+            put(grid, x, gutY - 2, "o");
+            put(grid, x, gutY + 2, "o");
+        }
+    }
+    for (const { x, length, i } of TENTACLES) {
+        const shown = Math.round(length * Math.pow(grown, 1.2));
+        const root = 20 + (x - 20) * k;
+        for (let j = 0; j < shown; j++)
+            put(grid, root + Math.round(Math.sin(j * 0.5 + i) * 1.6 * (j / shown)), cy + 1 + j, j % 2 ? "n" : "N");
+    }
+}
+/** The polyp on the floor, grown `u` of the way: a stalk, a head with its gut, a crown of tentacles. */
+function polyp(grid, u) {
+    shape(grid, 20, FLOOR, 3, 1.4, true);
+    const height = Math.round(2 + 12 * u);
+    const radius = 1.4 + 2.2 * u;
+    for (let y = FLOOR - height; y <= FLOOR; y++) {
+        for (let x = 19; x <= 20; x++)
+            put(grid, x, y, band(0.45 + (0.55 * (y - (FLOOR - height))) / Math.max(1, height), x, y));
+    }
+    const head = FLOOR - height - radius + 1;
+    shape(grid, 20, head, radius, radius, false);
+    put(grid, 19, head, "o");
+    put(grid, 20, head, "o");
+    if (radius > 2.5) {
+        put(grid, 19, head - 1, "o");
+        put(grid, 20, head - 1, "o");
+    }
+    const crown = [[-4, -3], [3, -3], [-1, -5], [1, -5], [-5, -4], [4, -4], [-1, -6], [1, -6], [-6, -5], [5, -5]];
+    const scale = radius / 3.6;
+    for (let i = 0; i < Math.floor(u * crown.length); i++) {
+        const [dx, dy] = crown[i];
+        put(grid, 20 + dx * scale + (dx < 0 ? 0 : 0.5), head + dy * scale, i % 2 ? "c" : "N");
+    }
+}
+const ease = (t) => (t < 0 ? 0 : t > 1 ? 1 : t * t * (3 - 2 * t));
+/** The lifecycle: twenty frames of the polyp growing into the jellyfish, nineteen of it sinking and the polyp growing back. */
+function lifecycle() {
+    const frames = [];
+    for (let f = 0; f < 20; f++) {
+        const grid = new Map();
+        const g = f / 19;
+        const p = ease((g - 0.2) / 0.65);
+        if (1 - p > 0.06)
+            polyp(grid, 1 - p);
+        else if (p < 1)
+            shape(grid, 20, FLOOR, 2.2, 1, true);
+        const e = ease((g - 0.08) / 0.92);
+        if (e > 0)
+            medusa(grid, 0.18 + 0.82 * e, 40 - 22 * e, Math.pow(e, 1.5));
+        frames.push(grid);
+    }
+    // It sinks to the floor first, and the polyp grows up from there.
+    for (let f = 0; f <= 18; f++) {
+        const grid = new Map();
+        if (f <= 8) {
+            const s = f / 8;
+            medusa(grid, 1 - 0.72 * s, 18 + 40 * s, 1 - s);
+        }
+        else if (f <= 11) {
+            const w = (f - 9) / 2;
+            shape(grid, 20, FLOOR, 4.2 - 1.2 * w, 3.2 - 0.8 * w, true);
+            put(grid, 19, FLOOR - 1, "o");
+            put(grid, 20, FLOOR - 1, "o");
+        }
+        else
+            polyp(grid, (f - 11) / 7);
+        frames.push(grid);
+    }
+    return frames;
+}
+/**
+ * The jellyfish swimming, grown: its bell still, its tentacles in one of two strokes - the second drawn a pixel higher,
+ * as it bobs.
+ */
+function hero(stroke) {
+    const grid = new Map();
+    shape(grid, 20.5, 18, 14.5, 16, true, false);
+    rim(grid, 18);
+    for (const [x, y] of GLINT)
+        if (grid.has(`${x},${y}`))
+            put(grid, x, y, "h", false);
+    for (let y = 10; y <= 12; y++)
+        for (let x = 18; x <= 22; x++)
+            put(grid, x, y, "o", false);
+    for (let x = 19; x <= 21; x++) {
+        put(grid, x, 9, "o", false);
+        put(grid, x, 13, "o", false);
+    }
+    for (const { x, length, i } of TENTACLES) {
+        for (let k = 0; k < length; k++) {
+            const sway = Math.round(Math.sin(k * 0.5 + i + (stroke === 1 ? 2.2 : 0)) * 1.6 * (k / length));
+            put(grid, x + sway, 19 + k, k % 2 ? "n" : "N", false);
+        }
+    }
+    if (stroke === 0)
+        return grid;
+    const raised = new Map();
+    for (const [key, pixel] of grid) {
+        const [x, y] = key.split(",").map(Number);
+        raised.set(`${x},${y - 1}`, pixel);
+    }
+    return raised;
+}
+/** Every frame on one grid, cut to what any of them draws on: rows of pixels, "." where there is none. */
+function crop(grids) {
+    const cells = grids.flatMap((grid) => [...grid.keys()].map((key) => key.split(",").map(Number)));
+    const left = Math.min(...cells.map(([x]) => x));
+    const right = Math.max(...cells.map(([x]) => x));
+    const top = Math.min(...cells.map(([, y]) => y));
+    const bottom = Math.max(...cells.map(([, y]) => y));
+    return grids.map((grid) => Array.from({ length: bottom - top + 1 }, (_, y) => Array.from({ length: right - left + 1 }, (_, x) => grid.get(`${x + left},${y + top}`) ?? ".").join("")));
+}
+/** The lifecycle's frames, then the jellyfish's two strokes, swimming. */
+const LIFECYCLE = lifecycle();
+const SWIM = LIFECYCLE.length;
+/** The jellyfish's frames, each as rows of pixels: what the pictures are rendered from. */
+export const JELLYFISH_FRAMES = crop([...LIFECYCLE, hero(0), hero(1)]);
+export const JELLYFISH_WIDTH = JELLYFISH_FRAMES[0][0].length;
+export const JELLYFISH_HEIGHT = JELLYFISH_FRAMES[0].length;
+/**
+ * The order the frames play in, round and round: the polyp a moment, growing into the jellyfish, swimming four
+ * seconds - a stroke every five frames - then sinking, and the polyp growing back.
+ */
+export const JELLYFISH_SEQUENCE = [
+    ...[0, 0, 0],
+    ...Array.from({ length: 20 }, (_, f) => f),
+    ...Array.from({ length: 27 }, (_, f) => SWIM + (Math.floor(f / 5) % 2)),
+    ...Array.from({ length: 19 }, (_, f) => 20 + f),
+];
 /** How long each frame shows. */
-export const JELLYFISH_FRAME_MS = 250;
+export const JELLYFISH_FRAME_MS = 150;
+/** How much smaller the frames are drawn in half blocks: a cell is a block of SHRINK pixels square. */
+const SHRINK = 3;
+/**
+ * A frame a third of the size: each block drawn as the pixel at its middle. What most of a block is would run the
+ * tentacles, two pixels apart, together into one fringe; its middle keeps strands apart.
+ */
+function shrink(pixels) {
+    const middle = Math.floor(SHRINK / 2);
+    const rows = [];
+    for (let y = middle; y < pixels.length; y += SHRINK) {
+        let row = "";
+        for (let x = middle; x < pixels[0].length; x += SHRINK)
+            row += pixels[y][x];
+        rows.push(row);
+    }
+    return rows;
+}
+/** The frames as a terminal without images draws them, in half blocks: the same order, a third of the size. */
+export const JELLYFISH_TEXT_FRAMES = JELLYFISH_FRAMES.map(shrink);
+/** A colour laid over another, `alpha` of it showing. */
+function over(hex, under, alpha) {
+    if (alpha >= 1)
+        return hex;
+    const channel = (colour, at) => Number.parseInt(colour.slice(at, at + 2), 16);
+    return `#${[1, 3, 5].map((at) => Math.round(channel(hex, at) * alpha + channel(under, at) * (1 - alpha)).toString(16).padStart(2, "0")).join("")}`;
+}
 /**
  * A frame drawn in half blocks for a terminal that shows no images: two pixels a cell, the upper one the text's colour
  * and the lower one the background's, in as many colours as the terminal has: a column a pixel, a row every two.
  */
 export function halfBlocks(pixels, appearance, truecolor) {
     const colours = JELLYFISH_COLOURS[appearance];
-    const colour = (pixel) => (pixel === undefined || pixel === "." ? undefined : colours[pixel]);
+    const colour = (pixel) => pixel === undefined || pixel === "." ? undefined : over(colours[pixel], BACKGROUND[appearance], ALPHA[pixel]);
     const rows = [];
     for (let y = 0; y < pixels.length; y += 2) {
         let row = "";

package/dist/judge.d.ts

@@ -0,0 +1,25 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { type Verdict } from "./tools.ts";
+import type { ReviewSpec } from "./skill.ts";
+export interface JudgeResult {
+    index: number;
+    model: string;
+    verdict: Verdict | undefined;
+}
+export interface GateOutcome {
+    passed: boolean;
+    results: JudgeResult[];
+    /** Feedback handed back to the executor on retry. Empty when the gate passed. */
+    critique: string;
+}
+export declare function runGate(opts: {
+    cwd: string;
+    review: ReviewSpec;
+    rubric: string;
+    artifactPath: string;
+    artifact: string;
+    executor: AgentSession;
+    /** Used when the gate does not name a model - normally the conversation's. */
+    defaultModel?: string;
+    onJudgeStart?: (index: number, model: string) => void;
+}): Promise<GateOutcome>;

package/dist/lineage-cli.d.ts

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

package/dist/loop-cli.d.ts

@@ -0,0 +1,34 @@
+import { type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
+import { type ModuleState } from "./run-report.ts";
+/**
+ * What every command that builds - `turri regenerate`, `conform`, `spec-diff` - does around its own
+ * request of the work loop, as the chat does it: the project's models, a job that fails run once more and, failing again,
+ * diagnosed, a line as each job starts and ends; then the loop run until nothing more can start, how each job ended,
+ * and exit 1 when any failed or a module is not complete. With `dryRun`, the work is planned and the prompt of the first job each codebase would
+ * start printed, and nothing runs.
+ */
+export declare function runLoop(options: {
+    plainFile: string;
+    /** Where the code is exported to as the run ends, however it ends: the furthest-built codebase's last commit. */
+    buildDir?: string;
+    /** The run report's file (`--report`): see run-report.ts. */
+    report?: string;
+    /** The command, as the report gives it: its name and its arguments. */
+    command?: string[];
+    dryRun?: boolean;
+    /** Start over, unasked, a codebase that has to be on a module it now requires (`--start-over`). */
+    startOver?: boolean;
+    /** The request: bring up, regenerate, conformance. */
+    ask: (loop: WorkLoop) => Promise<ModuleStatus[]>;
+}): Promise<never>;
+/** How each codebase stands, from what is left to regenerate there. */
+export declare function moduleStates(reports: DriftReport[]): ModuleState[];
+/**
+ * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review`, `--mutation-testing` and, where
+ * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
+ */
+export declare function headlessOptions(options: Record<string, string | undefined>, conformance: boolean): {
+    report?: string;
+    buildDir?: string;
+};

package/dist/loop-tools.d.ts

@@ -0,0 +1,80 @@
+import { type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
+import type { RenderWork } from "./regenerate/engine.ts";
+import { type JobRegistry } from "./regenerate/jobs.ts";
+/**
+ * The tools that act on the work loop - `regenerate`, `drift` and `halt` - defined once, for the conversation and for the
+ * skills alike: a skill that regenerates what a spec holds, or reads how far it is regenerated, uses the conversation's
+ * own tools, on the conversation's loop, never copies of them.
+ */
+type AnyTool = ToolDefinition<any, any, any>;
+/** How the queue is to be planned, for the work this call queues - see regenerate/steer.ts. */
+export declare const GUIDANCE_PARAM: Type.TOptional<Type.TString>;
+export declare const WORKING_DIR_PARAM: Type.TOptional<Type.TString>;
+export declare const MODEL_PARAM: Type.TOptional<Type.TString>;
+export declare const STACK_PARAM: Type.TOptional<Type.TString>;
+/**
+ * Why a module asked for with no stack named cannot be built: a project of stacks where it has no stack of its own and
+ * none is chosen, and config.turri.yaml alone names no unit testing script - every pulse would stop for want of one.
+ * The stacks and the script each names, and what to do. Undefined when it can be built.
+ */
+export declare function stacklessBuild(plainFile: string): string | undefined;
+/**
+ * `work` with the stack a call names chosen for it - or, none named, as it is: each module is then built with its own
+ * (`stackForModule`). A module that could not be built that way is refused before anything is planned (`stacklessBuild`).
+ */
+export declare function withCallStack<T>(plainFile: string, named: string | undefined, work: () => T): T;
+export declare const WAIT_PARAM: Type.TOptional<Type.TBoolean>;
+/**
+ * A render tool's arguments as if turri had been started in `working_dir`: the .plain file
+ * and the build folder made absolute from there, and that folder as `base`.
+ */
+export declare function fromWorkingDir<T extends {
+    working_dir?: string;
+    plain_file?: string;
+    build_dir?: string;
+}>(cwd: string, params: T): T & {
+    base: string;
+};
+/** What the loop is doing for a spec's modules, for the conversation - and, waiting, how each module ended. */
+export declare function loopReply(loop: WorkLoop, statuses: ModuleStatus[], wait: boolean): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        jobIds: string[];
+    };
+}>;
+/** Halt a pulse by its id, or the start of it: what it was, and what moves up behind it. `reason`: why, kept with it. */
+export declare function stopJob(jobs: JobRegistry, named: string, reason?: string, loop?: WorkLoop): string;
+export interface LoopToolsOptions {
+    /** Where turri was started: the folder plain_file and working_dir are relative to. */
+    cwd: string;
+    /** The pulses `halt` stops. Without them - the release agent's - it stops only what activate started. */
+    jobs?: JobRegistry;
+    /** The work loop the tools act on - the conversation's, for a call in it. */
+    loop?: (ctx: ExtensionContext) => WorkLoop;
+    /** The model a pulse of this call regenerates on: the one named, or the one chosen for the work. Default: the one named. */
+    model?: (ctx: ExtensionContext, plainFile: string, named?: string, work?: RenderWork) => string | undefined;
+    /** Whether a call waits for its work to finish, given what it asked. Default: only when it asked to. */
+    wait?: (ctx: ExtensionContext, asked?: boolean) => boolean;
+}
+/** Whether a /regenerate's words ask for the module from scratch: its code deleted, and all of it regenerated again. */
+export declare function asksFromScratch(words: string): boolean;
+/** Whether a /regenerate asking for its module from scratch asks for its whole requires chain with it. */
+export declare function asksWholeChain(words: string): boolean;
+/** regenerate: regenerate a module's code up to its spec as it is now. */
+export declare function regenerateTool(options: LoopToolsOptions & {
+    loop: (ctx: ExtensionContext) => WorkLoop;
+}): AnyTool;
+/** drift: what is left to regenerate - planning nothing, starting nothing. */
+export declare function driftTool(options: LoopToolsOptions & {
+    loop: (ctx: ExtensionContext) => WorkLoop;
+}): AnyTool;
+/** halt: stop a pulse, or what activate started. */
+export declare function haltTool(options: Pick<LoopToolsOptions, "jobs"> & {
+    workLoop?: () => WorkLoop | undefined;
+}): AnyTool;
+export {};

package/dist/mature-tools.d.ts

@@ -0,0 +1,53 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Job, type JobRegistry } from "./regenerate/jobs.ts";
+/**
+ * The tools a skill that matures a spec works with, besides the conversation's regenerate, drift and halt: wait for
+ * the builds, and read back where the spec left the agents to decide.
+ *
+ * A render that passes can still have been built on a guess: where the spec is silent, the agent
+ * decides, and says so in the working notes' assumptions. Those, the pitfalls, a failed job's
+ * diagnosis and a spec that contradicts itself are what the spec should have said - and a skill
+ * reading them can write it in, so the next build does not have to guess.
+ */
+type AnyTool = ToolDefinition<any, any, any>;
+/** What a maturing skill found: where it came from, and what it says. */
+export interface SpecFinding {
+    id: string;
+    kind: "assumption" | "pitfall" | "diagnosis" | "conflict";
+    /** The module whose codebase it came from, or the job it came from. */
+    where: string;
+    text: string;
+}
+/** A time as the notes stamp their lines: "2026-09-28 17:40". */
+export declare function noteStamp(date: Date): string;
+/**
+ * What the agents and the harness recorded since `since`: the assumptions and pitfalls in every
+ * codebase's working notes, the diagnosis of every job that failed for good, and every spec that
+ * contradicts itself.
+ */
+export declare function collectFindings(options: {
+    project: string;
+    jobs: Job[];
+    since: Date;
+}): Omit<SpecFinding, "id">[];
+/** Why a build is struggling: a key for what kind of struggle it is - handed out once each - and what it says. */
+export interface Struggle {
+    key: string;
+    why: string;
+}
+/** How long a build may run before it counts as struggling on its length alone. */
+export declare const LONG_BUILD_MS: number;
+/**
+ * Whether a running build is struggling, and how: sent back four times or more in one loop, five
+ * setbacks or more, a spec conflict raised, a failure being run again, or running far longer than a
+ * build should. Each kind comes once per build - a round count again only every four rounds more.
+ */
+export declare function struggling(job: Job, now?: number): Struggle | undefined;
+export declare function createMatureTools(options: {
+    jobs: JobRegistry;
+    cwd: string;
+    startedAt?: Date;
+}): AnyTool[];
+/** The names of the maturing tools, as a skill's allowed-tools names them: its own - it regenerates, halts and reads drift with the conversation's (loop-tools.ts). */
+export declare const MATURE_TOOLS: string[];
+export {};

package/dist/model-check.d.ts

@@ -0,0 +1,42 @@
+import { type ProjectConfig } from "./config.ts";
+/**
+ * Whether the models a project's config names answer, with the credentials this machine has - for any provider pi
+ * supports. Each model the config uses (harness-model, coding-model, judge-model and every role under models:) is sent
+ * one short request through pi's own model runtime, the one turri's agents use, so the credentials are found as they
+ * will be when it builds: an API key in the environment, pi's /login, an AWS profile. A model pi does not know, a key
+ * it rejects, an account without access to the model - each is said, with what to do about it.
+ */
+/** A model the config uses, and which of its settings name it. */
+export interface UsedModel {
+    spec: string;
+    usedBy: string[];
+}
+/** Every model the config uses, each once, with the settings that name it - the two models first. */
+export declare function modelsInUse(config: Pick<ProjectConfig, "harnessModel" | "codingModel" | "judgeModel" | "models">): UsedModel[];
+export type ModelVerdict = {
+    ok: true;
+    spec: string;
+    usedBy: string[];
+    ms: number;
+} | {
+    ok: false;
+    spec: string;
+    usedBy: string[];
+    problem: string;
+    fix: string;
+};
+/** What it takes to talk to a model: pi's runtime, or a stand-in for tests. */
+export interface ModelAccess {
+    /** The model, as pi knows it - undefined when it does not. */
+    find(provider: string, id: string): unknown;
+    /** Other models of the provider pi knows, to suggest from. */
+    known(provider: string): string[];
+    /** One short request: the error the provider gave, or nothing when it answered. */
+    ask(model: unknown): Promise<string | undefined>;
+}
+/** pi's own model runtime, with pi's credentials - auth.json, models.json and the environment - as turri's agents have them. */
+export declare function piModelAccess(): Promise<ModelAccess>;
+/** What to do about a provider's error, from what it says. */
+export declare function fixFor(provider: string, problem: string): string;
+/** Each model the config uses, tried: answered, or what is wrong and what to do. One request a model. */
+export declare function checkModels(models: UsedModel[], access: ModelAccess): Promise<ModelVerdict[]>;

package/dist/module-report.d.ts

@@ -0,0 +1,9 @@
+/** Colours for what the command line prints. */
+export declare const c: {
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    success: (text: string) => string;
+    error: (text: string) => string;
+    warning: (text: string) => string;
+    accent: (text: string) => string;
+};

package/dist/pi-launch.d.ts

@@ -0,0 +1 @@
+import "./terminal-images.ts";