@skill-harness/core 0.1.2 → 0.2.1

package/dist/report.d.ts

@@ -1,5 +1,6 @@
 import { type ShipBar } from "./spec.js";
 import { type ResultsFile } from "./results.js";
+import { type Lift } from "./lift.js";
 export interface RunColumn {
     index: number;
     label: string;
@@ -20,6 +21,17 @@ export interface RunColumn {
         override: string | null;
         note: string;
     }>;
+    /**
+     * Red-vs-green lift for this model, when the tag has both a red baseline and a
+     * green run. Undefined means "never measured" — which is not the same claim as
+     * a zero lift, so the report must not render a 0 for it.
+     *
+     * Only set when THIS column is the green run the lift was computed from (see
+     * collectReport): the review UI recomputes lift from the column's live cells,
+     * which is only valid if those cells are the green side of the comparison.
+     */
+    lift?: Lift;
+    liftHeadline?: string;
 }
 export interface ReportData {
     skill: string;
@@ -48,6 +60,8 @@ export declare function publicView(data: ReportData): {
         critical: boolean;
     }[];
     columns: {
+        lift?: Lift | undefined;
+        liftHeadline?: string | undefined;
         index: number;
         label: string;
         tag: string;

package/dist/report.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { loadSpec } from "./spec.js";
 import { readResults } from "./results.js";
+import { collectLift, liftHeadline } from "./lift.js";
 /** Most-recent run dir (by name, which is an ISO-ish slug) under a model-tag dir. */
 function latestRunDir(tagDir) {
     if (!statSync(tagDir).isDirectory())
@@ -21,6 +22,8 @@ export function collectReport(skillDir) {
     const spec = loadSpec(specPath);
     const scenarios = spec.scenarios.map((s) => ({ id: s.id, title: s.title, critical: s.critical }));
     const resultsRoot = join(skillDir, "tests", "results");
+    // Lift is keyed by model tag, the same key columns are built from.
+    const liftByTag = new Map(collectLift(skillDir).map((l) => [l.tag, l]));
     const columns = [];
     if (existsSync(resultsRoot)) {
         const tags = readdirSync(resultsRoot)
@@ -46,16 +49,27 @@ export function collectReport(skillDir) {
                     note: s.note,
                 };
             }
+            const tag = tagDir.split("/").pop();
+            // A column is the tag's LATEST run, which is not necessarily the green one —
+            // record a red baseline after a green run and the newest run in the tag is
+            // red. The review UI recomputes lift from `cells` (so author overrides move
+            // it live), so attaching a lift to a column whose cells are the RED run
+            // would have it compare red against red and report "no effect" for a skill
+            // that in fact gained every scenario. Attach only when this column IS the
+            // green side of the comparison.
+            const tagLift = liftByTag.get(tag);
+            const lift = tagLift && tagLift.greenTimestamp === r.timestamp ? tagLift : undefined;
             columns.push({
                 index: columns.length,
                 label: r.model,
-                tag: tagDir.split("/").pop(),
+                tag,
                 runDir,
                 timestamp: r.timestamp,
                 mode: r.mode,
                 grade: r.effective_grade,
                 judge: r.judge,
                 cells,
+                ...(lift ? { lift, liftHeadline: liftHeadline(lift) } : {}),
             });
         }
     }
@@ -77,6 +91,7 @@ export function publicView(data) {
             grade: c.grade,
             judge: c.judge,
             cells: c.cells,
+            ...(c.lift ? { lift: c.lift, liftHeadline: c.liftHeadline } : {}),
         })),
     };
 }

package/dist/rescore.d.ts

