@trieungoctam/speckit 0.2.2 → 0.3.0

package/dist/core/beads-mirror.js

@@ -0,0 +1,46 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readSyncedStories } from "./synced-stories.js";
+export async function writeBeadsMirror(root, stories) {
+    const path = ".beads/beads.jsonl";
+    const now = new Date().toISOString();
+    const jsonl = stories
+        .map((story) => JSON.stringify(toBeadIssue(story, now)))
+        .join("\n");
+    const target = join(root, path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${jsonl}${jsonl ? "\n" : ""}`, "utf8");
+    return path;
+}
+export async function prepareBeadsMirror(root) {
+    return writeBeadsMirror(root, await readSyncedStories(root));
+}
+function toBeadIssue(story, timestamp) {
+    return {
+        id: story.id,
+        title: story.title,
+        description: `Speckit story: ${story.path}`,
+        status: mapStatus(story.status),
+        priority: 2,
+        issue_type: "task",
+        labels: ["speckit", "story"],
+        created_at: timestamp,
+        updated_at: timestamp,
+    };
+}
+function mapStatus(status) {
+    switch (status) {
+        case "in-progress":
+            return "in_progress";
+        case "ready-for-review":
+        case "review-ready":
+            return "review";
+        case "closed":
+        case "done":
+            return "closed";
+        case "draft":
+            return "draft";
+        default:
+            return "open";
+    }
+}

package/dist/core/memory.d.ts

@@ -0,0 +1 @@
+export declare function refreshMemory(root: string): Promise<string[]>;

package/dist/core/memory.js

@@ -0,0 +1,47 @@
+import { markdown, writeManagedFiles } from "./managed-files.js";
+export async function refreshMemory(root) {
+    const files = [
+        {
+            path: ".speckit/memory/project-context.md",
+            content: markdown(`# Spec Project Context
+
+## Technology Stack & Versions
+- Update this section with project-specific runtime, framework, test, and deployment facts.
+
+## Critical Implementation Rules
+- Prefer existing project patterns over generic framework defaults.
+- Keep implementation scoped to the active story and acceptance criteria.
+- Record red-green-refactor evidence for code stories.
+- Use robot-safe graph commands only.
+
+## Context Loading Rules
+- Load this file before implementation, review, sprint planning, and session resume.
+- Treat this file as durable guidance, not as proof that the current environment still matches it.
+`),
+        },
+        {
+            path: ".speckit/memory/decisions.md",
+            content: markdown(`# Spec Decisions
+
+## Active Decisions
+- Record durable architecture and workflow decisions here.
+
+## Superseded Decisions
+- Move stale decisions here with the replacement decision and date.
+`),
+        },
+        {
+            path: ".speckit/memory/lessons.md",
+            content: markdown(`# Spec Lessons
+
+## Repeated Mistakes To Avoid
+- Add a lesson when an agent repeats a mistake or review catches a missed project rule.
+
+## Useful Verification Commands
+- Add commands that reliably validate this project.
+`),
+        },
+    ];
+    const results = await writeManagedFiles(root, files, false);
+    return results.map((result) => result.path);
+}

package/dist/core/scaffold.js

@@ -1,5 +1,6 @@
 import { markdown, text } from "./managed-files.js";
 import { agilePolicy, enterpriseSafetyPolicy, tddPolicy, workflowReview, workflowShape, workflowTddRun, } from "./policy.js";
+import { storyTemplate, tddEvidenceTemplate } from "./templates.js";
 export function coreFiles() {
     return [
         {
@@ -13,6 +14,14 @@ tdd:
 task_graph:
   provider: beads
   bv_robot_only: true
+memory:
+  project_context: .speckit/memory/project-context.md
+  session_dir: .speckit/sessions
+skills:
+  catalog: .speckit/skills/catalog.md
+  super_agent: .speckit/agents/super-agent.md
+sprint:
+  status: .speckit/sprint/status.yaml
 adapters:
   enabled: []`),
         },
