@jinn-network/jinn-layer 0.1.0

package/dist/distill-prompt.js

@@ -0,0 +1,85 @@
+/**
+ * `jinn-skill-distill-prompt-v1` — the layer-1-evidence → layer-2-skill
+ * distillation prompt (spec/2026-07-06-distillation-v1.md §7, D4/D10 + v0.5).
+ *
+ * Three modes keyed to the cluster's tier (§7), following the SkillRL
+ * decomposition (arXiv 2602.08234, §2.4) plus the ExpeL contrastive axis:
+ * successes → strategic patterns; evaluator-confirmed failures → failure
+ * lessons stated as DIAGNOSIS, not prescription (the verified-counterfactual
+ * rule — the evidence verifies THAT an attempt failed, not the fix); and
+ * both-polarity instances → one contrastive skill whose counterfactual IS the
+ * verified pass. Every mode emits the fixed skeleton and a trigger/anti-trigger
+ * description. Single-shot and flat for v1 (recursion/hierarchy are v3).
+ *
+ * Like `SESSION_DERIVED_DISTILL_PROMPT_V1`, this is a foundation reference
+ * implementation, not protocol canon: a later network-task version may
+ * substitute it, and the SHA-256 below is published on every distilled skill
+ * (`metadata.jinn.distillPromptSha256`) so generated skills stay auditable.
+ */
+export const JINN_SKILL_DISTILL_PROMPT_V1 = `You distil verified agent evidence into ONE reusable Agent-Skill (a SKILL.md package).
+
+Input: a cluster of evaluator-verified traces for one coding sub-problem, and a MODE.
+
+MODE = strategic-pattern (the traces are SUCCESSES):
+- Extract the critical decision points and the generalizable behavior that made the solve work — the strategy a future agent should reuse, not the specific diff.
+
+MODE = failure-lesson (the traces are evaluator-confirmed FAILURES):
+- The evidence verifies THAT this approach failed — it does NOT verify what would have worked. State the DIAGNOSIS: the failure point and WHY the approach fails ("this fails because …"). Do NOT prescribe a fix as fact. You MAY offer a hypothesis, but it must be explicitly marked as one ("likely …", "consider …") — never an imperative "instead, do X" or "the correct fix is X". A verified counterfactual is only available in contrastive mode.
+
+MODE = contrastive (the traces are BOTH a verified PASS and a confirmed FAIL of the SAME problem):
+- The delta between the pass and the fail is the signal — extract the causal decision that separates success from failure (what the passing attempt did that the failing one did not). Here the counterfactual IS verified (the pass really worked), so you MAY state it as fact.
+
+Every skill (all modes):
+- Produce a name (lowercase-hyphen), a description, and a markdown body.
+- The description is the retrieval surface and MUST carry BOTH a trigger and an anti-trigger: "Use when … Not for: …". The anti-trigger names the nearby-but-situationally-wrong case the skill must NOT fire on. For a failure-lesson the trigger is the RISKY situation and the anti-trigger the safe lookalike.
+- The body MUST use EXACTLY these five sections, each non-empty, in this order:
+  ## When to use
+  ## Strategy
+  ## Steps
+  ## Pitfalls
+  ## Verify
+- Generalize: name the transferable rule, not the instance. Do NOT copy verbatim diff hunks, file paths, symbol names, instance ids, or PR numbers — those are contamination and are rejected downstream.
+- Never include secrets, keys, tokens, or credentials. A skill has no legitimate need to carry raw key material.
+- Use placeholder paths (/path/to/project) and invented example identifiers. Never real home directories (/Users/<name>, /home/<name>), real email addresses, or machine-specific paths — the output scrub redacts those shapes, and ANY redaction drops the whole skill (fail-closed), deterministically, on every retry.
+- Be concise. A skill that restates the raw trace has not earned its place over just retrieving the trace.`;
+// sha256(JINN_SKILL_DISTILL_PROMPT_V1), verified in distill.test.ts. Recomputed
+// on every prompt edit (v0.5: three modes + verified-counterfactual + skeleton).
+export const JINN_SKILL_DISTILL_PROMPT_V1_SHA256 = '44bf8cad03c6d3c17dd726e0f0b9a3375703028bc4be08d15804442626c6c195';
+/**
+ * `jinn-skill-meta-distill-prompt-v1` — the stage-2 cross-instance meta-distill
+ * prompt (issue #1463). Input is a BATCH of stage-1 skills that already share a
+ * polarity (all strategic-pattern, all failure-lesson, or all contrastive),
+ * each labelled with an opaque source id (s1, s2, …). The task is to find the
+ * ONE rule that recurs across the batch and is corroborated by AT LEAST TWO
+ * DISTINCT instances, and to name which sources corroborate it.
+ *
+ * Like the v1 distill prompt, this is a foundation reference, not protocol
+ * canon; its SHA-256 is published on every meta-distilled skill
+ * (`metadata.jinn.distillPromptSha256`).
+ */
+export const JINN_SKILL_META_DISTILL_PROMPT_V1 = `You distil a BATCH of already-distilled Agent-Skills into ONE higher-order cross-instance Agent-Skill (a SKILL.md package).
+
+Input: a batch of skills, each labelled with an opaque source id (s1, s2, …). Every skill in the batch shares a POLARITY (given below), and each came from a DIFFERENT coding sub-problem instance.
+
+MODE = cross-instance:
+- Find the ONE recurring rule that generalises across the batch — the pattern, lesson, or delta that shows up in two or more of the sources for DIFFERENT instances. A rule that appears in only a single source is NOT cross-instance evidence and must not be emitted.
+- Corroboration is the signal: emit a skill only for a rule that at least two DISTINCT sources support. List those source ids in "supports".
+
+POLARITY = strategic-pattern: the sources are recurring success strategies — extract the shared generalizable behavior.
+POLARITY = failure-lesson: the sources are recurring failure diagnoses. State the shared DIAGNOSIS ("this class of approach fails because …"). Do NOT prescribe a fix as fact — no imperative "instead, do X" or "the correct fix is X"; a hypothesis MUST be marked as one ("likely …", "consider …"). A verified counterfactual is only available in contrastive polarity.
+POLARITY = contrastive: the sources are recurring pass↔fail deltas — extract the shared causal decision that separates success from failure; here the counterfactual IS verified, so you MAY state it as fact.
+
+Every skill:
+- Produce a name (lowercase-hyphen), a description, a markdown body, and a "supports" list of the source ids that corroborate the rule.
+- The description is the retrieval surface and MUST carry BOTH a trigger and an anti-trigger: "Use when … Not for: …".
+- The body MUST use EXACTLY these five sections, each non-empty, in this order:
+  ## When to use
+  ## Strategy
+  ## Steps
+  ## Pitfalls
+  ## Verify
+- Generalize: name the transferable rule, not any single instance. Do NOT copy verbatim diff hunks, file paths, symbol names, instance ids, or PR numbers — those are contamination and are rejected downstream.
+- Never include secrets, keys, tokens, or credentials. Use placeholder paths (/path/to/project) and invented example identifiers; never real home directories, emails, or machine-specific paths — the output scrub drops the whole skill (fail-closed) on any redaction.
+- Be concise. A cross-instance skill that merely concatenates its sources has not earned its place.`;
+// sha256(JINN_SKILL_META_DISTILL_PROMPT_V1), verified in distill.test.ts.
+export const JINN_SKILL_META_DISTILL_PROMPT_V1_SHA256 = '6d21ed583cb8f3f3f92449c6b67a247be287a767517a9f83ec891e7f737b388b';

