cclaw-cli 0.51.30 → 0.55.2

package/dist/content/next-command.js

@@ -1,298 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-import { nextStage as nextStageForTrack } from "../flow-state.js";
-import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
-import { stageSchema } from "./stage-schema.js";
-import { closeoutChainInline, closeoutNextCommandGuidance, closeoutSubstateInline, closeoutSubstateProtocolBullets } from "./closeout-guidance.js";
-import { stageSkillFolder } from "./skills.js";
-const NEXT_SKILL_FOLDER = "flow-next-step";
-const NEXT_SKILL_NAME = "flow-next-step";
-function flowStatePath() {
-    return `${RUNTIME_ROOT}/state/flow-state.json`;
-}
-function delegationLogPathLine() {
-    return `${RUNTIME_ROOT}/state/delegation-log.json`;
-}
-function reconciliationNoticesPathLine() {
-    return `${RUNTIME_ROOT}/state/reconciliation-notices.json`;
-}
-/**
- * Single source of truth for how /cc-next should treat Ralph Loop status.
- *
- * IMPORTANT: Ralph Loop is a **progress indicator + soft pre-advance nudge**,
- * not a hard gate. Hard enforcement always flows through flow-state.json
- * gates via `stage-complete.mjs`. Both the command contract and the skill
- * document render this same paragraph to prevent drift — see
- * `tests/e2e/next-command-ralph-loop-contract.test.ts`.
- */
-export const RALPH_LOOP_CONTRACT_MARKER = "ralph-loop-contract:v1";
-export function ralphLoopContractSnippet() {
-    return `**Ralph Loop (tdd only).** When \`currentStage === "tdd"\`, read
-\`${RUNTIME_ROOT}/state/ralph-loop.json\` (refreshed on every session-start
-while the flow is in tdd) as a **progress indicator**:
-
-- \`loopIteration\` — running count of RED → GREEN cycles already landed.
-- \`acClosed\` — distinct acceptance-criterion IDs closed by GREEN rows
-  (populated from \`acIds\` in \`tdd-cycle-log.jsonl\`).
-- \`redOpenSlices\` — slices with an unsatisfied RED.
-
-Ralph Loop is a **soft pre-advance nudge**, not a gate: do not advance
-toward review while \`redOpenSlices\` is non-empty unless the user
-explicitly defers a slice. Hard gate enforcement always flows through
-\`flow-state.json\` gates via \`node .cclaw/hooks/stage-complete.mjs <stage>\`;
-Ralph Loop fields never gate-check on their own.
-
-<!-- ${RALPH_LOOP_CONTRACT_MARKER} -->`;
-}
-/**
- * Internal compatibility contract for /cc-next.
- * /cc is the promoted public progression command; this remains as an internal/legacy alias.
- */
-export function nextCommandContract() {
-    const flowPath = flowStatePath();
-    const skillRel = `${RUNTIME_ROOT}/skills/${NEXT_SKILL_FOLDER}/SKILL.md`;
-    const delegationPath = delegationLogPathLine();
-    const reconciliationNoticesPath = reconciliationNoticesPathLine();
-    return `# /cc-next
-
-## Purpose
-
-**Internal compatibility progression command.** \`/cc\` is the promoted public start/resume/continue command. This contract remains for legacy shims and internal references; read flow state, determine what to do:
-
-- **Current stage not started / in progress** → load its skill and execute it.
-- **Current stage complete (all gates passed)** → advance \`currentStage\` and load the next skill.
-- **Ship complete** → continue the resumable ${closeoutChainInline()} closeout. Public habit: use \`/cc\`.
-- **Flow complete** → report done after closeout has archived the run.
-
-The public habit is \`/cc\`; this command is a compatibility/internal route for the same progression behavior. Stage command contracts are internal implementation details.
-
-## HARD-GATE
-
-${conversationLanguagePolicyMarkdown()}
-- **Do not** invent gate completion: use only \`${flowPath}\` plus observable evidence in repo artifacts.
-- **Do not** skip stages: advance only from \`currentStage\` to its configured successor.
-- ${closeoutNextCommandGuidance()}
-
-## Algorithm (mandatory)
-
-1. Read **\`${flowPath}\`**. If missing → **BLOCKED** (state missing). Next action: run \`cclaw sync\` to safely regenerate generated runtime files, then \`cclaw doctor --explain\`; do not hand-edit state unless doctor says user repair is required.
-2. Parse JSON. Capture \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, do not advance automatically. Report \`Blocked by: stale stage\`, the marker reason/rewindId, the stage artifact work to re-run, and clear only the current stage marker with \`cclaw internal rewind --ack <currentStage>\` after rework.
-4. Read **\`${reconciliationNoticesPath}\`** when present. If it contains entries for \`activeRunId + currentStage\` and the listed gate is still blocked in \`stageGateCatalog[currentStage].blocked\`, emit \`Blocked by: reconciliation notice\` with gate id, reason, and next action \`cclaw doctor --reconcile-gates --explain\`. Clarify that reconciliation refreshes derived gate status only; it does not repair missing artifacts or tests.
-5. Let \`G\` = \`requiredGates\` for **\`currentStage\`** from the stage schema.
-6. Let \`catalog\` = \`stageGateCatalog[currentStage]\` from flow state.
-7. **Satisfied** for gate id \`g\`: \`g\` in \`catalog.passed\` and \`g\` not in \`catalog.blocked\`.
-8. Let \`M\` = \`mandatoryDelegations\` for \`currentStage\`.
-9. If \`M\` is non-empty, inspect **\`${delegationPath}\`**. Treat as satisfied only if each mandatory agent is **completed** or **waived**.
-10. For each satisfied mandatory delegation row, verify \`evidenceRefs\` is a non-empty array (unless status is \`waived\` with rationale). Missing evidenceRefs means delegation is unresolved.
-11. If any mandatory delegation is missing and no waiver exists: **STOP** and ask the user whether to dispatch \`<agent>\` now or waive with rationale. State who must run, why the role is mandatory, whether the gap is ledger status, event-log dispatch proof, or artifact \`evidenceRefs\`, and do not mark gates passed while delegation is unresolved.
-12. If \`currentStage === "review"\` and \`catalog.blocked\` includes \`review_criticals_resolved\`, treat this as a hard remediation branch: recommend the managed command \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\`, and do not attempt to advance toward ship. After TDD rework, require \`cclaw internal rewind --ack tdd\` before continuing.
-
-### Path A: Current stage is NOT complete (any gate unmet or delegation missing)
-
-→ Load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** for the current stage.
-→ Execute that stage's protocol. The stage skill handles the full interaction including STOP points and gate tracking.
-→ Stage completion must use \`node .cclaw/hooks/stage-complete.mjs <currentStage>\` (canonical), which validates delegations + gate evidence before mutating \`flow-state.json\`.
-
-${ralphLoopContractSnippet()}
-
-### Path B: Current stage IS complete (all gates passed, all delegations satisfied)
-
-→ If current stage's \`next\` is **\`done\`**:
-
-  ${closeoutSubstateProtocolBullets()}
-
-  Otherwise report **"Flow complete. All stages finished."** and stop.
-
-→ Otherwise: load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** for the successor stage. Execute that stage's protocol.
-
-### Track-aware successor resolution
-
-\`flow-state.json\` carries a \`track\` field (\`"quick"\`, \`"medium"\`, or \`"standard"\`) and a \`skippedStages\` array.
-
-- If \`track === "quick"\`, the critical path is **spec → tdd → review → ship**. Quick skips ceremony, not safety: spec approval, RED/GREEN/REFACTOR evidence, review, and ship gates still apply. When advancing, skip any stage listed in \`skippedStages\` — i.e. after the current stage completes, pick the next stage that is NOT in \`skippedStages\`.
-- If \`track === "medium"\`, the critical path is **brainstorm → spec → plan → tdd → review → ship**. Scope and design are intentionally skipped unless the run is reclassified to standard.
-- If \`track === "standard"\`, advance through all 8 stages in their natural order.
-- Never manually reintroduce a skipped stage mid-run. If evidence shows the track was wrong, stop and use the managed start-flow helper with \`--reclassify\`; only that managed reclassification may add upstream stages back into the active track.
-
-## Resume Semantics
-
-\`/cc\` in a **new session** resumes from where you left off; \`/cc-next\` is a compatibility alias:
-- Flow-state records \`currentStage\` and which gates have passed.
-- The stage skill reads upstream artifacts and picks up context.
-- ${closeoutSubstateInline()} carries the post-ship substate, so a crashed
-  session during retro/compound/archive resumes at the exact step without
-  regenerating the retro draft.
-- No special resume command needed — \`/cc\` is the public resume/progression command.
-
-## Headless mode
-
-When orchestrated by another skill/subagent, emit exactly one JSON envelope and
-no narrative text:
-
-\`\`\`json
-{"version":"1","kind":"gate-result","stage":"<currentStage>","payload":{"command":"/cc-next","decision":"resume_or_advance","nextStage":"<nextStage>"},"emittedAt":"<ISO-8601>"}
-\`\`\`
-
-Validate envelopes with:
-\`cclaw internal envelope-validate --stdin\`
-
-## Primary skill
-
-**${skillRel}** — full protocol and stage table.
-
-## Surface reference
-
-Use the flow-start skill plus \`.cclaw/state/flow-state.json\` for orientation when needed.
-`;
-}
-/**
- * Skill body for /cc-next — the primary flow progression command.
- */
-export function nextCommandSkillMarkdown() {
-    const flowPath = flowStatePath();
-    const delegationPath = delegationLogPathLine();
-    const reconciliationNoticesPath = reconciliationNoticesPathLine();
-    const stageRows = ["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"]
-        .map((stage) => {
-        const skillMd = `${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md`;
-        const standardNext = nextStageForTrack(stage, "standard") ?? "(terminal)";
-        const mediumNext = nextStageForTrack(stage, "medium") ?? "not in track";
-        const quickNext = nextStageForTrack(stage, "quick") ?? "not in track";
-        return `| \`${stage}\` | \`${standardNext}\` | \`${mediumNext}\` | \`${quickNext}\` | \`${skillMd}\` |`;
-    })
-        .join("\n");
-    const naturalStageRows = ["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"]
-        .map((stage) => {
-        const schema = stageSchema(stage);
-        const next = schema.next === "done" ? "(terminal)" : schema.next;
-        const skillMd = `${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md`;
-        return `| \`${stage}\` | \`${next}\` | \`${skillMd}\` |`;
-    })
-        .join("\n");
-    return `---
-name: ${NEXT_SKILL_NAME}
-description: "Internal compatibility progression command. Prefer /cc for start, resume, continue, and closeout."
----
-
-# /cc-next — Flow Progression Compatibility
-
-## Overview
-
-\`/cc\` is the public command to drive the cclaw flow. \`/cc-next\` remains as an internal/compatibility alias for progression.
-
-## Operator Output Contract
-
-${conversationLanguagePolicyMarkdown()}
-Default output should be compact, like OMC/OMX operator surfaces:
-
-\`\`\`
-Current: <currentStage or closeout.shipSubstate> (<track>)
-Stage: <currentStage>
-Gates: <passed>/<required> passed, <blocked> blocked
-Delegations: <done>/<mandatory> done
-Blocked by: <none | gate/delegation/reconciliation/stale/TDD/review/closeout ids>
-Blocker category: <sync-recovery | user-decision | stage-work | delegation-proof | review-rework | closeout>
-Next: <exact next action, usually /cc or one named remediation>
-Evidence needed: <artifact/test/review/delegation evidence required to unblock>
-\`\`\`
-
-Only expand beyond this when blocked, when asking a structured question, or when
-the user explicitly requests detail. When blocked, name the blocker category,
-why it blocks progression, the one next command/action, and the exact proof that
-would unblock it. Do not dump full artifacts in progression output.
-
-**How it works:**
-1. Reads \`flow-state.json\` to find \`currentStage\`
-2. Checks if all gates for that stage are satisfied
-3. If **not** → loads the stage skill and starts/resumes execution
-4. If **yes** → advances to the next stage and loads its skill
-
-**Resume:** \`/cc\` in a new session picks up from where \`flow-state.json\` says you are.
-
-## HARD-GATE
-
-Do **not** mark gates satisfied from memory alone. Cite **artifact evidence** (paths, excerpts). If evidence is missing, list the gate as **unmet**. Do **not** skip stages.
-
-## Algorithm
-
-### Step 1: Read state
-
-1. Open **\`${flowPath}\`**.
-2. Record \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, show \`Blocked by: stale stage\`, the marker reason/rewindId, re-run the stage, and clear only the current marker via \`cclaw internal rewind --ack <currentStage>\` before advancing.
-4. If the file is missing or invalid JSON → **BLOCKED** (state missing/corrupt). Next action: run \`cclaw sync\` for safe regeneration of generated runtime files, then \`cclaw doctor --explain\`; do not hand-edit flow state unless doctor says user repair is required.
-5. Read \`${reconciliationNoticesPath}\` when present. For entries matching \`activeRunId + currentStage\` whose gate is still in \`stageGateCatalog[currentStage].blocked\`, show \`Blocked by: reconciliation notice\` with gate id + reason before proceeding; \`cclaw doctor --reconcile-gates --explain\` refreshes derived gate-state only; it does not repair missing artifacts or tests.
-
-### Step 2: Evaluate gates
-
-For each gate id in \`requiredGates\` for \`currentStage\`:
-- **Met** if in \`catalog.passed\` and not in \`catalog.blocked\`.
-- **Unmet** otherwise.
-
-Check \`mandatoryDelegations\` via **\`${delegationPath}\`** — satisfied only if **completed** or **waived**.
-Also verify each completed mandatory delegation row has non-empty \`evidenceRefs\` (waived rows must include rationale).
-If a mandatory delegation is missing and no waiver exists, **STOP** and ask:
-(A) dispatch \`<agent>\` now, (B) waive with rationale, (C) cancel stage advance.
-Explain who must run, why that role is mandatory for this stage, and whether the missing proof is ledger status, event-log dispatch proof, or artifact \`evidenceRefs\`. Waivers must include a user-visible safety reason.
-
-If reconciliation warnings were emitted in Step 1, treat them as a pre-advance stop point: require explicit acknowledgement before continuing Path A or Path B.
-
-### Step 3: Act
-
-**Path A — stage NOT complete (any gate unmet):**
-
-Load the current stage skill:
-- \`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`
-
-Execute the stage protocol. The stage skill handles interaction, STOP points, gate tracking, and stage completion via \`node .cclaw/hooks/stage-complete.mjs <stage>\` (canonical flow-state mutation path).
-
-${ralphLoopContractSnippet()}
-
-Special-case for review: if \`review_criticals_resolved\` is in \`blocked\`, route to rework instead of looping review forever - recommend \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\`, then \`cclaw internal rewind --ack tdd\` after TDD rework.
-
-Special-case for TDD blockers: when \`06-tdd.md\` records \`NO_SOURCE_CONTEXT\`, \`NO_TEST_SURFACE\`, \`NO_IMPLEMENTABLE_SLICE\`, \`RED_NOT_EXPRESSIBLE\`, or \`NO_VCS_MODE\`, keep status BLOCKED and print \`Current\`, \`Blocked by\`, \`Next\`, \`Repair path\`, and \`Evidence needed\` instead of retrying speculative RED/GREEN work. RED blockers need a runnable failing test surface, GREEN blockers need passing full-suite evidence, REFACTOR blockers need behavior-preservation evidence.
-
-**Path B — stage IS complete (all gates met, all delegations done):**
-
-If \`next\` is \`done\`:
-
-When \`currentStage\` is \`ship\`, automatically drive the **closeout chain**
-by inspecting ${closeoutSubstateInline()}:
-
-| shipSubstate          | Action                                              |
-|-----------------------|-----------------------------------------------------|
-| \`idle\` / missing      | Flip to \`retro_review\` and start retro protocol     |
-| \`retro_review\`        | Draft/update \`09-retro.md\`, ask accept/edit/skip  |
-| \`compound_review\`     | Compound closeout: overlap scan, refresh/supersede, ask approve/skip |
-| \`ready_to_archive\`    | Run \`npx cclaw-cli archive\`; reset flow-state on success |
-| \`archived\`            | Report "run archived"; stop                         |
-
-Each step owns its own state transition. \`/cc\` keeps retro and compound
-in-session, then uses the archive runtime only at \`ready_to_archive\`.
-
-Otherwise report **"Flow complete. All stages finished."** and stop.
-
-Otherwise (non-terminal \`next\`): load the next stage skill and begin execution.
-
-## Stage order
-
-This table is the track-aware critical path. It must match \`flow-state.json.track\`; do not follow the natural schema edge when the active track skips a stage. Quick skips ceremony, not safety: spec approval, RED/GREEN/REFACTOR evidence, review, and ship gates still apply. After \`ship\`, \`/cc\` continues closeout via ${closeoutSubstateInline()}: ${closeoutChainInline()}.
-
-| Stage | Standard next | Medium next | Quick next | Skill path |
-|---|---|---|---|---|
-${stageRows}
-
-Natural schema edge reference for diagnostics only:
-
-| Stage | Natural next | Skill path |
-|---|---|---|
-${naturalStageRows}
-
-## Anti-patterns
-
-- Advancing when \`blocked\` is non-empty for the current stage.
-- Treating \`passed\` as trusted when artifact evidence contradicts it.
-- Skipping **review** or **ship** because "the code looks fine".
-- Loading a stage skill directly instead of using \`/cc\` for progression.
-`;
-}