@@ -27,63 +36,11 @@ adapters:
         { path: ".speckit/workflows/review.md", content: markdown(workflowReview) },
         {
             path: ".speckit/templates/story.md",
-            content: markdown(`---
-status: draft
-evidence: .speckit/evidence/{{slug}}-tdd-evidence.md
-context: pending
----
-
-# Story: {{title}}
-
-## Intent
-{{intent}}
-
-## Acceptance Criteria
-- Given ...
-- When ...
-- Then ...
-
-## TDD Checklist
-- [ ] Test targets identified
-- [ ] Red evidence recorded
-- [ ] Green evidence recorded
-- [ ] Refactor validation recorded
-
-## Notes
-- Risks:
-- Dependencies:
-
-## Spec Anti-Mistake Checklist
-- Reuse existing project patterns before adding new files.
-- Verify file locations before editing.
-- Do not introduce new libraries without explicit need.
-- Preserve existing behavior unless an acceptance criterion requires change.
-- Capture previous-story learnings if this continues prior work.
-`),
+            content: markdown(storyTemplate),
         },
         {
             path: ".speckit/templates/tdd-evidence.md",
-            content: markdown(`---
-status: missing
-story: {{story}}
----
-
-# TDD Evidence: {{story}}
-
-## Test Intent
-
-## Red
-- Command:
-- Result:
-
-## Green
-- Command:
-- Result:
-
-## Refactor
-- Command:
-- Result:
-`),
+            content: markdown(tddEvidenceTemplate),
         },
     ];
 }
@@ -94,12 +51,14 @@ export function enterpriseFiles() {
             content: markdown(`# Spec Flow
 
 ## Order
-start -> shape -> plan -> context -> sync -> triage -> run -> review -> close
+start -> memory -> sprint -> context -> sync -> triage -> ready -> run -> checkpoint -> review -> close
 
 ## Traceability
 - A session links the original idea to every downstream artifact.
+- Project memory links durable rules to every new session.
 - A story links acceptance criteria to TDD evidence.
 - Sync links stories to graph-ready JSONL.
+- Session checkpoints preserve file changes, decisions, and next steps across compaction.
 - Close links review output back to story and graph sync.
 `),
         },
@@ -127,6 +86,11 @@ graph:
 
 - Current context: \`.speckit/context/current.md\`
 - Subagent handoff: \`.speckit/context/subagent-handoff.md\`
+- Project memory: \`.speckit/memory/project-context.md\`
+- Active session summary: \`.speckit/sessions/active.md\` and the linked \`summary.md\`
+- Active artifact log: linked \`artifact-log.md\`
+- Super agent router: \`.speckit/agents/super-agent.md\`
+- Skill catalog: \`.speckit/skills/catalog.md\`
 - Story with acceptance criteria
 - Matching TDD evidence file
 - Tool policy: \`.speckit/tool-policy.yaml\`
@@ -136,6 +100,7 @@ graph:
 - Story status is \`ready-for-dev\`.
 - Context status is \`fresh\`.
 - \`speckit ready <story>\` returns ready.
+- \`speckit session status\` identifies the active session.
 
 ## Allowed Edits
 
@@ -149,26 +114,31 @@ graph:
 Use the red-green-refactor loop.
 
 1. Read the current context before touching code.
-2. Confirm the story path, acceptance criteria, and evidence path.
-3. Write or run the smallest failing test first.
-4. Record red evidence before implementation.
-5. Implement the smallest change that satisfies the failing test.
-6. Record green evidence after tests pass.
-7. Refactor only while tests stay green, then record validation.
-8. Use graph commands only through robot-safe flags such as \`bv --robot-next --format json\`.
-9. Run \`speckit review\` before handoff.
+2. Read the super agent router and select the smallest matching Speckit skill.
+3. Confirm the story path, acceptance criteria, and evidence path.
+4. Write or run the smallest failing test first.
+5. Record red evidence before implementation.
+6. Implement the smallest change that satisfies the failing test.
+7. Record green evidence after tests pass.
+8. Refactor only while tests stay green, then record validation.
+9. Use graph commands only through robot-safe flags such as \`bv --robot-next --format json\`.
+10. Run \`speckit session checkpoint --note "<phase complete>"\` after red, green, refactor, and review boundaries.
+11. Run \`speckit session compact\` before context gets noisy or before handing off to another agent.
+12. Run \`speckit review\` before handoff.
 
 ## Stop Conditions
 
 - Stop if acceptance criteria are missing.
 - Stop if the evidence file cannot be identified.
 - Stop if \`speckit ready <story>\` reports blocked.
+- Stop if active session state cannot be written.
 - Stop before destructive commands, production changes, or secret access.
 
 ## Completion Signal
 
 - All acceptance criteria satisfied.
 - TDD evidence status can be advanced through red, green, and refactor.
+- Session checkpoint and compact summary are current.
 - Review handoff is ready.
 `),
         },