@@ -0,0 +1,34 @@
+import type { Spec } from "./spec.js";
+import { type ResultsFile, type ScenarioResult } from "./results.js";
+export interface RescoreOptions {
+    runDir: string;
+    spec: Spec;
+    now?: () => string;
+}
+export interface RescoreChange {
+    id: string;
+    from: ScenarioResult["judge_verdict"];
+    to: ScenarioResult["judge_verdict"];
+    passes: number;
+    clean: number;
+    fromThreshold: number;
+    toThreshold: number;
+}
+export interface RescoreResult {
+    results: ResultsFile;
+    changes: RescoreChange[];
+}
+/**
+ * Re-score a run against the CURRENT spec's pass thresholds — no model calls, no judge
+ * calls. Reps are the raw measurement (`passes` of `clean`); a threshold is *policy*.
+ * When the policy changes, the honest move is to recompute the old measurements under it
+ * rather than reconcile two numbers in prose — and to record what moved.
+ *
+ * Only reps-bearing scenarios can be re-scored: a single-rep verdict has no rate to
+ * re-apply a threshold to, and ERROR/JUDGE-AMBIGUOUS carry no trustworthy rate at all —
+ * both are carried verbatim. Overrides, notes, and suspect flags are preserved: this
+ * changes the collapse rule, nothing about what the judge said.
+ */
+export declare function rescoreRun(opts: RescoreOptions): RescoreResult;
+/** Locate the spec for a run dir: results/<tag>/<ts> → ../../../specification.yaml */
+export declare function specPathForRunDir(runDir: string): string;

package/dist/rescore.js

@@ -0,0 +1,66 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { readResults, writeResults } from "./results.js";
+import { appendJournal } from "./journal.js";
+/**
+ * Re-score a run against the CURRENT spec's pass thresholds — no model calls, no judge
+ * calls. Reps are the raw measurement (`passes` of `clean`); a threshold is *policy*.
+ * When the policy changes, the honest move is to recompute the old measurements under it
+ * rather than reconcile two numbers in prose — and to record what moved.
+ *
+ * Only reps-bearing scenarios can be re-scored: a single-rep verdict has no rate to
+ * re-apply a threshold to, and ERROR/JUDGE-AMBIGUOUS carry no trustworthy rate at all —
+ * both are carried verbatim. Overrides, notes, and suspect flags are preserved: this
+ * changes the collapse rule, nothing about what the judge said.
+ */
+export function rescoreRun(opts) {
+    const now = opts.now ?? (() => new Date().toISOString());
+    const prev = readResults(opts.runDir);
+    if (!prev)
+        throw new Error(`no results.yaml in ${opts.runDir}`);
+    const specById = new Map(opts.spec.scenarios.map((s) => [s.id, s]));
+    const changes = [];
+    const scenarios = prev.scenarios.map((s) => {
+        const scenario = specById.get(s.id);
+        // no rate to re-apply, or an untrustworthy verdict → carry verbatim
+        if (!scenario || s.reps === undefined || s.clean === undefined || s.passes === undefined)
+            return s;
+        if (s.judge_verdict === "ERROR" || s.judge_verdict === "JUDGE-AMBIGUOUS")
+            return s;
+        if (s.clean === 0)
+            return s;
+        const toThreshold = scenario.passThreshold ?? 0.5;
+        const fromThreshold = s.pass_threshold ?? toThreshold;
+        if (toThreshold === fromThreshold)
+            return s;
+        const rate = s.passes / s.clean;
+        const verdict = rate >= toThreshold ? "PASS" : "FAIL";
+        if (verdict !== s.judge_verdict) {
+            changes.push({ id: s.id, from: s.judge_verdict, to: verdict, passes: s.passes, clean: s.clean, fromThreshold, toThreshold });
+        }
+        return { ...s, judge_verdict: verdict, pass_threshold: toThreshold };
+    });
+    const ctx = prev.mode === "green" && !prev.partial
+        ? { shipBar: opts.spec.ship_bar, critical: opts.spec.critical }
+        : null;
+    const results = writeResults(opts.runDir, {
+        skill: prev.skill, harness: prev.harness, model: prev.model, judge: prev.judge,
+        timestamp: prev.timestamp, label: prev.label, mode: prev.mode,
+        partial: prev.partial, source_hashes: prev.source_hashes, scenarios,
+    }, ctx);
+    appendJournal(opts.runDir, {
+        event: "rescore", ts: now(),
+        changed: changes.map((c) => `${c.id}: ${c.from}->${c.to} (${c.passes}/${c.clean} @ ${c.toThreshold})`),
+        passed: results.effective_grade.passed, total: results.effective_grade.total,
+        pct: results.effective_grade.pct, ship: results.effective_grade.ship,
+    });
+    return { results, changes };
+}
+/** Locate the spec for a run dir: results/<tag>/<ts> → ../../../specification.yaml */
+export function specPathForRunDir(runDir) {
+    const p = join(runDir, "..", "..", "..", "specification.yaml");
+    if (!existsSync(p))
+        throw new Error(`no specification.yaml above ${runDir}`);
+    return p;
+}
+//# sourceMappingURL=rescore.js.map

