@trieungoctam/speckit 0.2.2 → 0.3.1

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,3 @@
+import { ManagedFile } from "./managed-files.js";
+export declare function specSkillFiles(): ManagedFile[];
+export declare function specSkillNames(): string[];

package/dist/core/skill-catalog.js

@@ -0,0 +1,180 @@
+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)];
+}
+export function specSkillNames() {
+    return skills.map((skill) => skill.name);
+}
+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";

package/dist/core/templates.js

@@ -0,0 +1,54 @@
+export const storyTemplate = `---
+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.
+`;
+export const tddEvidenceTemplate = `---
+status: missing
+story: {{story}}
+---
+
+# TDD Evidence: {{story}}
+
+## Test Intent
+
+## Red
+- Command:
+- Result:
+
+## Green
+- Command:
+- Result:
+
+## Refactor
+- Command:
+- Result:
+`;

package/dist/core/workflow-contract.d.ts

@@ -0,0 +1,7 @@
+export declare const workflowContract: {
+    readonly phases: readonly ["start", "memory", "sprint", "context", "sync", "triage", "ready", "run", "checkpoint", "review", "close"];
+    readonly skills: string[];
+    readonly statuses: readonly ["DONE", "DONE_WITH_CONCERNS", "BLOCKED", "NEEDS_CONTEXT"];
+    readonly requiredPromptTerms: readonly [readonly ["project memory", ".speckit/memory/project-context.md"], readonly ["active session", ".speckit/sessions/active.md"], readonly ["current context", ".speckit/context/current.md"], readonly ["subagent handoff", ".speckit/context/subagent-handoff.md"], readonly ["acceptance criteria", "AC coverage", "ACs"], readonly ["red-green-refactor", "red/green/refactor"], readonly ["checkpoint", "speckit session checkpoint"], readonly ["compact", "compaction", "speckit session compact"], readonly ["robot-safe", "bv --robot", "robot commands"], readonly ["ready-for-dev", "speckit ready"]];
+    readonly requiredRouterTerms: readonly ["smallest matching Speckit skill", "Work context path", "Reports path", "Plans path", "Hydrate runtime tasks", "Sync completed runtime tasks"];
+};

package/dist/core/workflow-contract.js

@@ -0,0 +1,38 @@
+import { specSkillNames } from "./skill-catalog.js";
+export const workflowContract = {
+    phases: [
+        "start",
+        "memory",
+        "sprint",
+        "context",
+        "sync",
+        "triage",
+        "ready",
+        "run",
+        "checkpoint",
+        "review",
+        "close",
+    ],
+    skills: specSkillNames(),
+    statuses: ["DONE", "DONE_WITH_CONCERNS", "BLOCKED", "NEEDS_CONTEXT"],
+    requiredPromptTerms: [
+        ["project memory", ".speckit/memory/project-context.md"],
+        ["active session", ".speckit/sessions/active.md"],
+        ["current context", ".speckit/context/current.md"],
+        ["subagent handoff", ".speckit/context/subagent-handoff.md"],
+        ["acceptance criteria", "AC coverage", "ACs"],
+        ["red-green-refactor", "red/green/refactor"],
+        ["checkpoint", "speckit session checkpoint"],
+        ["compact", "compaction", "speckit session compact"],
+        ["robot-safe", "bv --robot", "robot commands"],
+        ["ready-for-dev", "speckit ready"],
+    ],
+    requiredRouterTerms: [
+        "smallest matching Speckit skill",
+        "Work context path",
+        "Reports path",
+        "Plans path",
+        "Hydrate runtime tasks",
+        "Sync completed runtime tasks",
+    ],
+};

package/dist/core/workflow-validator.d.ts

@@ -0,0 +1,6 @@
+export type ContractCheck = {
+    name: string;
+    ok: boolean;
+    detail: string;
+};
+export declare function validateWorkflowContract(root: string): Promise<ContractCheck[]>;

