@skill-harness/cli 0.17.0 → 0.19.0

package/README.md

@@ -24,19 +24,6 @@ npm i -g @skill-harness/cli
 | `skill-harness grade <run-dir> [--judge p:m]` | re-grade saved transcripts |
 | `skill-harness review <skill> --skills <root> [--port N]` | serve the interactive review UI |
 | `skill-harness add-test <skill> --skills <root> --id ID --title T ...` | scaffold a new scenario |
-| `skill-harness qualification prepare\|start\|status\|poll\|validate\|abort ...` | durable external-config qualification lifecycle |
-
-## Retained learning
-
-`skill-harness learning` opens the guided offline workflow; `learning help` documents
-named retained inputs, complete quality review, scoped trust, independent labels,
-separate adoption decisions and later observations. No hand-authored manifests or model calls.
-The Pi package exposes the same flow as `/skill-harness learning`; connected producer registry
-activation/rollback remain separately authorized operations, never a side effect of reading.
-`@skill-harness/cli/learning` exports `runLearningCommand`, `runLearningWizard` and
-`reviewLearningComparison` for the existing producer dashboard bridge.
-
-[Product guide](https://github.com/mojomanyana/skill-harness/blob/main/docs/factory/PRODUCT-GUIDE.md).
 
 ## More
 

package/assets/report.template.html

@@ -255,13 +255,7 @@ function render() {
       const objMark = obj
         ? `<span class='lm obj-${obj.status.toLowerCase()}' title='${escapeHtml(`objective ${obj.status}: ${obj.detail}`)}'>◉ ${escapeHtml(obj.status.toLowerCase())}</span>`
         : "";
-      // Adjudication. `unresolved` is amber and says so in words — a disagreement
-      // that renders as a clean verdict is the whole failure this feature prevents.
-      const adj = cell.adjudication;
-      const adjMark = adj
-        ? `<span class='lm adj-${adj.state === "unresolved" ? "unresolved" : "settled"}' title='${escapeHtml(`adjudication ${adj.state} (${adj.trigger}) · ${adj.detail}`)}'>⚖ ${adj.state === "unresolved" ? "unresolved" : `${adj.count} agree`}</span>`
-        : "";
-      html += `<td class='cell ${v}${sel}' data-col='${col.index}' data-id='${scn.id}'>${v}${ov}${suspectBadge}${liftMark}${stabMark}${objMark}${adjMark}${reps}</td>`;
+      html += `<td class='cell ${v}${sel}' data-col='${col.index}' data-id='${scn.id}'>${v}${ov}${suspectBadge}${liftMark}${stabMark}${objMark}${reps}</td>`;
     });
     html += "</tr>";
   }