package/dist/results.d.ts

@@ -35,6 +35,15 @@ export interface ResultsFile {
     timestamp: string;
     label: string | null;
     mode: string;
+    /** True for an `--only`-filtered run: a scenario subset, never ship-graded, never a release run. */
+    partial?: boolean;
+    /**
+     * sha256 of every source file this run measured: SKILL.md plus each distinct
+     * system_prompt_file. Lint compares the newest run's hashes against the current
+     * files — a mismatch means the published result describes text that no longer
+     * exists (the stale-scorecard class this field exists to kill).
+     */
+    source_hashes?: Record<string, string>;
     effective_grade: GradeSummary;
     scenarios: ScenarioResult[];
 }

package/dist/results.js

@@ -46,7 +46,8 @@ export function finalizeResults(draft, ctx) {
         effective_grade = { passed: s.passed, total: s.total, pct: s.pct, letter: s.letter, ship: s.ship, note: s.note };
     }
     else {
-        effective_grade = { passed: 0, total: 0, pct: 0, letter: "-", ship: false, note: `mode=${draft.mode} (not scored)` };
+        const why = draft.partial ? "partial run (--only) — not scored" : `mode=${draft.mode} (not scored)`;
+        effective_grade = { passed: 0, total: 0, pct: 0, letter: "-", ship: false, note: why };
     }
     return {
         schema: 2,
@@ -57,6 +58,8 @@ export function finalizeResults(draft, ctx) {
         timestamp: draft.timestamp,
         label: draft.label,
         mode: draft.mode,
+        ...(draft.partial ? { partial: true } : {}),
+        ...(draft.source_hashes ? { source_hashes: draft.source_hashes } : {}),
         effective_grade,
         scenarios: draft.scenarios,
     };

package/dist/run.d.ts

@@ -1,6 +1,7 @@
 import type { Spec } from "./spec.js";
 import type { HarnessAdapter, ModelRef, RunMode } from "./adapters/types.js";
 import { type ResultsFile } from "./results.js";
+import { type Lift } from "./lift.js";
 export interface RunOptions {
     spec: Spec;
     skillDir: string;
@@ -17,6 +18,12 @@ export interface RunOptions {
     concurrency?: number;
     reps?: number;
     passThreshold?: number;
+    /**
+     * Run only these scenario ids — the iteration tool (re-testing 2 D-scenarios must not
+     * cost an 18-scenario run). The result is marked `partial: true` and is NEVER
+     * ship-graded: a subset passing says nothing about the ship bar.
+     */
+    only?: string[];
 }
 export interface RunSummary {
     runDir: string;
@@ -24,5 +31,22 @@ export interface RunSummary {
 }
 /** Run one skill against one model: run scenarios, grade, score, persist. */
 export declare function runSkillModel(opts: RunOptions): Promise<RunSummary>;
+/**
+ * True when any assistant turn in a transcript is blank — the shape a harness timeout
+ * leaves behind. Such a transcript must never reach the judge: grading an empty reply
+ * produces a confident FAIL about behavior that never happened (round 9 lost two
+ * scenarios this way). Sections are delimited by the adapters' shared transcript
+ * convention (">>> USER"/"<<< ASSISTANT:"); seeded gate output ("=== SEEDED GATES ===")
+ * ends the last assistant section.
+ */
+export declare function hasEmptyAssistantTurn(transcript: string): boolean;
 /** A compact terminal scorecard for one run. */
-export declare function formatScorecard(summary: RunSummary): string;
+/**
+ * The human-facing scorecard for one run.
+ *
+ * `lift` is the red-vs-green comparison for this model when a red baseline
+ * exists. Passing it for a green run turns the scorecard from "the skill scored
+ * B" into "the skill *did* this much" — without a baseline the grade alone can't
+ * distinguish a skill that works from a model that never needed it.
+ */
+export declare function formatScorecard(summary: RunSummary, lift?: Lift): string;

package/dist/run.js

@@ -1,18 +1,62 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, resolve } from "node:path";
 import { judgeResemblesSubject } from "./grade.js";
 import { runDirFor, transcriptPath, writeResults, ensureResultsGitignore, } from "./results.js";
 import { appendJournal } from "./journal.js";
+import { liftHeadline } from "./lift.js";
 import { runSeeded } from "./seeded.js";
 import { createWorkspace } from "./workspace.js";
 import { runPool } from "./scheduler.js";
 import { outcomesToResult } from "./reps.js";
 import { judgeOneRep } from "./regrade.js";
+/** sha256 of a file, or null when it doesn't exist — missing sources are lint's problem, not run's. */
+function sha256(path) {
+    try {
+        return createHash("sha256").update(readFileSync(path)).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Hash every source file this run measures: SKILL.md + each distinct
+ * system_prompt_file (agents/<name>.md). Recorded in results.yaml so lint can prove
+ * a published result still describes the current text.
+ */
+function sourceHashes(skillDir, specPath, scenarios) {
+    const hashes = {};
+    const skillMd = sha256(resolve(skillDir, "SKILL.md"));
+    if (skillMd)
+        hashes["SKILL.md"] = skillMd;
+    for (const s of scenarios) {
+        if (s.systemPromptFile && !(s.systemPromptFile in hashes)) {
+            const h = sha256(resolve(dirname(specPath), s.systemPromptFile));
+            if (h)
+                hashes[s.systemPromptFile] = h;
+        }
+    }
+    return hashes;
+}
 /** Run one skill against one model: run scenarios, grade, score, persist. */
 export async function runSkillModel(opts) {
     const { spec, skillDir, adapter, model, judge, mode, timestamp } = opts;
     const log = opts.onProgress ?? (() => { });
     const now = opts.now ?? (() => new Date().toISOString());
+    // --only: validate against the spec BEFORE spending anything — a typo'd id must not
+    // silently run zero scenarios and report success.
+    let scenarios = spec.scenarios;
+    const partial = Boolean(opts.only && opts.only.length > 0);
+    if (partial) {
+        const known = new Set(spec.scenarios.map((s) => s.id));
+        const unknown = opts.only.filter((id) => !known.has(id));
+        if (unknown.length > 0) {
+            throw new Error(`--only names unknown scenario id(s) ${unknown.join(", ")} — spec has: ${[...known].join(", ")}`);
+        }
+        const wanted = new Set(opts.only);
+        scenarios = spec.scenarios.filter((s) => wanted.has(s.id));
+        log(`  --only ${opts.only.join(",")} — partial run, will not be ship-graded`);
+    }
     if (judgeResemblesSubject(judge, model)) {
         log(`  ⚠ judge (${judge.provider}:${judge.model}) resembles the model under test ` +
             `(${model.provider}:${model.model}) — verdicts may be inflated. Use a distinct judge.`);
@@ -27,10 +71,10 @@ export async function runSkillModel(opts) {
         mode, label: opts.label ?? null,
     });
     // scenario × rep tasks; runPool preserves input order so we can slice per scenario.
-    const repCounts = spec.scenarios.map((s) => s.reps ?? opts.reps ?? 1);
+    const repCounts = scenarios.map((s) => s.reps ?? opts.reps ?? 1);
     const owners = [];
     const tasks = [];
-    spec.scenarios.forEach((scenario, si) => {
+    scenarios.forEach((scenario, si) => {
         for (let k = 0; k < repCounts[si]; k++) {
             const rep = k;
             const total = repCounts[si];
@@ -39,13 +83,13 @@ export async function runSkillModel(opts) {
         }
     });
     const flat = await runPool(tasks, opts.concurrency ?? 1);
-    const grouped = spec.scenarios.map(() => []);
+    const grouped = scenarios.map(() => []);
     flat.forEach((outcome, i) => grouped[owners[i]].push(outcome));
-    const scenarioResults = spec.scenarios.map((scenario, si) => {
+    const scenarioResults = scenarios.map((scenario, si) => {
         const threshold = scenario.passThreshold ?? opts.passThreshold ?? 0.5;
         return outcomesToResult(scenario.id, grouped[si], repCounts[si], threshold);
     });
-    const ctx = mode === "green" ? { shipBar: spec.ship_bar, critical: spec.critical } : null;
+    const ctx = mode === "green" && !partial ? { shipBar: spec.ship_bar, critical: spec.critical } : null;
     const results = writeResults(runDir, {
         skill: spec.skill,
         harness: adapter.name,
@@ -54,6 +98,8 @@ export async function runSkillModel(opts) {
         timestamp,
         label: opts.label ?? null,
         mode,
+        ...(partial ? { partial: true } : {}),
+        source_hashes: sourceHashes(skillDir, opts.specPath, scenarios),
         scenarios: scenarioResults,
     }, ctx);
     if (ctx) {
@@ -62,6 +108,23 @@ export async function runSkillModel(opts) {
     }
     return { runDir, results };
 }
+/**
+ * True when any assistant turn in a transcript is blank — the shape a harness timeout
+ * leaves behind. Such a transcript must never reach the judge: grading an empty reply
+ * produces a confident FAIL about behavior that never happened (round 9 lost two
+ * scenarios this way). Sections are delimited by the adapters' shared transcript
+ * convention (">>> USER"/"<<< ASSISTANT:"); seeded gate output ("=== SEEDED GATES ===")
+ * ends the last assistant section.
+ */
+export function hasEmptyAssistantTurn(transcript) {
+    const sections = transcript.split(/^<<< ASSISTANT:\s*$/m).slice(1);
+    if (sections.length === 0)
+        return false;
+    return sections.some((sec) => {
+        const body = sec.split(/^(?:>>> |=== SEEDED GATES ===|\[pi exited )/m)[0];
+        return body.trim() === "";
+    });
+}
 /** Run ONE rep of a scenario in its own isolated workspace. */
 async function runRep(scenario, rep, repCount, ctx) {
     const { spec, judge, mode, runDir, now, log } = ctx;
@@ -75,25 +138,44 @@ async function runRep(scenario, rep, repCount, ctx) {
     let gatePrefix = null;
     try {
         try {
-            ws = createWorkspace(scenario.workspace, { specDir: dirname(ctx.specPath) });
+            ws = createWorkspace(scenario.workspace, { specDir: dirname(ctx.specPath), remote: scenario.remote });
         }
         catch (e) {
             // A setup failure (e.g. missing fixture) is an objective FAIL, not an infra abort.
             gatePrefix = e instanceof Error ? e.message : String(e);
             transcript = `[workspace setup failed] ${gatePrefix}`;
         }
+        let noResponse = false;
         if (ws) {
-            if (scenario.mode === "seeded") {
-                const r = await runSeeded(scenario, {
-                    skillDir: ctx.skillDir, adapter: ctx.adapter, model: ctx.model, mode, cwd: ws.cwd,
-                });
-                transcript = r.transcript;
-                gatePrefix = r.gateFailure;
-            }
-            else {
-                transcript = await ctx.adapter.run({
-                    skillDir: ctx.skillDir, model: ctx.model, mode, turns: scenario.turns, cwd: ws.cwd,
-                });
+            // A blank assistant turn is a harness timeout, not model behavior: retry ONCE in a
+            // fresh workspace (the first attempt may have half-mutated a seeded repo), and if
+            // it happens again the verdict is ERROR — never a judged FAIL on an empty reply.
+            for (let attempt = 0; attempt < 2; attempt++) {
+                if (attempt > 0) {
+                    appendJournal(runDir, { event: "empty-response-retry", ts: now(), id: scenario.id, attempt, ...repField });
+                    log(`  ${scenario.id}${repCount > 1 ? `#${rep}` : ""} empty response — retrying once`);
+                    ws.cleanup();
+                    ws = createWorkspace(scenario.workspace, { specDir: dirname(ctx.specPath), remote: scenario.remote });
+                }
+                if (scenario.mode === "seeded") {
+                    const r = await runSeeded(scenario, {
+                        skillDir: ctx.skillDir, adapter: ctx.adapter, model: ctx.model, mode, cwd: ws.cwd,
+                    });
+                    transcript = r.transcript;
+                    gatePrefix = r.gateFailure;
+                }
+                else {
+                    transcript = await ctx.adapter.run({
+                        skillDir: ctx.skillDir, model: ctx.model, mode, turns: scenario.turns, cwd: ws.cwd,
+                        // resolved like fixtures: relative to the spec's dir
+                        systemPromptFile: scenario.systemPromptFile
+                            ? resolve(dirname(ctx.specPath), scenario.systemPromptFile)
+                            : undefined,
+                    });
+                }
+                noResponse = hasEmptyAssistantTurn(transcript);
+                if (!noResponse)
+                    break;
             }
         }
         writeFileSync(transcriptPath(runDir, scenario.id, mode, repCount > 1 ? rep : undefined), transcript, "utf8");
@@ -103,7 +185,12 @@ async function runRep(scenario, rep, repCount, ctx) {
         let verdict;
         let reason;
         let suspect = false;
-        if (gatePrefix) {
+        if (noResponse) {
+            verdict = "ERROR";
+            reason = "model produced no response after a retry (harness timeout?) — infra, not skill behavior";
+            appendJournal(runDir, { event: "judge-verdict", ts: now(), id: scenario.id, verdict, reason, suspect, ...repField });
+        }
+        else if (gatePrefix) {
             verdict = "FAIL";
             reason = gatePrefix;
             // gate failures don't invoke the judge, but still record a judge-verdict event (as before)
@@ -126,7 +213,15 @@ async function runRep(scenario, rep, repCount, ctx) {
     }
 }
 /** A compact terminal scorecard for one run. */
-export function formatScorecard(summary) {
+/**
+ * The human-facing scorecard for one run.
+ *
+ * `lift` is the red-vs-green comparison for this model when a red baseline
+ * exists. Passing it for a green run turns the scorecard from "the skill scored
+ * B" into "the skill *did* this much" — without a baseline the grade alone can't
+ * distinguish a skill that works from a model that never needed it.
+ */
+export function formatScorecard(summary, lift) {
     const { results } = summary;
     const g = results.effective_grade;
     const lines = [];
@@ -143,6 +238,16 @@ export function formatScorecard(summary) {
     const ship = g.ship ? "SHIP" : "NOT READY";
     const note = g.note ? ` (${g.note})` : "";
     lines.push(`  GRADE: ${g.letter} (${g.pct}%) — ${g.passed}/${g.total} — ${ship}${note}`);
+    // Lift is a statement about a green run. On a red run the caller may still have
+    // a lift in hand (a green run exists in the same tag), but printing it under a
+    // baseline scorecard reads as if the baseline itself gained something.
+    if (lift && results.mode === "green") {
+        lines.push(`  LIFT:  ${liftHeadline(lift)}  (vs red baseline ${lift.redTimestamp})`);
+    }
+    else if (results.mode === "green") {
+        // The grade alone can't answer "does this skill do anything?", so say how.
+        lines.push(`  LIFT:  no red baseline — run with --mode red to measure what the skill adds`);
+    }
     return lines.join("\n");
 }
 //# sourceMappingURL=run.js.map

package/dist/scaffold.d.ts

@@ -0,0 +1,28 @@
+/** Marker written into an `init` template's first comment. Its presence tells
+ *  `suggest` the file is an unadopted template it may overwrite without --force. */
+export declare const TEMPLATE_SENTINEL = "skill-harness: generated template";
+/** Render a commented, empty-but-valid specification.yaml for a skill. */
+export declare function renderTemplateSpec(skillName: string): string;
+/** True if the text still carries the template sentinel (i.e. an unadopted template). */
+export declare function isTemplateSpec(text: string): boolean;
+export interface DraftScenario {
+    id: string;
+    title: string;
+    turns: string[];
+    checklist: string[];
+}
+export interface SuggestDraft {
+    judge_persona: string;
+    ship_bar: {
+        total: number;
+        min_pass: number;
+        no_critical_fail: boolean;
+    };
+    proposed_critical: string[];
+    scenarios: DraftScenario[];
+}
+/** Render a populated spec from an LLM draft. Strings are JSON-encoded (valid YAML
+ *  flow scalars) so colons/quotes never break the file. Carries no sentinel. */
+export declare function renderDraftSpec(skillName: string, draft: SuggestDraft): string;
+export declare function buildSuggestPrompt(skillName: string, skillMd: string): string;
+export declare function parseSuggestDraft(raw: string): SuggestDraft;