package/dist/core/session-manager.d.ts

@@ -0,0 +1,15 @@
+export type SessionCheckpointOptions = {
+    root: string;
+    note?: string;
+    story?: string;
+};
+export type SessionRef = {
+    id: string;
+    dir: string;
+};
+export declare function ensureSession(root: string, intent?: string): Promise<SessionRef>;
+export declare function createSession(root: string, intent?: string): Promise<SessionRef>;
+export declare function checkpointSession(options: SessionCheckpointOptions): Promise<SessionRef>;
+export declare function compactSession(root: string): Promise<SessionRef>;
+export declare function resumeSession(root: string, id?: string): Promise<SessionRef | undefined>;
+export declare function sessionStatus(root: string): Promise<Record<string, string>>;

package/dist/core/session-manager.js

@@ -0,0 +1,139 @@
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { slugify, timestamp } from "./slug.js";
+export async function ensureSession(root, intent = "long session") {
+    const active = await readActiveSession(root);
+    if (active)
+        return active;
+    return createSession(root, intent);
+}
+export async function createSession(root, intent = "long session") {
+    const id = `${timestamp()}-${slugify(intent)}`;
+    const ref = { id, dir: `.speckit/sessions/${id}` };
+    await mkdir(join(root, ref.dir), { recursive: true });
+    await writeActiveSession(root, ref);
+    await writeFile(join(root, ref.dir, "events.jsonl"), "", "utf8");
+    await writeFile(join(root, ref.dir, "artifact-log.md"), "# Spec Artifact Log\n\n", "utf8");
+    await writeFile(join(root, ref.dir, "summary.md"), baseSummary(intent), "utf8");
+    await writeState(root, ref, { phase: "started", status: "active", story: "pending" });
+    await writeHandoff(root, ref, "Start from the active Speckit session state.");
+    return ref;
+}
+export async function checkpointSession(options) {
+    const ref = await ensureSession(options.root, options.note ?? "checkpoint");
+    const event = {
+        type: "checkpoint",
+        at: new Date().toISOString(),
+        note: options.note ?? "Manual checkpoint",
+        story: options.story,
+    };
+    await appendFile(join(options.root, ref.dir, "events.jsonl"), `${JSON.stringify(event)}\n`, "utf8");
+    await appendFile(join(options.root, ref.dir, "artifact-log.md"), `## ${event.at}\n- Note: ${event.note}\n${options.story ? `- Story: \`${options.story}\`\n` : ""}\n`, "utf8");
+    await writeState(options.root, ref, {
+        phase: "checkpointed",
+        status: "active",
+        story: options.story ?? "pending",
+    });
+    return ref;
+}
+export async function compactSession(root) {
+    const ref = await ensureSession(root, "compact");
+    const [state, context, handoff, artifactLog] = await Promise.all([
+        readOptional(root, `${ref.dir}/state.yaml`),
+        readOptional(root, ".speckit/context/current.md"),
+        readOptional(root, ".speckit/context/subagent-handoff.md"),
+        readOptional(root, `${ref.dir}/artifact-log.md`),
+    ]);
+    const summary = `# Spec Session Summary
+
+## Session Intent
+Preserve the active Speckit workflow so another agent or compacted session can continue safely.
+
+## Current State
+${state || "- No state recorded yet."}
+
+## Active Context
+${extractCompactSection(context)}
+
+## Files And Artifacts
+${extractCompactSection(artifactLog)}
+
+## Decisions Made
+- Trust current files over stale memory.
+- Keep implementation bounded by the selected story and readiness gate.
+
+## Next Steps
+1. Read \`.speckit/memory/project-context.md\`.
+2. Read \`.speckit/context/current.md\` and \`.speckit/context/subagent-handoff.md\`.
+3. Run \`speckit session status\`.
+4. Run \`speckit ready <story>\` before implementation.
+
+## Resume Handoff
+${extractCompactSection(handoff)}
+`;
+    await writeFile(join(root, ref.dir, "summary.md"), summary, "utf8");
+    await writeHandoff(root, ref, "Resume from the compacted session summary before loading task context.");
+    return ref;
+}
+export async function resumeSession(root, id) {
+    const ref = id ? { id, dir: `.speckit/sessions/${id}` } : await readActiveSession(root);
+    if (!ref)
+        return undefined;
+    await writeActiveSession(root, ref);
+    await writeHandoff(root, ref, "Resume this session and continue from summary, context, and artifact log.");
+    return ref;
+}
+export async function sessionStatus(root) {
+    const ref = await readActiveSession(root);
+    if (!ref)
+        return { status: "missing" };
+    return {
+        status: "active",
+        id: ref.id,
+        dir: ref.dir,
+        state: `${ref.dir}/state.yaml`,
+        summary: `${ref.dir}/summary.md`,
+        handoff: `${ref.dir}/handoff.md`,
+    };
+}
+async function readActiveSession(root) {
+    try {
+        const content = await readFile(join(root, ".speckit", "sessions", "active.md"), "utf8");
+        const id = content.match(/session:\s*([^\s]+)/)?.[1];
+        return id ? { id, dir: `.speckit/sessions/${id}` } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeActiveSession(root, ref) {
+    await writeText(root, ".speckit/sessions/active.md", `# Active Spec Session\n\nsession: ${ref.id}\n`);
+}
+async function writeState(root, ref, state) {
+    const body = Object.entries({ session: ref.id, updated: new Date().toISOString(), ...state })
+        .map(([key, value]) => `${key}: ${value}`)
+        .join("\n");
+    await writeText(root, `${ref.dir}/state.yaml`, `${body}\n`);
+}
+async function writeHandoff(root, ref, note) {
+    await writeText(root, `${ref.dir}/handoff.md`, `# Spec Session Handoff\n\n${note}\n\n## Load Order\n1. \`${ref.dir}/summary.md\`\n2. \`${ref.dir}/state.yaml\`\n3. \`${ref.dir}/artifact-log.md\`\n4. \`.speckit/context/current.md\`\n`);
+}
+async function writeText(root, path, content) {
+    const target = join(root, path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, content, "utf8");
+}
+async function readOptional(root, path) {
+    try {
+        return await readFile(join(root, path), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function baseSummary(intent) {
+    return `# Spec Session Summary\n\n## Session Intent\n${intent}\n\n## Current State\n- Session started.\n\n## Next Steps\n1. Build context.\n2. Sync graph.\n3. Run readiness.\n`;
+}
+function extractCompactSection(content) {
+    return content.trim() ? content.trim().split("\n").slice(0, 40).join("\n") : "- Not recorded.";
+}

package/dist/core/skill-catalog.d.ts

@@ -0,0 +1,2 @@
+import { ManagedFile } from "./managed-files.js";
+export declare function specSkillFiles(): ManagedFile[];

package/dist/core/skill-catalog.js

@@ -0,0 +1,177 @@
+import { json, markdown } from "./managed-files.js";
+const selectedSources = [
+    "brainstorm",
+    "research",
+    "docs-seeker",
+    "plan",
+    "project-management",
+    "scout",
+    "context-engineering",
+    "kanban",
+    "implementation-runner",
+    "test",
+    "debug",
+    "fix",
+    "code-review",
+    "security-scan",
+    "docs",
+    "journal",
+    "git",
+    "ship",
+];
+const skills = [
+    skill("spec-shape", "shape", "Turn a rough request into a bounded Agile spec before planning.", [
+        "Clarify business goal, users, constraints, and non-goals.",
+        "Split large ideas into independent stories with acceptance criteria.",
+        "Challenge over-engineered scope before it reaches implementation.",
+    ]),
+    skill("spec-research", "research", "Validate external tools, docs, or architecture choices before planning.", [
+        "Define recency and source-quality requirements before searching.",
+        "Prefer official docs, primary repos, and current release notes.",
+        "Summarize recommendations, risks, and rejected options in reports.",
+    ]),
+    skill("spec-plan", "plan", "Create PRD, architecture, story, and evidence skeletons.", [
+        "Check unfinished plans before creating new work.",
+        "Write phases with files, dependencies, success criteria, and rollback.",
+        "Keep plan state durable so sessions can rehydrate tasks later.",
+    ]),
+    skill("spec-context", "context", "Build the smallest useful story context and subagent handoff.", [
+        "Read project memory, active session, story, evidence, and relevant files.",
+        "List files to read and files to modify separately.",
+        "Avoid passing full chat history to implementation agents.",
+    ]),
+    skill("spec-session", "session", "Manage checkpoint, compaction, resume, and artifact-log discipline.", [
+        "Checkpoint after red, green, refactor, review, and scope changes.",
+        "Compact noisy context into durable summaries before handoff.",
+        "Sync runtime task progress back to plan and story files.",
+    ]),
+    skill("spec-graph", "graph", "Use sprint and graph robot outputs to choose safe, unblocked work.", [
+        "Run Beads Viewer through robot-safe commands only.",
+        "Prefer unblocked, high-value stories with clear evidence paths.",
+        "Mirror story state to graph artifacts before triage or next selection.",
+    ]),
+    skill("spec-tdd", "run", "Run a ready story through red-green-refactor with evidence and checkpoints.", [
+        "Require ready-for-dev status and current context before code edits.",
+        "Write or run the smallest failing test before implementation.",
+        "Record red, green, and refactor evidence with session checkpoints.",
+    ]),
+    skill("spec-test", "test", "Select and run verification after implementation.", [
+        "Map changed files to focused tests first, then broaden when risk is high.",
+        "Run typecheck or build before claiming code is valid.",
+        "Never ignore failing tests; report root cause or blocker.",
+    ]),
+    skill("spec-debug", "debug", "Diagnose failures with evidence before changing code.", [
+        "Capture exact failing output and pre-fix state.",
+        "Trace root cause through callers, dependencies, and recent changes.",
+        "Fix the cause, then verify against the original failure.",
+    ]),
+    skill("spec-review", "review", "Review acceptance coverage, TDD evidence, safety, docs, and session freshness.", [
+        "Review spec compliance before code quality opinions.",
+        "Prioritize correctness, security, regressions, and missing tests.",
+        "Block closure when evidence, context, or session state is stale.",
+    ]),
+    skill("spec-docs", "docs", "Update durable docs, changelog, and lessons after behavior changes.", [
+        "Update roadmap and changelog when milestone or behavior changes.",
+        "Record decisions and lessons in project memory when reusable.",
+        "Keep docs aligned with actual implemented behavior.",
+    ]),
+    skill("spec-ship", "ship", "Prepare clean release handoff after tests and review pass.", [
+        "Check git diff for unrelated changes and secrets before commit.",
+        "Use focused conventional commits and release notes.",
+        "Do not ship while tests, review, or evidence gates are failing.",
+    ]),
+];
+function skill(name, phase, purpose, practices) {
+    return { name, phase, purpose, practices };
+}
+export function specSkillFiles() {
+    return [catalogFile(), schemaFile(), ...skills.map(skillFile)];
+}
+function catalogFile() {
+    return {
+        path: ".speckit/skills/catalog.md",
+        content: markdown(`# Spec Skill Catalog
+
+This catalog is intentionally smaller than a broad general-purpose skill set. Speckit keeps only the skills required for enterprise Agile, TDD, long sessions, graph-guided work, and release hygiene.
+
+## Core Skills
+
+| Skill | Inspired By | Use When | Required Inputs |
+| --- | --- | --- | --- |
+| spec-shape | brainstorm, scenario | Turning rough intent into a bounded spec | user intent, project memory |
+| spec-research | research, docs-seeker | Validating external choices and current docs | scope, source criteria |
+| spec-plan | plan, project-management | Creating PRD, architecture, stories, and evidence skeletons | spec brief, project memory |
+| spec-context | scout, context-engineering | Building current story context and handoff | story, evidence, session state |
+| spec-graph | kanban, plans-kanban, gkg | Choosing and sequencing safe work | synced stories, robot graph output |
+| spec-session | context-engineering, watzup | Preserving long-running work | active session, artifact log |
+| spec-tdd | implementation-runner, test | Implementing code with red-green-refactor | ready story, context, evidence |
+| spec-test | test, web-testing | Selecting and running verification | changed files, acceptance criteria |
+| spec-debug | debug, fix, sequential-thinking | Diagnosing failures before changing code | failing output, impact scope |
+| spec-review | code-review, security-scan | Reviewing code and artifacts | diff, story, evidence, session log |
+| spec-docs | docs, journal, retro | Updating docs and durable decisions | changed behavior, release notes |
+| spec-ship | git, ship, deploy | Preparing clean release handoff | passing tests, review result |
+
+## Selection Policy
+
+- Pick the smallest skill that covers the current phase.
+- Load skill detail only when that phase is active.
+- Never mix planning and implementation in the same skill invocation.
+- Prefer file handoff over chat handoff for subagents.
+- Do not import broad domain skills unless the current story explicitly needs that domain.
+- Use \`spec-debug\` before fixes when the root cause is not proven.
+- Use \`spec-test\` after implementation and before review.
+`),
+    };
+}
+function schemaFile() {
+    return {
+        path: ".speckit/skills/schema.json",
+        content: json({
+            version: 1,
+            required: ["name", "purpose", "phase", "inputs", "outputs", "stop_conditions"],
+            statuses: ["DONE", "DONE_WITH_CONCERNS", "BLOCKED", "NEEDS_CONTEXT"],
+            selected_from: selectedSources,
+        }),
+    };
+}
+function skillFile(skill) {
+    return {
+        path: `.speckit/skills/${skill.name}.md`,
+        content: markdown(`# ${skill.name}
+
+## Purpose
+
+${skill.purpose}
+
+## Phase
+
+${skill.phase}
+
+## Required Context
+
+- \`.speckit/memory/project-context.md\`
+- \`.speckit/sessions/active.md\`
+- \`.speckit/context/current.md\` when story-scoped
+- \`.speckit/context/subagent-handoff.md\` when delegating
+
+## Practices
+
+${skill.practices.map((practice) => `- ${practice}`).join("\n")}
+
+## Stop Conditions
+
+- Missing acceptance criteria.
+- Missing or stale active session.
+- Missing evidence path for code work.
+- Blocked story or unresolved \`NEEDS_CONTEXT\` handoff.
+
+## Output Contract
+
+- State what was read.
+- State what changed.
+- State the next Speckit command.
+- Write durable progress to the appropriate Speckit artifact.
+- End delegated work with \`DONE\`, \`DONE_WITH_CONCERNS\`, \`BLOCKED\`, or \`NEEDS_CONTEXT\`.
+`),
+    };
+}

package/dist/core/synced-stories.d.ts

@@ -0,0 +1,8 @@
+export type SyncedStory = {
+    id: string;
+    path: string;
+    title: string;
+    status: string;
+};
+export declare function readSyncedStories(root: string): Promise<SyncedStory[]>;
+export declare function selectableStories(stories: SyncedStory[]): SyncedStory[];

package/dist/core/synced-stories.js

@@ -0,0 +1,17 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function readSyncedStories(root) {
+    try {
+        const content = await readFile(join(root, ".speckit", "sync", "beads-sync.jsonl"), "utf8");
+        return content
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+export function selectableStories(stories) {
+    return stories.filter((story) => ["open", "ready-for-dev", "in-progress"].includes(story.status));
+}

package/dist/core/templates.d.ts

@@ -0,0 +1,2 @@
+export declare const storyTemplate = "---\nstatus: draft\nevidence: .speckit/evidence/{{slug}}-tdd-evidence.md\ncontext: pending\n---\n\n# Story: {{title}}\n\n## Intent\n{{intent}}\n\n## Acceptance Criteria\n- Given ...\n- When ...\n- Then ...\n\n## TDD Checklist\n- [ ] Test targets identified\n- [ ] Red evidence recorded\n- [ ] Green evidence recorded\n- [ ] Refactor validation recorded\n\n## Notes\n- Risks:\n- Dependencies:\n\n## Spec Anti-Mistake Checklist\n- Reuse existing project patterns before adding new files.\n- Verify file locations before editing.\n- Do not introduce new libraries without explicit need.\n- Preserve existing behavior unless an acceptance criterion requires change.\n- Capture previous-story learnings if this continues prior work.\n";
+export declare const tddEvidenceTemplate = "---\nstatus: missing\nstory: {{story}}\n---\n\n# TDD Evidence: {{story}}\n\n## Test Intent\n\n## Red\n- Command:\n- Result:\n\n## Green\n- Command:\n- Result:\n\n## Refactor\n- Command:\n- Result:\n";