package/dist/content/seed-shelf.d.ts

@@ -1,36 +0,0 @@
-export interface SeedShelfEntry {
-    fileName: string;
-    absPath: string;
-    relPath: string;
-    createdOn: string;
-    title: string;
-    triggerWhen: string[];
-    sourceStage: string | null;
-    sourceArtifact: string | null;
-    hypothesis: string | null;
-    action: string | null;
-    summary: string;
-    raw: string;
-}
-export interface SeedTemplateInput {
-    title: string;
-    triggerWhen: readonly string[];
-    hypothesis: string;
-    action: string;
-    sourceStage?: string;
-    sourceArtifact?: string;
-    createdAt?: Date;
-}
-export interface ResolvedSeedPath {
-    fileName: string;
-    absPath: string;
-    relPath: string;
-}
-export declare function seedShelfDir(projectRoot: string): string;
-export declare function seedSlug(title: string): string;
-export declare function seedFileName(title: string, createdAt?: Date): string;
-export declare function resolveSeedPathForWrite(projectRoot: string, title: string, createdAt?: Date): Promise<ResolvedSeedPath>;
-export declare function readSeedShelf(projectRoot: string): Promise<SeedShelfEntry[]>;
-export declare function seedMatchesPrompt(seed: SeedShelfEntry, prompt: string): boolean;
-export declare function findMatchingSeeds(projectRoot: string, prompt: string, maxMatches?: number): Promise<SeedShelfEntry[]>;
-export declare function renderSeedTemplate(input: SeedTemplateInput): string;