package/dist/core/workflow-validator.js

@@ -0,0 +1,133 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAdapters } from "../config/adapter-registry.js";
+import { validatePermissionPolicy } from "./permission-auditor.js";
+import { workflowContract } from "./workflow-contract.js";
+export async function validateWorkflowContract(root) {
+    const checks = [];
+    const catalog = await read(root, ".speckit/skills/catalog.md");
+    const router = await read(root, ".speckit/agents/super-agent.md");
+    const flow = await read(root, ".speckit/flows/spec-flow.md");
+    const runPrompt = await read(root, ".speckit/prompts/spec-run.md");
+    checks.push(requiredFile(".speckit/skills/catalog.md", catalog));
+    checks.push(requiredFile(".speckit/agents/super-agent.md", router));
+    checks.push(requiredFile(".speckit/flows/spec-flow.md", flow));
+    checks.push(requiredFile(".speckit/prompts/spec-run.md", runPrompt));
+    checks.push(await skillsCheck(root, catalog));
+    checks.push(containsAll("super-agent router", router, workflowContract.requiredRouterTerms));
+    checks.push(orderedFlowCheck(flow));
+    checks.push(containsAll("enterprise run prompt", runPrompt, workflowContract.requiredPromptTerms));
+    checks.push(await permissionPolicyCheck(root));
+    checks.push(await adapterPromptCheck(root));
+    return checks;
+}
+async function permissionPolicyCheck(root) {
+    const missing = await validatePermissionPolicy(root);
+    return {
+        name: "permission policy",
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? "aligned" : `missing: ${missing.join(", ")}`,
+    };
+}
+function requiredFile(path, content) {
+    return {
+        name: path,
+        ok: content !== undefined,
+        detail: content === undefined ? "missing" : "present",
+    };
+}
+async function skillsCheck(root, catalog) {
+    const missing = [];
+    for (const skill of workflowContract.skills) {
+        if (!(await exists(root, `.speckit/skills/${skill}.md`)) || !catalog?.includes(skill)) {
+            missing.push(skill);
+        }
+    }
+    return {
+        name: "core skills",
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? `${workflowContract.skills.length} skills aligned` : `missing: ${missing.join(", ")}`,
+    };
+}
+function orderedFlowCheck(flow) {
+    if (!flow)
+        return { name: "workflow phase order", ok: false, detail: "flow file missing" };
+    let cursor = -1;
+    const missing = [];
+    for (const phase of workflowContract.phases) {
+        const next = flow.indexOf(phase, cursor + 1);
+        if (next === -1) {
+            missing.push(phase);
+            continue;
+        }
+        cursor = next;
+    }
+    return {
+        name: "workflow phase order",
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? workflowContract.phases.join(" -> ") : `missing or out of order: ${missing.join(", ")}`,
+    };
+}
+function containsAll(name, content, terms) {
+    const haystack = content?.toLowerCase() ?? "";
+    const missing = terms.filter((term) => !matchesTerm(haystack, term)).map(termLabel);
+    return {
+        name,
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? "aligned" : `missing: ${missing.join(", ")}`,
+    };
+}
+function matchesTerm(haystack, term) {
+    const alternatives = Array.isArray(term) ? term : [term];
+    return alternatives.some((alternative) => haystack.includes(alternative.toLowerCase()));
+}
+function termLabel(term) {
+    return typeof term === "string" ? term : term[0];
+}
+async function adapterPromptCheck(root) {
+    const missing = [];
+    const checked = [];
+    for (const adapter of getAdapters("all")) {
+        const content = await readExisting(root, adapter.outputPaths);
+        if (!content)
+            continue;
+        checked.push(adapter.name);
+        const check = containsAll(adapter.name, content, workflowContract.requiredPromptTerms);
+        if (!check.ok)
+            missing.push(`${adapter.name} (${check.detail})`);
+    }
+    if (checked.length === 0) {
+        return { name: "adapter prompt contracts", ok: false, detail: "no adapter files found" };
+    }
+    return {
+        name: "adapter prompt contracts",
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? `aligned: ${checked.join(", ")}` : missing.join("; "),
+    };
+}
+async function readExisting(root, paths) {
+    const chunks = [];
+    for (const path of paths) {
+        const content = await read(root, path);
+        if (content)
+            chunks.push(content);
+    }
+    return chunks.length > 0 ? chunks.join("\n") : undefined;
+}
+async function read(root, path) {
+    try {
+        return await readFile(join(root, path), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function exists(root, path) {
+    try {
+        await access(join(root, path));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/docs/development-roadmap.md

@@ -4,9 +4,9 @@
 
 Speckit MVP is implemented and pushed to `git@github.com:trieungoctam/speckit.git` on `main`.
 
-Current package target: `@trieungoctam/speckit@0.2.2`.
+Current package target: `@trieungoctam/speckit@0.3.1`.
 
-The CLI is npx-ready, generates Agile + TDD rules, creates workflow artifacts, supports five IDE adapters, wraps Beads Viewer safely, includes an enterprise harness, and has automated prompt/readiness tests plus CI.
+The CLI is npx-ready, generates Agile + TDD rules, creates workflow artifacts, supports five IDE adapters, wraps Beads Viewer safely, includes an enterprise harness, and has automated prompt/readiness/session tests plus CI.
 
 ## Milestones
 
@@ -15,17 +15,21 @@ The CLI is npx-ready, generates Agile + TDD rules, creates workflow artifacts, s
 | Product contract | Complete | Contract, workflow model, and command surface documented. |
 | CLI scaffold | Complete | `bin/speckit`, TypeScript build, command router, managed file writer. |
 | Workflow engine | Complete | `start`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `ready`, `run`, `review`, and `close` generate linked artifacts. |
+| Long session manager | Complete | `memory refresh` plus `session start/checkpoint/compact/resume/status` preserve agent continuity outside chat history. |
 | IDE adapters | Complete | Claude Code, Codex, Antigravity, OpenCode, Cursor. |
-| Beads integration | MVP Complete | `next` wraps BV robot mode; `sync` exports story metadata JSONL. |
+| Beads integration | MVP Complete | `next` and `graph triage/plan/insights` wrap BV robot mode; `sync` exports story metadata JSONL. |
+| Sprint automation | MVP Complete | `sprint plan` and `sprint next` select work from synced stories. |
 | Enterprise harness | MVP Complete | `init --enterprise` creates flow, tool-policy, and prompt harness files; `doctor --deep` verifies them. |
+| Curated skill catalog | Complete | Speckit now generates focused phase skills, a schema, delegation statuses, and task hydration/sync-back guidance. |
+| Workflow contract validator | Complete | `speckit validate` and `doctor --deep` check phase order, core skills, router terms, run prompt terms, and adapter parity. |
+| Permission policy | MVP Complete | `.speckit/permissions.yaml` and `permissions audit` cover privacy files, heavy paths, destructive commands, and release commands. |
 | Validation | Complete | Build and `node:test` suite pass locally with flow contract gates. |
 | GitHub publish | Complete | Initial code pushed to `trieungoctam/speckit` at commit `7e5c582`; status docs follow-up in progress. |
 | npm package readiness | Ready | Package scoped as `@trieungoctam/speckit`; `npm pack --dry-run` passes. |
 
 ## Next Roadmap
 
-- Expand Speckit Enterprise Harness with richer profile and context-pack layers.
 - Add `review --deep` with blind, edge-case, and acceptance audit prompts.
-- Add graph commands: `graph-plan`, `insights`, and `drift`.
+- Add graph drift and history correlation commands.
 - Add GitHub trusted publishing for npm releases.
 - Add snapshot tests for full adapter file contents.