@@ -290,7 +284,6 @@ async function openPanel(colIndex, scenarioId) {
     ${cell.suspect ? `<div class="reason" style="color:#b45309"><b>⚠ suspect:</b> judge listed no failed item — re-judge before trusting this FAIL</div>` : ""}
     ${cell.stability ? `<div class="reason" style="color:#b45309"><b>⇄ boundary cell:</b> ${escapeHtml(cell.stability.note)}</div>` : ""}
     ${cell.objective ? `<div class="reason"><b>◉ objective ${escapeHtml(cell.objective.status)}:</b> ${escapeHtml(cell.objective.detail)}</div>` : ""}
-    ${cell.adjudication ? `<div class="reason"${cell.adjudication.state === "unresolved" ? ' style="color:#b45309"' : ""}><b>⚖ adjudication ${escapeHtml(cell.adjudication.state)}</b> (${escapeHtml(cell.adjudication.trigger)}): ${escapeHtml(cell.adjudication.detail)}</div>` : ""}
     ${cell.metrics ? `<div class="reason"><b>cost/latency:</b> ${cell.metrics.input_tokens == null ? "subject tokens unavailable" : `${cell.metrics.input_tokens} input / ${cell.metrics.output_tokens || 0} output / ${cell.metrics.cache_read_tokens || 0} cache-read`} (${cell.metrics.subject_metrics_reps}/${cell.metrics.total_reps} reps) · ${cell.metrics.judge_calls} judge + ${cell.metrics.judge_rejudge_calls} re-judge · ${cell.metrics.wall_time_ms}ms · ${cell.metrics.tool_calls == null ? "tool calls unavailable" : `${cell.metrics.tool_calls} tools, ${cell.metrics.delegated_children || 0} delegated, max concurrency ${cell.metrics.max_concurrency || 0}`}</div>` : ""}
     <div class="toggle">
       <button data-v="PASS" class="PASS ${cell.override === 'PASS' ? 'active PASS' : ''}">PASS</button>
@@ -298,7 +291,6 @@ async function openPanel(colIndex, scenarioId) {
       <button data-v="" class="JUDGE ${!cell.override ? 'active JUDGE' : ''}">use judge (${cell.judge_verdict})</button>
     </div>
     <div class="rejudge"><button id="rejudgeBtn">Re-judge (${escapeHtml(col.judge.provider + ":" + col.judge.model)})</button> <span class="saved" id="rejudged"></span></div>
-    <div class="rejudge"><button id="adjBtn">Adjudicate column…</button> <span class="saved" id="adjudged"></span></div>
     <label class="fld">note <span class="saved" id="saved">saved ✓</span></label>
     <textarea id="note" placeholder="why you overrode / what to fix in SKILL.md">${escapeHtml(cell.note || "")}</textarea>
     <label class="fld">transcript</label>
@@ -323,40 +315,6 @@ async function openPanel(colIndex, scenarioId) {
       location.reload(); // re-judge rewrote results.yaml; reload the fresh matrix + grades
     } catch (e) { rj.disabled = false; rj.textContent = "Re-judge"; }
   };
-
-  // Two requests on purpose. The first prices the work and spends nothing; the
-  // confirm shows that exact ceiling; only then does anything call a judge. A
-  // single endpoint could not disclose a count before charging for it.
-  const adjBtn = document.getElementById("adjBtn");
-  if (adjBtn) adjBtn.onclick = async () => {
-    const status = document.getElementById("adjudged");
-    const show = (msg, err) => { if (status) { status.textContent = msg; status.classList.toggle("err", !!err); status.classList.add("show"); } };
-    adjBtn.disabled = true;
-    try {
-      const pr = await fetch("/adjudicate", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ col: colIndex, step: "plan" }) });
-      const plan = await pr.json().catch(() => ({}));
-      if (!pr.ok || !plan.ok) { show(plan.error || "could not plan adjudication", true); adjBtn.disabled = false; return; }
-      if (!plan.triggered.length) { show("no cell triggered — nothing to adjudicate", false); adjBtn.disabled = false; return; }
-
-      // Counts, never dollars: the default judge is a Claude subscription and
-      // reports no per-call usage, so a cost figure here would be invented.
-      const ok = window.confirm(
-        `Adjudicate ${plan.triggered.length} cell(s) with ${plan.judge}?\n\n` +
-        `Up to ${plan.maxAdditionalCalls} additional judge call(s).\n` +
-        `No tie-break judge from the browser — a disagreement stays unresolved and blocks SHIP.\n\n` +
-        plan.detail.join("\n")
-      );
-      if (!ok) { show("cancelled — nothing spent", false); adjBtn.disabled = false; return; }
-
-      adjBtn.textContent = "Adjudicating…";
-      const rr = await fetch("/adjudicate", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ col: colIndex, step: "run" }) });
-      const done = await rr.json().catch(() => ({}));
-      if (!rr.ok || !done.ok) { show(done.error || "adjudication failed", true); adjBtn.disabled = false; adjBtn.textContent = "Adjudicate column…"; return; }
-      location.reload();
-    } catch (e) {
-      show("adjudication failed", true); adjBtn.disabled = false; adjBtn.textContent = "Adjudicate column…";
-    }
-  };
   let t;
   document.getElementById("note").addEventListener("input", (e) => {
     cell.note = e.target.value;

package/dist/cli.d.ts

@@ -23,21 +23,13 @@ export declare function releaseExitCode(summaries: Array<{
     };
 }>): 0 | 1;
 export declare function cmdRun(args: Args): Promise<void>;
-export declare function cmdCompare(args: Args, adapterOverride?: HarnessAdapter): Promise<void>;
 export declare function cmdGrade(args: Args, adapterOverride?: HarnessAdapter): Promise<void>;
-/**
- * Re-score saved runs against the current spec's thresholds — no model or judge calls.
- * Reps are the measurement; thresholds are policy. When policy changes, recompute rather
- * than reconcile two numbers in prose.
- */
-export declare function cmdJudgeAgreement(args: Args): void;
 /**
  * Re-evaluate needle gates against the saved staged diffs — no subject call. A rep
  * whose gate verdict flips from fail to pass was never judged and costs one judge call.
  * The completion summary reports how many judge calls were made.
  */
 export declare function cmdRegate(args: Args, adapterOverride?: HarnessAdapter): Promise<void>;
-export declare function cmdScreen(args: Args): Promise<void>;
 export declare function cmdInit(args: Args): Promise<void>;
 export declare function cmdSuggest(args: Args, adapterOverride?: HarnessAdapter): Promise<void>;
 /**

package/dist/cli.js

@@ -1,15 +1,10 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, mkdirSync, writeFileSync, mkdtempSync, rmSync, readdirSync } from "node:fs";
-import { load as yamlLoad } from "js-yaml";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { basename, dirname, join, resolve, relative } from "node:path";
 import { tmpdir } from "node:os";
-import { discover, resolveSkill, loadSpec, parseSpec, appendScenario, parseModelRef, runSkillModel, formatScorecard, readResults, regradeRun, lintSkill, failsGate, renderTemplateSpec, isTemplateSpec, renderDraftSpec, buildSuggestPrompt, parseSuggestDraft, rescoreRun, regateRun, specPathForRunDir, collectLift, collectStability, boundaryCells, stabilityNote, PATH_LEGEND, restampSkill, resolveAdjudicationJudges, adjudicateRun, judgeResemblesSubject, computeCoverage, formatCoverage, selectAffected, formatAffected, gitDiff, exec, HARNESS_VERSION, defaultJudge, assertJudgeAllowed, judgeAgreement, assertNotDowngraded, downgradeWarning, isScoredMode, resolveArm, isFreeOfflineCommand, screenResults, formatScreen, } from "@skill-harness/core";
+import { discover, resolveSkill, loadSpec, parseSpec, appendScenario, parseModelRef, runSkillModel, formatScorecard, readResults, regradeRun, lintSkill, failsGate, renderTemplateSpec, isTemplateSpec, renderDraftSpec, buildSuggestPrompt, parseSuggestDraft, rescoreRun, regateRun, specPathForRunDir, collectLift, collectStability, boundaryCells, stabilityNote, PATH_LEGEND, restampSkill, computeCoverage, formatCoverage, HARNESS_VERSION, defaultJudge, assertJudgeAllowed, assertNotDowngraded, downgradeWarning, isScoredMode, resolveArm, isFreeOfflineCommand, } from "@skill-harness/core";
 import { getAdapter } from "@skill-harness/adapters";
 import { serveReview } from "./serve.js";
-import { runCompareCommand } from "./compare.js";
-import { cmdQualification } from "./qualification.js";
-import { cmdArchive } from "./archive.js";
-import { runLearningCommand } from "./learning.js";
 const DEFAULT_MODEL = "fireworks:accounts/fireworks/models/deepseek-v4-pro";
 // The judge default lives in core (`defaultJudge()`), which resolves
 // SKILL_HARNESS_JUDGE over a baked value — it was duplicated in three places
@@ -46,6 +41,16 @@ function parseArgs(argv) {
     }
     return { _, flags, multi };
 }
+function assertNoRetiredFlags(command, args) {
+    const retired = command === "run"
+        ? ["affected"]
+        : command === "grade"
+            ? ["auto-rejudge", "secondary-judge", "tie-break-judge"]
+            : [];
+    const found = retired.find((flag) => Object.hasOwn(args.flags, flag));
+    if (found)
+        throw new Error(`--${found} was removed; this command refuses to silently run with different behavior`);
+}
 export function flagStr(args, key, fallback) {
     const v = args.flags[key];
     if (typeof v === "string")
@@ -143,11 +148,7 @@ export async function cmdRun(args) {
     // that was never the problem. Free, offline validation first — it is also why
     // CI, which has no `pi`, could not test this refusal at all.
     const onlyRaw = flagStr(args, "only");
-    let only = onlyRaw ? onlyRaw.split(",").map((x) => x.trim()).filter(Boolean) : undefined;
-    const affected = flagBool(args, "affected");
-    if (affected && only) {
-        throw new Error("--affected and --only both choose the scenario set — pass one, not both");
-    }
+    const only = onlyRaw ? onlyRaw.split(",").map((x) => x.trim()).filter(Boolean) : undefined;
     const harnessName = flagStr(args, "harness", "pi");
     const adapter = getAdapter(harnessName);
     if (!(await adapter.available()))
@@ -176,17 +177,6 @@ export async function cmdRun(args) {
         // that look comparable and are not. Checked per skill, before its first token.
         assertNotDowngraded(skill.dir, "run");
         const spec = loadSpec(skill.specPath);
-        if (affected) {
-            // Reuses the exact `--only` machinery, so an affected run is partial and
-            // cannot report SHIP — the same guarantee, through the same code path.
-            const result = await computeAffected(args, spec.scenarios, skill.specPath);
-            console.log(formatAffected(result, spec.scenarios.length));
-            only = result.selected.map((sel) => sel.id);
-            if (only.length === 0) {
-                console.log(`skip ${skill.name}: no scenario is affected by this change`);
-                continue;
-            }
-        }
         for (const token of modelTokens) {
             const model = parseModelRef(token);
             // The version is on the banner because a stale global install is otherwise
@@ -229,98 +219,10 @@ export async function cmdRun(args) {
     console.log(`\nReview interactively:  skill-harness review ${skills[0]?.name ?? "<skill>"} --skills ${root}`);
     // A full delivered run is a release gate. NOT READY — including one critical
     // failure hidden by a high aggregate — must be machine-visible to CI. Red
-    // baselines and partial/affected branch feedback are deliberately excluded.
+    // baselines and partial branch feedback are deliberately excluded.
     if (releaseExitCode(summaries) !== 0)
         process.exitCode = 1;
 }
-export async function cmdCompare(args, adapterOverride) {
-    const target = args._[0];
-    const reference = flagStr(args, "reference");
-    const candidateRoot = flagStr(args, "candidate");
-    if (!target || !reference || !candidateRoot) {
-        throw new Error("usage: skill-harness compare <skill|all> --reference <git-ref-or-skills-root> --candidate <skills-root> --model <provider:model> --reps N");
-    }
-    const judgeFlag = flagStr(args, "judge");
-    const judgeToken = judgeFlag ?? defaultJudge();
-    const judge = parseModelRef(judgeToken);
-    assertJudgeAllowed(judge, {
-        source: judgeFlag ? "--judge" : "the default judge (SKILL_HARNESS_JUDGE or the baked value)",
-        allowMetered: flagBool(args, "allow-metered-judge"),
-    });
-    const harnessName = flagStr(args, "harness", "pi");
-    const adapter = adapterOverride ?? getAdapter(harnessName);
-    if (!(await adapter.available()))
-        throw new Error(`harness \`${harnessName}\` is not on PATH`);
-    const mode = (flagStr(args, "mode", "force") || "force");
-    if (mode === "red")
-        throw new Error("compare measures a skill candidate, so --mode must be green or force (red is a no-skill baseline)");
-    const tuning = parseRunTuning(args);
-    const onlyRaw = flagStr(args, "only");
-    let only = onlyRaw ? onlyRaw.split(",").map((id) => id.trim()).filter(Boolean) : undefined;
-    const affected = flagBool(args, "affected");
-    if (affected && only)
-        throw new Error("--affected and --only both choose the comparison scenario set — pass one, not both");
-    if (affected) {
-        if (target === "all")
-            throw new Error("compare --affected currently requires one skill so each selected ID has an unambiguous spec");
-        const skill = resolveSkill(candidateRoot, target);
-        const spec = loadSpec(skill.specPath);
-        const selectionArgs = {
-            ...args,
-            flags: {
-                ...args.flags,
-                // A git-ref reference is the natural diff base. A reference directory
-                // has no common history, so the caller must supply --base explicitly.
-                ...(!flagStr(args, "base") && !existsSync(reference) ? { base: reference } : {}),
-            },
-        };
-        if (existsSync(reference) && !flagStr(args, "base")) {
-            throw new Error("compare --affected with a reference directory needs --base <git-ref> for candidate change selection");
-        }
-        const selected = await computeAffected(selectionArgs, spec.scenarios, skill.specPath);
-        console.log(formatAffected(selected, spec.scenarios.length));
-        only = selected.selected.map((entry) => entry.id);
-        if (only.length === 0) {
-            console.log("compare: no affected scenarios — 0 subject calls, 0 judge calls; no release claim produced");
-            return;
-        }
-    }
-    const threshold = (name) => {
-        const raw = flagStr(args, name);
-        if (raw === undefined)
-            return undefined;
-        const value = Number(raw);
-        if (!Number.isFinite(value) || value < 0)
-            throw new Error(`--${name} must be a non-negative ratio (got \`${raw}\`)`);
-        return value;
-    };
-    const thresholds = {
-        max_subject_token_increase: threshold("max-subject-token-increase"),
-        max_wall_time_increase: threshold("max-wall-time-increase"),
-        max_tool_call_increase: threshold("max-tool-call-increase"),
-    };
-    const hasThreshold = Object.values(thresholds).some((value) => value !== undefined);
-    const result = await runCompareCommand({
-        target,
-        reference,
-        candidateRoot,
-        models: resolveModels(args),
-        judgeToken,
-        mode,
-        reps: tuning.reps,
-        passThreshold: tuning.passThreshold,
-        parallel: Math.max(1, Number(flagStr(args, "parallel", "1")) || 1),
-        only,
-        canary: flagBool(args, "canary"),
-        output: flagStr(args, "output") || undefined,
-        thresholds: hasThreshold ? thresholds : undefined,
-        adapter,
-        now: nowIso,
-    });
-    console.log(`\ncomparison artifacts: ${result.outputDir}`);
-    if (result.exitCode !== 0)
-        process.exitCode = result.exitCode;
-}
 export async function cmdGrade(args, adapterOverride) {
     const runDir = args._[0];
     if (!runDir)
@@ -360,30 +262,7 @@ export async function cmdGrade(args, adapterOverride) {
     for (const s of results.scenarios) {
         console.log(`  ${s.id} → ${s.judge_verdict}: ${s.judge_reason}`);
     }
-    let final = results;
-    // Adjudication is opt-in. Without --auto-rejudge nothing below runs and not one
-    // extra call is made — a spec may declare triggers, but spec configuration alone
-    // never authorizes spending.
-    const judges = resolveAdjudicationJudges({
-        enabled: flagBool(args, "auto-rejudge"),
-        primary: judge,
-        secondaryToken: flagStr(args, "secondary-judge"),
-        tieBreakToken: flagStr(args, "tie-break-judge"),
-        subjectToken: results.model,
-        parseRef: parseModelRef,
-        assertAllowed: (j, source) => assertJudgeAllowed(j, { source, allowMetered: flagBool(args, "allow-metered-judge") }),
-        resemblesSubject: judgeResemblesSubject,
-        warn: (m) => console.error(m),
-    });
-    if (judges) {
-        final = await adjudicateRun({
-            runDir, spec, adapter, results, primaryJudge: judge,
-            secondaryJudge: judges.secondary, tieBreakJudge: judges.tieBreak,
-            specDir: testsDir, now: nowIso,
-            log: (m) => console.log(m),
-        });
-    }
-    const g = final.effective_grade;
+    const g = results.effective_grade;
     console.log(`\n  re-graded with ${judge.provider}:${judge.model} → ${g.letter} (${g.pct}%) ${g.ship ? "SHIP" : "NOT READY"}`);
 }
 /**
@@ -391,20 +270,6 @@ export async function cmdGrade(args, adapterOverride) {
  * Reps are the measurement; thresholds are policy. When policy changes, recompute rather
  * than reconcile two numbers in prose.
  */
-export function cmdJudgeAgreement(args) {
-    const raw = args._[0];
-    if (!raw)
-        throw new Error("usage: skill-harness judge-agreement <run-dir>");
-    const runDir = resolve(raw);
-    if (!existsSync(runDir))
-        throw new Error(`run dir not found: ${runDir}`);
-    const report = judgeAgreement(readResults(runDir));
-    for (const cell of report.cells) {
-        console.log(`  ${cell.status === "agree" ? "=" : cell.status === "disagree" ? "≠" : "?"} ${cell.scenario}: ${cell.status} — ${cell.detail}${cell.judges.length ? ` (${cell.judges.join(" vs ")})` : ""}`);
-    }
-    console.log(`\njudge agreement: ${report.agree} agree / ${report.disagree} disagree / ${report.error} error; ${report.rate === null ? "n/a" : `${(report.rate * 100).toFixed(1)}%`} across ${report.comparable} comparable scenario(s).`);
-    console.log("offline report only; no model or judge calls.");
-}
 async function cmdRescore(args) {
     const runDirs = args._;
     if (runDirs.length === 0)
@@ -523,13 +388,6 @@ async function cmdRestamp(args) {
     console.log(`\n${runs} run(s) examined: ${upgraded} upgraded, ${unprovable} left alone, ${unchanged} already current.` +
         `${partial > 0 ? ` (${partial} upgraded only in part.)` : ""} No models were called.`);
 }
-export async function cmdScreen(args) {
-    if (args._.length === 0)
-        throw new Error("usage: skill-harness screen <run-dir> [<run-dir> ...]");
-    const results = args._.map(runDir => readResults(resolve(runDir)));
-    console.log(formatScreen(screenResults(results)));
-    console.log(`\n${results.length} retained result(s) screened; 0 subject calls, 0 judge calls.`);
-}
 async function cmdStability(args) {
     const root = flagStr(args, "skills", process.cwd());
     const target = args._[0] ?? "all";
@@ -652,7 +510,6 @@ async function cmdCoverage(args) {
             // always points at, so report on it even when nothing references it —
             // otherwise a skill with zero `covers` reports 0 sections and looks fine.
             baseFiles: [relative(specDir, join(skill.dir, "SKILL.md")).split("\\").join("/")],
-            pendingCaptures: readPendingCaptures(specDir),
         });
         console.log(formatCoverage(report, spec.skill));
         if (report.uncovered.length)
@@ -672,54 +529,6 @@ async function cmdCoverage(args) {
         process.exitCode = 1;
     }
 }
-/** Pending captures and the sections they are parked against. Free, offline, tolerant. */
-function readPendingCaptures(specDir) {
-    const dir = join(specDir, "captures");
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    for (const file of readdirSync(dir).filter((f) => f.endsWith(".yaml"))) {
-        try {
-            const raw = yamlLoad(readFileSync(join(dir, file), "utf8"));
-            if (!raw || raw.status === "promoted")
-                continue;
-            const covers = Array.isArray(raw.covers) ? raw.covers.filter((c) => typeof c === "string") : [];
-            if (covers.length)
-                out.push({ id: String(raw.id ?? file.replace(/\.yaml$/, "")), covers });
-        }
-        catch {
-            // A malformed capture is the capture command's problem to report; coverage
-            // must not fail because a draft file is mid-edit.
-        }
-    }
-    return out;
-}
-/** `affected` — which scenarios a change could plausibly touch. Free and offline. */
-async function cmdAffected(args) {
-    const root = flagStr(args, "skills", process.cwd());
-    const target = args._[0];
-    if (!target)
-        throw new Error("usage: skill-harness affected <skill> --skills <root> [--base <git-ref>]");
-    const skill = resolveSkill(root, target);
-    if (!skill.hasSpec)
-        throw new Error(`${target} has no spec`);
-    const spec = loadSpec(skill.specPath);
-    const result = await computeAffected(args, spec.scenarios, skill.specPath);
-    console.log(formatAffected(result, spec.scenarios.length));
-}
-/** Shared by `affected` and `run --affected`, so the two can never disagree. */
-async function computeAffected(args, scenarios, specPath) {
-    const base = flagStr(args, "base", "HEAD");
-    const repoRoot = await gitRepoRoot(dirname(specPath));
-    const diff = await gitDiff(repoRoot, base);
-    return selectAffected({ scenarios, specDir: dirname(specPath), diff, repoRoot });
-}
-async function gitRepoRoot(from) {
-    const r = await exec("git", ["rev-parse", "--show-toplevel"], { cwd: from, timeoutMs: 30_000 });
-    if (r.code !== 0)
-        throw new Error(`not a git repository (from ${from}) — --affected needs one to diff against`);
-    return r.stdout.trim();
-}
 /** Write a spec to disk, creating its tests/ dir. The single choke point for spec
  *  writes (init/suggest) so a future atomic-write/backup/audit change lands in one place. */
 function writeSpecFile(specPath, text) {
@@ -881,31 +690,16 @@ export function help() {
     return `skill-harness ${HARNESS_VERSION} — test/optimize loop for agent skills (pi harness)
 
   run    <skill|all> --skills <root> [--model prov:model ...] [--models file] [--only A1,D2]
-                     [--affected --base <git-ref>]  run only the scenarios a change could touch (partial; never SHIPs)
                      [--mode red|green|force] [--judge prov:model] [--harness pi] [--label name] [--parallel N] [--reps N] [--pass-threshold T]
                      [--canary]  green only: spend ONE probe proving the skill reached the model, and abort the run if it did not
-                     [--structured]  record subject tokens, cost and wall time (needs pi --mode json)
+                     [--structured]  request structured capture (Pi uses it by default for subject usage)
                      [--arm <name>]  measure under a named arm from <skills-root>/tests/arms.yaml
                                      (loads its extensions, seeds pi-daddy definitions, tags the run dir)
-  compare <skill|all> --reference <git-ref-or-skills-root> --candidate <skills-root>
-                     [--model prov:model ...] [--mode green|force] [--judge prov:model] [--reps N] [--only IDs | --affected --base ref]
-                     [--output dir] [--max-subject-token-increase R] [--max-wall-time-increase R] [--max-tool-call-increase R]
-                       paired setup (not seeded sampling); critical regression exit 2, ordinary regression exit 1
   grade  <run-dir>   [--judge prov:model] [--suspect-only]   re-grade saved transcripts (neutral judge)
-                     [--auto-rejudge] [--secondary-judge p:m] [--tie-break-judge p:m]
-                       ask again about untrustworthy cells (ambiguous / contradictory / non-unanimous /
-                       ship-deciding). OFF by default; prints the exact MAX extra call count first.
-  archive ingest|inspect|watch --policy file --source id  explicit external ingestion/metadata (${free("archive")})
-  learning [status|import|review|trust|decide|adoption|outcome|guide]  guided retained learning (${free("learning")}; no models)
-                        use learning help; quality, trust, adoption and later outcomes stay separate
-  archive weekly|trust|access --state /private/dir --request file  durable learning/consent lifecycle (${free("archive")})
-                        watch requires --max-polls N; optional --interval-ms N and --previous checkpoint
-  judge-agreement <run-dir>                      compare two distinct persisted judge votes per scenario (${free("judge-agreement")})
   rescore <run-dir>...                          re-score saved reps vs current spec thresholds (${free("rescore")})
   regate <run-dir>...  [--judge prov:model]     re-evaluate saved gates (no subject call; judges fail→pass reps)
   restamp <skill|all> --skills <root> [--from <git-ref>]   record the model-visible skill digest on runs that still match (${free("restamp")}; one-time migration)
   stability <skill|all> --skills <root> [--window N] [--all]  run-over-run verdict flips per scenario (${free("stability")})
-  screen <run-dir>...                           retained control/treatment + criterion rates (${free("screen")})
   review <skill>     --skills <root> [--port N] serve the interactive review UI
   add-test <skill>   --skills <root> --id ID --title T --turn ... --check ... [--critical] [--mode seeded --fixture path]
   init   <skill>     --skills <root> [--force]     scaffold a commented template spec (${free("init")})
@@ -913,12 +707,6 @@ export function help() {
   list   --skills <root>                        discovered skills + spec status (${free("list")})
   lint   <skill|all> --skills <root>           validate specs/fixtures + results-consistency (${free("lint")}; CI gate; exits non-zero on findings)
   coverage <skill|all> --skills <root> [--strict]   which instruction sections have a declared test (${free("coverage")})
-  affected <skill>   --skills <root> [--base ref]   which scenarios a change could touch (${free("affected")})
-  qualification <prepare|start|status|poll|validate|panel|cell|abort>  durable qualification-runner-v1 lifecycle + offline panel collapse
-                     prepare --spool DIR --config FILE --request FILE [--expected-config-sha256 HEX] (required in production)
-                     start|status|poll|abort --spool DIR --id ID  (abort also requires --reason ID)
-                     start may resume only with --continuation-authority-file <private-0600-prebound-one-use-capability>
-                     validate --spool DIR  (all calls use external, schema-validated arms; no automatic retry)
 
   version  print ${HARNESS_VERSION} and exit (also --version / -v)
 
@@ -931,22 +719,15 @@ defaults: model=${DEFAULT_MODEL}  judge=${defaultJudge()}  mode=green  harness=p
 }
 export async function main(argv) {
     const cmd = argv[0];
-    if (cmd === "learning") {
-        await runLearningCommand(argv.slice(1));
-        return;
-    }
     const args = parseArgs(argv.slice(1));
+    assertNoRetiredFlags(cmd, args);
     switch (cmd) {
         case "run": return cmdRun(args);
-        case "compare": return cmdCompare(args);
         case "grade": return cmdGrade(args);
-        case "archive": return cmdArchive(args);
-        case "judge-agreement": return cmdJudgeAgreement(args);
         case "rescore": return cmdRescore(args);
         case "regate": return cmdRegate(args);
         case "restamp": return cmdRestamp(args);
         case "stability": return cmdStability(args);
-        case "screen": return cmdScreen(args);
         case "review": return cmdReview(args);
         case "add-test": return cmdAddTest(args);
         case "init": return cmdInit(args);
@@ -954,8 +735,6 @@ export async function main(argv) {
         case "list": return cmdList(args);
         case "lint": return cmdLint(args);
         case "coverage": return cmdCoverage(args);
-        case "affected": return cmdAffected(args);
-        case "qualification": return cmdQualification(args);
         case "version":
         case "--version":
         case "-v":

package/dist/serve.js

@@ -3,7 +3,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
-import { collectReport, renderReport, collectTrends, readResults, writeResults, applyOverride, preserveTranscript, findTranscriptFiles, ensureResultsGitignore, appendJournal, loadSpec, regradeScenario, appendJudgeHistory, refreshRubricHashes, findJudgeRawFiles, effectiveThreshold, scoreContextFor, isScoredMode, rebuildScenarioResult, mergeScenarioMetrics, carryRepObjectives, envFlag, planAdjudication, adjudicateRun, assertJudgeAllowed, cellsFromResults, } from "@skill-harness/core";
+import { collectReport, renderReport, collectTrends, readResults, writeResults, applyOverride, preserveTranscript, findTranscriptFiles, ensureResultsGitignore, appendJournal, loadSpec, regradeScenario, refreshRubricHashes, findJudgeRawFiles, effectiveThreshold, scoreContextFor, isScoredMode, rebuildScenarioResult, mergeScenarioMetrics, carryRepObjectives, envFlag, } from "@skill-harness/core";
 import { getAdapter } from "@skill-harness/adapters";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /** Locate assets/report.template.html relative to dist/ or src/. */
@@ -142,15 +142,8 @@ export async function serveReview(opts) {
                     const merged = results.scenarios.map((s) => {
                         if (s.id !== body.scenarioId)
                             return s;
-                        const judge_history = appendJudgeHistory(s, results.judge, {
-                            judge: results.judge,
-                            verdict: rr.judge_verdict,
-                            reason: rr.judge_reason,
-                            suspect: rr.suspect,
-                            criteria: rr.rep_judgments?.find(panel => panel.repetition === 0)?.judgments[0]?.criteria,
-                        });
                         // Same contract as `grade`, through the same choke point.
-                        return rebuildScenarioResult({ ...rr, metrics: mergeScenarioMetrics(s.metrics, rr.metrics), rep_judgments: carryRepObjectives(rr.rep_judgments, s.rep_judgments), judge_history }, s, { objective: "carry", adjudication: "drop" });
+                        return rebuildScenarioResult({ ...rr, metrics: mergeScenarioMetrics(s.metrics, rr.metrics), rep_judgments: carryRepObjectives(rr.rep_judgments, s.rep_judgments) }, s, { objective: "carry", adjudication: "drop" });
                     });
                     const written = writeResults(column.runDir, {
                         schema: results.schema, subject_invocations: results.subject_invocations,
@@ -187,79 +180,6 @@ export async function serveReview(opts) {
                 }
                 return;
             }
-            /**
-             * Adjudication, in two steps: `plan` returns the exact call ceiling and
-             * spends nothing; `run` executes it.
-             *
-             * Two requests rather than one because the ceiling has to be disclosed
-             * BEFORE anything is spent, and a single endpoint that both prices and
-             * charges cannot do that — the UI would be showing a count for work that
-             * had already happened.
-             */
-            if (req.method === "POST" && url.pathname === "/adjudicate") {
-                const body = JSON.parse((await readBody(req)) || "{}");
-                const data = collectReport(opts.skillDir);
-                const column = data.columns.find((c) => c.index === body.col);
-                if (!column) {
-                    res.writeHead(404).end("unknown column");
-                    return;
-                }
-                const results = readResults(column.runDir);
-                if (!isScoredMode(results.mode)) {
-                    res.writeHead(400, { "content-type": "application/json" });
-                    res.end(JSON.stringify({ ok: false, error: `only scored runs (green/force) can be adjudicated — for a ${results.mode} run use \`skill-harness grade\`` }));
-                    return;
-                }
-                const specPath = join(opts.skillDir, "tests", "specification.yaml");
-                const spec = loadSpec(specPath);
-                const adapter = opts.adapter ?? getAdapter(results.harness);
-                // Priced exactly as `adjudicateRun` will perform it — including per-rep
-                // verdicts, without which the quoted ceiling can be lower than the spend.
-                const cells = cellsFromResults(column.runDir, results);
-                // No tie-break judge from the browser: adding a third judge is a judge
-                // CHOICE, and the UI has nowhere honest to make one. A disagreement here
-                // stays unresolved and blocks SHIP, which is the safe direction.
-                const plan = planAdjudication({
-                    cells, scenarios: spec.scenarios, shipBar: spec.ship_bar, critical: spec.critical,
-                    tieBreakAvailable: false,
-                });
-                if (body.step !== "run") {
-                    res.writeHead(200, { "content-type": "application/json" });
-                    res.end(JSON.stringify({
-                        ok: true, step: "plan",
-                        triggered: plan.triggered,
-                        maxAdditionalCalls: plan.maxAdditionalCalls,
-                        judge: `${results.judge.provider}:${results.judge.model}`,
-                        detail: plan.decisions.filter((d) => d.triggers.length).map((d) => `${d.id}: ${d.triggers.join(", ")}`),
-                    }));
-                    return;
-                }
-                if (!(await adapter.available())) {
-                    res.writeHead(400, { "content-type": "application/json" });
-                    res.end(JSON.stringify({ ok: false, error: `harness \`${results.harness}\` is not on PATH` }));
-                    return;
-                }
-                try {
-                    assertJudgeAllowed(results.judge, { source: "the run's recorded judge", allowMetered: envFlag("SKILL_HARNESS_ALLOW_METERED_JUDGE") });
-                    const written = await adjudicateRun({
-                        runDir: column.runDir, spec, adapter, results,
-                        primaryJudge: results.judge,
-                        // Asked again as an independent draw. The judge-variance study measured
-                        // ~2% self-disagreement on identical transcripts, so this is a real
-                        // second opinion rather than a no-op.
-                        secondaryJudge: results.judge,
-                        specDir: dirname(specPath), now: () => new Date().toISOString(),
-                    });
-                    ensureResultsGitignore(join(opts.skillDir, "tests", "results"));
-                    res.writeHead(200, { "content-type": "application/json" });
-                    res.end(JSON.stringify({ ok: true, step: "run", grade: written.effective_grade }));
-                }
-                catch (e) {
-                    res.writeHead(400, { "content-type": "application/json" });
-                    res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : String(e) }));
-                }
-                return;
-            }
             if (req.method === "POST" && url.pathname === "/save") {
                 const body = JSON.parse((await readBody(req)) || "{}");
                 const data = collectReport(opts.skillDir);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/cli",
-    "version": "0.17.0",
+    "version": "0.19.0",
     "description": "skill-harness CLI — run, grade, review, and lint agent-skill scenarios on the pi harness",
     "type": "module",
     "license": "MIT",
@@ -10,8 +10,7 @@
     },
     "exports": {
         ".": "./dist/cli.js",
-        "./serve": "./dist/serve.js",
-        "./learning": "./dist/learning.js"
+        "./serve": "./dist/serve.js"
     },
     "keywords": [
         "agent-skills",
@@ -28,7 +27,6 @@
         "dist/**/*.js",
         "dist/**/*.d.ts",
         "assets",
-        "docs/*.md",
         "LICENSE",
         "README.md"
     ],
@@ -46,7 +44,7 @@
         "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "@skill-harness/core": "0.17.0",
-        "@skill-harness/adapters": "0.17.0"
+        "@skill-harness/core": "0.19.0",
+        "@skill-harness/adapters": "0.19.0"
     }
 }

package/dist/archive-learning.d.ts

@@ -1,3 +0,0 @@
-import type { Args } from './cli.js';
-/** Explicit operator requests, not a scheduler or model route. The inert host cannot invoke this CLI. */
-export declare function cmdArchiveLearning(args: Args): void;