package/dist/content/seed-shelf.js

@@ -1,301 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parse } from "yaml";
-import { RUNTIME_ROOT } from "../constants.js";
-const SEED_FILE_NAME_PATTERN = /^SEED-(\d{4}-\d{2}-\d{2})-([a-z0-9]+(?:-[a-z0-9]+)*)(?:-(\d+))?\.md$/u;
-const DEFAULT_MAX_MATCHES = 3;
-const MAX_SEED_MATCHES = 10;
-const MIN_TOKEN_OVERLAP = 2;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeTriggerList(value) {
-    if (Array.isArray(value)) {
-        return value
-            .map((item) => typeof item === "string" || typeof item === "number" ? String(item).trim() : "")
-            .filter((item) => item.length > 0);
-    }
-    if (typeof value === "string") {
-        return value
-            .split(/,\s*/u)
-            .map((item) => item.trim())
-            .filter((item) => item.length > 0);
-    }
-    return [];
-}
-function parseSeedFrontmatter(raw) {
-    if (!raw.startsWith("---")) {
-        return { values: {}, body: raw };
-    }
-    const lines = raw.split(/\r?\n/u);
-    let closingIndex = -1;
-    for (let index = 1; index < lines.length; index += 1) {
-        if (lines[index]?.trim() === "---") {
-            closingIndex = index;
-            break;
-        }
-    }
-    if (closingIndex < 0) {
-        return { values: {}, body: raw };
-    }
-    const frontmatterRaw = lines.slice(1, closingIndex).join("\n");
-    const body = lines.slice(closingIndex + 1).join("\n");
-    try {
-        const parsed = parse(frontmatterRaw);
-        if (isRecord(parsed)) {
-            return { values: parsed, body };
-        }
-        return { values: {}, body };
-    }
-    catch {
-        return { values: {}, body };
-    }
-}
-function firstHeading(body) {
-    const match = /^#\s+(.+)$/mu.exec(body);
-    if (!match)
-        return null;
-    const title = match[1]?.trim() ?? "";
-    return title.length > 0 ? title : null;
-}
-function firstNonEmptyParagraph(body) {
-    const lines = body.split(/\r?\n/u);
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            continue;
-        if (/^#\s+/u.test(trimmed))
-            continue;
-        if (/^[-*]\s+/u.test(trimmed))
-            continue;
-        return trimmed;
-    }
-    return "";
-}
-function fromFileNameFallbackTitle(fileName) {
-    const stem = fileName.replace(/\.md$/u, "");
-    const withoutPrefix = stem.replace(/^SEED-\d{4}-\d{2}-\d{2}-/u, "");
-    return withoutPrefix
-        .split("-")
-        .filter((part) => part.length > 0 && !/^\d+$/u.test(part))
-        .map((part) => part[0]?.toUpperCase() + part.slice(1))
-        .join(" ")
-        .trim();
-}
-export function seedShelfDir(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "seeds");
-}
-export function seedSlug(title) {
-    const normalized = title
-        .toLowerCase()
-        .trim()
-        .replace(/[`"'“”‘’()[\]{}<>]/gu, " ")
-        .replace(/[^a-z0-9]+/gu, "-")
-        .replace(/^-+/u, "")
-        .replace(/-+$/u, "");
-    if (normalized.length === 0) {
-        return "seed";
-    }
-    return normalized.slice(0, 48);
-}
-function isoDate(value) {
-    return value.toISOString().slice(0, 10);
-}
-export function seedFileName(title, createdAt = new Date()) {
-    return `SEED-${isoDate(createdAt)}-${seedSlug(title)}.md`;
-}
-async function pathExists(absPath) {
-    try {
-        await fs.stat(absPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function resolveSeedPathForWrite(projectRoot, title, createdAt = new Date()) {
-    const seedsDir = seedShelfDir(projectRoot);
-    await fs.mkdir(seedsDir, { recursive: true });
-    const baseFile = seedFileName(title, createdAt);
-    const baseStem = baseFile.replace(/\.md$/u, "");
-    let candidate = baseFile;
-    let index = 2;
-    while (await pathExists(path.join(seedsDir, candidate))) {
-        candidate = `${baseStem}-${index}.md`;
-        index += 1;
-    }
-    return {
-        fileName: candidate,
-        absPath: path.join(seedsDir, candidate),
-        relPath: path.join(RUNTIME_ROOT, "seeds", candidate)
-    };
-}
-export async function readSeedShelf(projectRoot) {
-    const dir = seedShelfDir(projectRoot);
-    let names = [];
-    try {
-        names = await fs.readdir(dir);
-    }
-    catch {
-        return [];
-    }
-    const entries = [];
-    for (const fileName of names) {
-        if (!SEED_FILE_NAME_PATTERN.test(fileName))
-            continue;
-        const absPath = path.join(dir, fileName);
-        let raw = "";
-        try {
-            raw = await fs.readFile(absPath, "utf8");
-        }
-        catch {
-            continue;
-        }
-        const frontmatter = parseSeedFrontmatter(raw);
-        const title = (typeof frontmatter.values.title === "string" && frontmatter.values.title.trim().length > 0
-            ? frontmatter.values.title.trim()
-            : null) ??
-            firstHeading(frontmatter.body) ??
-            fromFileNameFallbackTitle(fileName) ??
-            "Untitled seed";
-        const triggerWhen = normalizeTriggerList(frontmatter.values.trigger_when ?? frontmatter.values.triggerWhen);
-        const sourceStage = typeof frontmatter.values.source_stage === "string"
-            ? frontmatter.values.source_stage
-            : typeof frontmatter.values.sourceStage === "string"
-                ? frontmatter.values.sourceStage
-                : null;
-        const sourceArtifact = typeof frontmatter.values.source_artifact === "string"
-            ? frontmatter.values.source_artifact
-            : typeof frontmatter.values.sourceArtifact === "string"
-                ? frontmatter.values.sourceArtifact
-                : null;
-        const hypothesis = typeof frontmatter.values.hypothesis === "string" ? frontmatter.values.hypothesis : null;
-        const action = typeof frontmatter.values.action === "string" ? frontmatter.values.action : null;
-        const createdOn = SEED_FILE_NAME_PATTERN.exec(fileName)?.[1] ?? "1970-01-01";
-        const summary = firstNonEmptyParagraph(frontmatter.body);
-        entries.push({
-            fileName,
-            absPath,
-            relPath: path.join(RUNTIME_ROOT, "seeds", fileName),
-            createdOn,
-            title,
-            triggerWhen,
-            sourceStage,
-            sourceArtifact,
-            hypothesis,
-            action,
-            summary,
-            raw
-        });
-    }
-    entries.sort((a, b) => b.fileName.localeCompare(a.fileName));
-    return entries;
-}
-function normalizeMatchText(value) {
-    return value.toLowerCase().trim().replace(/\s+/gu, " ");
-}
-function tokenizeSeedText(value) {
-    if (!value)
-        return [];
-    return value
-        .toLowerCase()
-        .split(/[^a-z0-9]+/u)
-        .map((token) => token.trim())
-        .filter((token) => token.length >= 3);
-}
-function uniqueTokens(values) {
-    return new Set(values);
-}
-function exactTriggerMatch(seed, normalizedPrompt) {
-    if (normalizedPrompt.length === 0 || seed.triggerWhen.length === 0)
-        return false;
-    return seed.triggerWhen.some((trigger) => {
-        const normalizedTrigger = normalizeMatchText(trigger);
-        return normalizedTrigger.length > 0 && normalizedPrompt.includes(normalizedTrigger);
-    });
-}
-function seedContentTokens(seed) {
-    return uniqueTokens([
-        ...tokenizeSeedText(seed.title),
-        ...tokenizeSeedText(seed.summary),
-        ...tokenizeSeedText(seed.hypothesis),
-        ...tokenizeSeedText(seed.action)
-    ]);
-}
-function tokenOverlap(seed, promptTokens) {
-    if (promptTokens.size === 0)
-        return 0;
-    const contentTokens = seedContentTokens(seed);
-    let overlap = 0;
-    for (const token of promptTokens) {
-        if (contentTokens.has(token))
-            overlap += 1;
-    }
-    return overlap;
-}
-export function seedMatchesPrompt(seed, prompt) {
-    const normalizedPrompt = normalizeMatchText(prompt);
-    if (exactTriggerMatch(seed, normalizedPrompt))
-        return true;
-    return tokenOverlap(seed, uniqueTokens(tokenizeSeedText(prompt))) >= MIN_TOKEN_OVERLAP;
-}
-export async function findMatchingSeeds(projectRoot, prompt, maxMatches = DEFAULT_MAX_MATCHES) {
-    const seeds = await readSeedShelf(projectRoot);
-    const normalizedPrompt = normalizeMatchText(prompt);
-    if (normalizedPrompt.length === 0)
-        return [];
-    const promptTokens = uniqueTokens(tokenizeSeedText(prompt));
-    const cappedMax = typeof maxMatches === "number" && Number.isFinite(maxMatches) && maxMatches > 0
-        ? Math.min(MAX_SEED_MATCHES, Math.max(1, Math.floor(maxMatches)))
-        : DEFAULT_MAX_MATCHES;
-    const ranked = seeds
-        .map((seed, index) => {
-        const exact = exactTriggerMatch(seed, normalizedPrompt);
-        const overlap = tokenOverlap(seed, promptTokens);
-        return { seed, index, exact, overlap };
-    })
-        .filter((row) => row.exact || row.overlap >= MIN_TOKEN_OVERLAP);
-    ranked.sort((a, b) => {
-        if (a.exact !== b.exact)
-            return a.exact ? -1 : 1;
-        if (b.overlap !== a.overlap)
-            return b.overlap - a.overlap;
-        const recency = b.seed.createdOn.localeCompare(a.seed.createdOn);
-        if (recency !== 0)
-            return recency;
-        return a.index - b.index;
-    });
-    return ranked.slice(0, cappedMax).map((row) => row.seed);
-}
-export function renderSeedTemplate(input) {
-    const triggerWhen = [...input.triggerWhen].map((item) => item.trim()).filter((item) => item.length > 0);
-    const createdAt = input.createdAt ?? new Date();
-    const sourceStage = input.sourceStage?.trim() || "unknown";
-    const sourceArtifact = input.sourceArtifact?.trim() || "unknown";
-    return `---
-title: ${input.title.trim()}
-created_at: ${createdAt.toISOString()}
-source_stage: ${sourceStage}
-source_artifact: ${sourceArtifact}
-trigger_when:
-${triggerWhen.length > 0 ? triggerWhen.map((trigger) => `  - ${trigger}`).join("\n") : "  - <trigger token>"}
-hypothesis: ${input.hypothesis.trim()}
-action: ${input.action.trim()}
----
-
-# ${input.title.trim()}
-
-## Why capture this seed
-${input.hypothesis.trim()}
-
-## Trigger when
-${triggerWhen.length > 0 ? triggerWhen.map((trigger) => `- ${trigger}`).join("\n") : "- <trigger token>"}
-
-## Suggested action
-${input.action.trim()}
-
-## Notes
-- Expected payoff:
-- Risks:
-`;
-}

package/dist/content/stage-common-guidance.d.ts

@@ -1 +0,0 @@
-export declare function stageCommonGuidanceMarkdown(): string;