package/dist/distill-render.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Plain-text renderers for the `distill` consent + run surface (issue #1490).
+ *
+ * The 1490 mockup is a colour, keyboard-driven console; this package has no ANSI
+ * layer and its CLI prints plain text (see `renderScrubReport`, `renderRecord`).
+ * So these are pure string renderers that carry the design's *copy* and *states*
+ * faithfully — the load-bearing part — in plain text, with box-drawing panels
+ * (allowed) standing in for the coloured boxes. Status is a WORD, never a glyph
+ * (the brand's ban on `✓/✗` as UI icons), and every string that touches cost or
+ * consent drops all vow-metaphor and says exactly what happens.
+ *
+ * Binary name is `jinn-layer` (the real shipped bin, #1489). The mockup writes
+ * `jinn-agent`; that is a pending branding decision, reconciled later.
+ */
+import type { DistillMode } from './distill-mode.js';
+import type { DistillerCatalogEntry } from './distill-llm.js';
+/** One skill in a run panel: its name, install state, forward value, and sources. */
+export interface RenderedSkill {
+    name: string;
+    installed: boolean;
+    /** Human-readable source-capture labels (task summaries, or the raw ref). */
+    provenance: string[];
+    /**
+     * Forward-looking value: what this skill will help with next time (the
+     * distiller's when-to-use description). Rendered as the `helps` line so the
+     * operator sees what they are getting, not just where it came from.
+     */
+    helpsWith?: string;
+}
+/**
+ * 1a — first-run consent disclosure. Leads with what distillation is FOR, then
+ * states plainly what it READS, what it COSTS (compute, not money), and what
+ * LEAVES the machine (nothing, with the one hosted-distiller exception named).
+ */
+export declare function renderConsentDisclosure(o: {
+    captureCount: number;
+    distillModel: string;
+}): string;
+/** 1a — the preview screen: exactly what a run would read and the distiller. */
+export declare function renderPreview(o: {
+    captures: {
+        summary: string;
+        when: string;
+        size: string;
+    }[];
+    distillModel: string;
+}): string;
+/** 1a — confirm the one spend before a local run. */
+export declare function renderConfirmLocal(o: {
+    captureCount: number;
+    distillModel: string;
+}): string;
+/** 1c — one-line echo after `distill --where <mode>` sets the persistent mode. */
+export declare function renderModeSet(mode: DistillMode): string;
+/** One-line echo after `distill --set-distiller[-model]` records a default. */
+export declare function renderDistillerSet(o: {
+    distiller?: 'claude' | 'codex';
+    distillerModel?: string;
+}): string;
+/**
+ * `distill models` — the discoverable catalog. One row per runnable distiller
+ * with its execution/cost/privacy attributes; the currently-resolved default
+ * is marked with the word `(default)` (never a glyph).
+ */
+export declare function renderDistillerModels(o: {
+    catalog: readonly DistillerCatalogEntry[];
+    resolved: {
+        provider: string;
+        model: string;
+    };
+}): string;
+/** 1c — what a bare `distill` prints while the mode is defer: it runs nothing. */
+export declare function renderDeferredRun(o: {
+    captureCount: number;
+    capturesDir: string;
+}): string;
+/** 1a — the recorded-state confirmation after a mode is chosen. */
+export declare function renderRecorded(mode: DistillMode, o: {
+    captureCount: number;
+}): string;
+/** 1d — nothing to distill yet: say what produces a capture. */
+export declare function renderEmpty(o: {
+    capturesDir: string;
+}): string;
+/**
+ * 1b — the skills panel: per-skill install-state word + name, then the
+ * forward-looking `helps` line (what it will help with next) and the backward
+ * `from` line (which captures it came from).
+ */
+export declare function renderSkillsPanel(skills: RenderedSkill[], title: string): string;
+/**
+ * 1b — the run terminus. Header, captures→skills summary, the skills panel with
+ * per-skill install state, and a footer keyed to the install outcome (none
+ * installed = staged/how-to-install, all = ready, some = partial).
+ */
+export declare function renderRunSummary(o: {
+    distillModel: string;
+    captureCount: number;
+    skills: RenderedSkill[];
+}): string;
+/**
+ * 1b — the review shown before the install choice (interactive). Frames the
+ * skills FORWARD — what they'll help with next — then asks for an explicit
+ * all / one / skip choice. Nothing is installed until the operator answers.
+ */
+export declare function renderReview(o: {
+    distillModel: string;
+    captureCount: number;
+    skills: RenderedSkill[];
+}): string;
+/** 1d — a run failed mid-way: what stopped, what survived, one resume command. */
+export declare function renderFailure(o: {
+    distillModel: string;
+    distilledCount: number;
+    errors: {
+        clusterId: string;
+        error: string;
+    }[];
+}): string;
+/** 1c/1d — `--resume` with no capture left to distill. */
+export declare function renderResumeNothing(o: {
+    captureCount: number;
+}): string;

package/dist/distill-render.js

@@ -0,0 +1,303 @@
+/**
+ * Plain-text renderers for the `distill` consent + run surface (issue #1490).
+ *
+ * The 1490 mockup is a colour, keyboard-driven console; this package has no ANSI
+ * layer and its CLI prints plain text (see `renderScrubReport`, `renderRecord`).
+ * So these are pure string renderers that carry the design's *copy* and *states*
+ * faithfully — the load-bearing part — in plain text, with box-drawing panels
+ * (allowed) standing in for the coloured boxes. Status is a WORD, never a glyph
+ * (the brand's ban on `✓/✗` as UI icons), and every string that touches cost or
+ * consent drops all vow-metaphor and says exactly what happens.
+ *
+ * Binary name is `jinn-layer` (the real shipped bin, #1489). The mockup writes
+ * `jinn-agent`; that is a pending branding decision, reconciled later.
+ */
+const BIN = 'jinn-layer';
+function plural(n, one) {
+    return `${n} ${one}${n === 1 ? '' : 's'}`;
+}
+// ── boxed panel (plain analogue of the mockup's coloured box) ────────────────
+// The three border rows and every body row share one frame width (IW + 4), so
+// the panel never overflows its widest line.
+function boxTop(iw, title) {
+    const t = ` ${title} `;
+    return `┌─${t}${'─'.repeat(Math.max(0, iw + 1 - t.length))}┐`;
+}
+function boxBot(iw) {
+    return `└${'─'.repeat(iw + 2)}┘`;
+}
+function boxLine(iw, content) {
+    const clipped = content.length > iw ? content.slice(0, iw) : content;
+    return `│ ${clipped}${' '.repeat(Math.max(0, iw - clipped.length))} │`;
+}
+function box(title, contentLines) {
+    const iw = Math.max(title.length + 1, ...contentLines.map((l) => l.length), 40);
+    return [boxTop(iw, title), ...contentLines.map((l) => boxLine(iw, l)), boxBot(iw)].join('\n');
+}
+/** Width of the install-state column (mockup uses 14). */
+const STATE_COL = 14;
+/**
+ * 1a — first-run consent disclosure. Leads with what distillation is FOR, then
+ * states plainly what it READS, what it COSTS (compute, not money), and what
+ * LEAVES the machine (nothing, with the one hosted-distiller exception named).
+ */
+export function renderConsentDisclosure(o) {
+    return [
+        `  Distill your recent tasks into skills?`,
+        '',
+        `  A frontier-class model reads the tasks you've run here, once, and pulls`,
+        `  out reusable skills — later tasks then reuse them on a small, cheap model.`,
+        `  Pay the heavy pass once; reuse the skills for free.`,
+        '',
+        `  READS    ${plural(o.captureCount, 'capture')} this run — the tasks you've run here so far, more`,
+        `           as you work. Nothing else.`,
+        '',
+        `  COSTS    one pass of heavy compute — not money — and it runs here, on`,
+        `           this machine.`,
+        '',
+        `  LEAVES   nothing — read, distilled, and written here; nothing is published`,
+        `           to the Jinn network. A hosted distiller (below) is the one`,
+        `           exception; ${BIN} names it and asks first.`,
+        '',
+        `  DISTILLER  ${o.distillModel} (local) — the model that writes the skills, and`,
+        `             yours to choose. Change with --distiller <provider> or`,
+        `             --distiller-model <model>.`,
+        '',
+        `  [L] Local now   ·   [F] Defer (default)   ·   [O] Off   ·   [P] Preview`,
+        '',
+        `  distill: unset — default is defer, nothing runs, nothing is spent`,
+    ].join('\n');
+}
+/** 1a — the preview screen: exactly what a run would read and the distiller. */
+export function renderPreview(o) {
+    const rows = o.captures.map((c) => boxLine(54, `${c.when.padEnd(9)}${c.summary}`));
+    const iw = 54;
+    const panel = [
+        boxTop(iw, 'captures · read locally, never sent'),
+        ...rows,
+        boxBot(iw),
+    ].join('\n');
+    return [
+        `  PREVIEW — NOTHING RUNS FROM THIS SCREEN`,
+        `  The exact captures a run would read, and the distiller it would use.`,
+        '',
+        panel,
+        '',
+        `  distiller  ${o.distillModel} (local, default) · change with --distiller`,
+        `  With the local default, none of this leaves the machine.`,
+        '',
+        `  [L] Run local now   ·   [B] Back`,
+    ].join('\n');
+}
+/** 1a — confirm the one spend before a local run. */
+export function renderConfirmLocal(o) {
+    return [
+        `  CONFIRM`,
+        '',
+        `  Run distillation now? One frontier pass with ${o.distillModel} over`,
+        `  ${plural(o.captureCount, 'capture')}, here on this machine — heavy compute, no money, nothing`,
+        `  sent. Stop any time; whatever finished is kept.`,
+        '',
+        `  [Y] Yes, run now   ·   [N] No, go back`,
+    ].join('\n');
+}
+/** 1c — one-line echo after `distill --where <mode>` sets the persistent mode. */
+export function renderModeSet(mode) {
+    switch (mode) {
+        case 'local':
+            return `distill: mode set to local. Runs here with a frontier-class model.`;
+        case 'defer':
+            return `distill: mode set to deferred. Captures held locally; nothing runs or publishes.`;
+        case 'off':
+            return `distill: mode set to off. Captures are not reserved for distillation.`;
+    }
+}
+/** One-line echo after `distill --set-distiller[-model]` records a default. */
+export function renderDistillerSet(o) {
+    const parts = [];
+    if (o.distiller !== undefined)
+        parts.push(`provider ${o.distiller}`);
+    if (o.distillerModel !== undefined)
+        parts.push(`model ${o.distillerModel}`);
+    return `distill: default distiller set — ${parts.join(', ')}. Applies to future runs; a per-run --distiller[-model] flag still wins.`;
+}
+/**
+ * `distill models` — the discoverable catalog. One row per runnable distiller
+ * with its execution/cost/privacy attributes; the currently-resolved default
+ * is marked with the word `(default)` (never a glyph).
+ */
+export function renderDistillerModels(o) {
+    const iw = 74;
+    const rows = o.catalog.map((e) => {
+        const isResolved = e.provider === o.resolved.provider && e.model === o.resolved.model;
+        const mark = isResolved ? ' (default)' : '';
+        return boxLine(iw, `${e.provider.padEnd(8)}${e.execution.padEnd(8)}${e.cost.padEnd(22)}${e.model}${mark}`);
+    });
+    const panel = [
+        boxTop(iw, 'distillers · the model that writes your skills'),
+        boxLine(iw, `${'provider'.padEnd(8)}${'run'.padEnd(8)}${'cost'.padEnd(22)}model`),
+        ...rows,
+        boxBot(iw),
+    ].join('\n');
+    return [
+        panel,
+        '',
+        ...o.catalog.map((e) => `  ${e.model} — ${e.privacy}`),
+        '',
+        `  Set a default  ·  ${BIN} distill --set-distiller <provider>  |  --set-distiller-model <model>`,
+        `  Override once  ·  ${BIN} distill --distiller <provider>  |  --distiller-model <model>`,
+    ].join('\n');
+}
+/** 1c — what a bare `distill` prints while the mode is defer: it runs nothing. */
+export function renderDeferredRun(o) {
+    return [
+        `  distill: deferred — ${plural(o.captureCount, 'capture')} held locally, nothing runs.`,
+        '',
+        `  They stay on this machine and are not published. When the bonded network`,
+        `  can distill a contributed signal, you'll be asked before anything leaves`,
+        `  this machine. (not available yet — rung 3)`,
+        '',
+        `  Run locally now  ·  ${BIN} distill --where local`,
+    ].join('\n');
+}
+/** 1a — the recorded-state confirmation after a mode is chosen. */
+export function renderRecorded(mode, o) {
+    switch (mode) {
+        case 'local':
+            return [
+                `  recorded — distill mode is LOCAL`,
+                '',
+                `  Distillation runs on this machine with a frontier-class model.`,
+                '',
+                `  Change any time  ·  ${BIN} distill --where defer  |  --where off`,
+            ].join('\n');
+        case 'defer':
+            return [
+                `  recorded — distill mode is DEFERRED`,
+                '',
+                `  Your ${plural(o.captureCount, 'capture')} are held on this machine. Nothing runs, nothing is`,
+                `  spent, and nothing is published to the Jinn network.`,
+                '',
+                `  Run locally instead  ·  ${BIN} distill --where local`,
+            ].join('\n');
+        case 'off':
+            return [
+                `  recorded — distill is OFF`,
+                '',
+                `  Distillation is disabled and no captures are reserved for it. Nothing`,
+                `  the harness already keeps is deleted — this only turns distilling off.`,
+                '',
+                `  Turn it on any time  ·  ${BIN} distill --where local  |  --where defer`,
+            ].join('\n');
+    }
+}
+/** 1d — nothing to distill yet: say what produces a capture. */
+export function renderEmpty(o) {
+    return [
+        `  No eligible captures.`,
+        '',
+        `  Distillation reads captures — the tasks you've run with the harness.`,
+        `  There aren't any yet — run a task first, then run \`${BIN} distill\` again.`,
+        '',
+        `  (looked in ${o.capturesDir})`,
+    ].join('\n');
+}
+/**
+ * 1b — the skills panel: per-skill install-state word + name, then the
+ * forward-looking `helps` line (what it will help with next) and the backward
+ * `from` line (which captures it came from).
+ */
+export function renderSkillsPanel(skills, title) {
+    const content = [];
+    skills.forEach((s, i) => {
+        const state = (s.installed ? 'installed' : 'not installed').padEnd(STATE_COL);
+        content.push(`${state}${s.name}`);
+        if (s.helpsWith)
+            content.push(`${' '.repeat(STATE_COL)}helps  ${s.helpsWith}`);
+        content.push(`${' '.repeat(STATE_COL)}from   ${s.provenance.join(' · ')}`);
+        if (i < skills.length - 1)
+            content.push('');
+    });
+    return box(title, content);
+}
+/** Title + footer for the run terminus, keyed to how many skills are installed. */
+function runSummaryChrome(installed, total) {
+    if (installed === 0) {
+        return {
+            title: 'skills · distilled locally · not installed',
+            footer: [
+                `  They stay local until you install them — nothing goes live until you choose.`,
+                `  Install  ·  ${BIN} distill --install all   ·   --install <name>   ·   --install none`,
+                `  List them  ·  /jinn skills`,
+            ],
+        };
+    }
+    if (installed === total) {
+        return {
+            title: 'skills · installed · ready',
+            footer: [
+                `  Next runs use these on a small model — no frontier pass.`,
+                `  Manage  ·  /jinn skills   ·   /jinn skills remove <name>`,
+            ],
+        };
+    }
+    return {
+        title: `skills · ${installed} installed · ${total - installed} available`,
+        footer: [
+            `  Installed skills run on a small model next time — no frontier pass.`,
+            `  Install the rest  ·  ${BIN} distill --install all`,
+            `  Manage  ·  /jinn skills`,
+        ],
+    };
+}
+/**
+ * 1b — the run terminus. Header, captures→skills summary, the skills panel with
+ * per-skill install state, and a footer keyed to the install outcome (none
+ * installed = staged/how-to-install, all = ready, some = partial).
+ */
+export function renderRunSummary(o) {
+    const installed = o.skills.filter((s) => s.installed).length;
+    const { title, footer } = runSummaryChrome(installed, o.skills.length);
+    return [
+        `  distill: local · distiller ${o.distillModel} · ${plural(o.captureCount, 'capture')}`,
+        '',
+        `  distilled · ${plural(o.captureCount, 'capture')} → ${plural(o.skills.length, 'skill')} · nothing left this machine`,
+        '',
+        renderSkillsPanel(o.skills, title),
+        '',
+        ...footer,
+    ].join('\n');
+}
+/**
+ * 1b — the review shown before the install choice (interactive). Frames the
+ * skills FORWARD — what they'll help with next — then asks for an explicit
+ * all / one / skip choice. Nothing is installed until the operator answers.
+ */
+export function renderReview(o) {
+    return [
+        `  distill: local · distiller ${o.distillModel} · ${plural(o.captureCount, 'capture')}`,
+        '',
+        `  distilled ${plural(o.skills.length, 'skill')} — they'll help with tasks like these next time:`,
+        '',
+        renderSkillsPanel(o.skills.map((s) => ({ ...s, installed: false })), 'skills · distilled locally · not installed'),
+        '',
+        `  Install all, one, or skip? Nothing goes live until you choose.`,
+    ].join('\n');
+}
+/** 1d — a run failed mid-way: what stopped, what survived, one resume command. */
+export function renderFailure(o) {
+    const first = o.errors[0]?.error ?? 'the distiller stopped responding';
+    return [
+        `  distill failed — ${first}`,
+        '',
+        `  ${plural(o.distilledCount, 'skill')} were distilled and kept. ${plural(o.errors.length, 'cluster')} did not`,
+        `  finish; the rest weren't distilled. Nothing was sent or lost.`,
+        '',
+        `  Resume the rest  ·  ${BIN} distill --resume`,
+        `  See what's done  ·  /jinn skills`,
+    ].join('\n');
+}
+/** 1c/1d — `--resume` with no capture left to distill. */
+export function renderResumeNothing(o) {
+    return `Nothing to resume — all ${plural(o.captureCount, 'capture')} are already distilled.`;
+}

package/dist/distill-runs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The distill run log (#1535): one JSON line per own-captures run, appended on
+ * every terminal outcome (ok / partial / empty). This is the history behind
+ * `distill runs` and the `lastRun` field of `distill status` — without it a
+ * completed run's only trace was the staged/installed skills themselves.
+ *
+ * Mirrors the ledger's shape discipline: append-only JSONL, corrupt-line
+ * tolerant reads (a bad line is skipped, never fatal).
+ */
+/** One recorded run — the `run_end` facts plus when it started. */
+export interface DistillRunRecord {
+    runId: string;
+    startedAt: string;
+    durationMs: number;
+    outcome: 'ok' | 'partial' | 'empty';
+    clusterCount: number;
+    published: string[];
+    rejectedCount: number;
+    errorCount: number;
+    installed: string[];
+    distillModel: string;
+}
+/** The default run log, alongside the layer's other operator state. */
+export declare const DEFAULT_DISTILL_RUNS_PATH: string;
+/** Append one run record, creating the parent directory if needed. */
+export declare function appendDistillRun(record: DistillRunRecord, path?: string): void;
+/** Read up to `limit` runs, newest-first. Corrupt lines are skipped. */
+export declare function readDistillRuns(limit: number, path?: string): DistillRunRecord[];

package/dist/distill-runs.js

@@ -0,0 +1,39 @@
+/**
+ * The distill run log (#1535): one JSON line per own-captures run, appended on
+ * every terminal outcome (ok / partial / empty). This is the history behind
+ * `distill runs` and the `lastRun` field of `distill status` — without it a
+ * completed run's only trace was the staged/installed skills themselves.
+ *
+ * Mirrors the ledger's shape discipline: append-only JSONL, corrupt-line
+ * tolerant reads (a bad line is skipped, never fatal).
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/** The default run log, alongside the layer's other operator state. */
+export const DEFAULT_DISTILL_RUNS_PATH = join(homedir(), '.jinn-client', 'harness-layer', 'distill-runs.jsonl');
+/** Append one run record, creating the parent directory if needed. */
+export function appendDistillRun(record, path = DEFAULT_DISTILL_RUNS_PATH) {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(record) + '\n', { encoding: 'utf-8' });
+}
+/** Read up to `limit` runs, newest-first. Corrupt lines are skipped. */
+export function readDistillRuns(limit, path = DEFAULT_DISTILL_RUNS_PATH) {
+    if (!existsSync(path))
+        return [];
+    const records = [];
+    for (const line of readFileSync(path, 'utf-8').split('\n')) {
+        if (line.trim() === '')
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed === 'object' && parsed !== null && typeof parsed.outcome === 'string') {
+                records.push(parsed);
+            }
+        }
+        catch {
+            // Tolerate a corrupt line — the log must never brick the CLI.
+        }
+    }
+    return records.reverse().slice(0, limit);
+}

package/dist/distill-traces.d.ts

@@ -0,0 +1,67 @@
+import type { CapturedTask } from './capture.js';
+export type TraceReadMode = 'summary' | 'events' | 'tool_calls' | 'transcript_excerpt' | 'full_transcript';
+export type EstimatedDistillCost = 'low' | 'medium' | 'high';
+export type EvidenceTierEstimate = 'single-example' | 'recurring-pattern' | 'contrastive';
+export interface LocalTraceCard {
+    traceId: string;
+    sessionId: string;
+    sourceTool: string;
+    repo?: string;
+    startedAt: string;
+    durationMs: number;
+    summary: string;
+    tools: string[];
+    commands: string[];
+    filesTouched: string[];
+    errorSnippets: string[];
+    outcome: CapturedTask['outcome']['status'];
+    skillsUsed: string[];
+    redactionFlags: string[];
+}
+export interface TraceEventView {
+    spanId: string;
+    kind: string;
+    name: string;
+    text?: string;
+    toolName?: string;
+    attributes?: Record<string, unknown>;
+}
+export interface TraceReadResult {
+    mode: TraceReadMode;
+    traceId: string;
+    summary: string;
+    events?: TraceEventView[];
+    toolCalls?: TraceEventView[];
+}
+export interface TraceSearchQuery {
+    query?: string;
+    command?: string;
+    file?: string;
+    error?: string;
+    tool?: string;
+    outcome?: CapturedTask['outcome']['status'];
+    limit?: number;
+}
+export interface TraceCandidate {
+    candidateId: string;
+    title: string;
+    traceIds: string[];
+    repeatedSignals: {
+        commands?: string[];
+        errors?: string[];
+        files?: string[];
+    };
+    evidenceTierEstimate: EvidenceTierEstimate;
+    estimatedSourceTokens: number;
+    estimatedDistillCost: EstimatedDistillCost;
+    privacyFlags: string[];
+}
+export declare function traceCardFromCapture(task: CapturedTask): LocalTraceCard;
+export declare function readTrace(task: CapturedTask, opts: {
+    mode: TraceReadMode;
+    query?: string;
+    limit?: number;
+    allowFullTranscript?: boolean;
+}): TraceReadResult;
+export declare function searchTraceCards(cards: LocalTraceCard[], query: TraceSearchQuery): LocalTraceCard[];
+export declare function clusterTraceCards(cards: LocalTraceCard[]): TraceCandidate[];