@trieungoctam/speckit 0.2.0 → 0.3.0

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/story.d.ts

@@ -3,6 +3,11 @@ export type StoryResolution = {
     content: string;
     id: string;
     title: string;
+    status?: string;
+    evidencePath?: string;
 };
 export declare function resolveStory(root: string, target: string): Promise<StoryResolution | undefined>;
+export declare function frontmatterValue(content: string, key: string): string | undefined;
+export declare function extractEvidenceReference(content: string): string | undefined;
+export declare function extractSection(content: string, heading: string): string | undefined;
 export declare function firstHeading(content: string): string | undefined;

package/dist/core/story.js

@@ -16,6 +16,8 @@ export async function resolveStory(root, target) {
                 content,
                 id: basename(candidate).replace(/\.md$/, ""),
                 title: firstHeading(content) ?? basename(candidate).replace(/\.md$/, ""),
+                status: frontmatterValue(content, "status"),
+                evidencePath: frontmatterValue(content, "evidence") ?? extractEvidenceReference(content),
             };
         }
         catch {
@@ -24,6 +26,38 @@ export async function resolveStory(root, target) {
     }
     return undefined;
 }
+export function frontmatterValue(content, key) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => line.trim() === "---");
+    if (start === -1)
+        return undefined;
+    const end = lines.findIndex((line, index) => index > start && line.trim() === "---");
+    if (end === -1)
+        return undefined;
+    const prefix = `${key}:`;
+    const found = lines
+        .slice(start + 1, end)
+        .find((line) => line.trim().toLowerCase().startsWith(prefix.toLowerCase()));
+    return found?.slice(found.indexOf(":") + 1).trim().replace(/^["']|["']$/g, "");
+}
+export function extractEvidenceReference(content) {
+    const match = content.match(/`([^`]*tdd-evidence\.md)`/i);
+    return match?.[1];
+}
+export function extractSection(content, heading) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading}`.toLowerCase());
+    if (start === -1)
+        return undefined;
+    const collected = [];
+    for (const line of lines.slice(start + 1)) {
+        if (line.startsWith("## "))
+            break;
+        if (line.trim())
+            collected.push(line);
+    }
+    return collected.length > 0 ? collected.join("\n") : undefined;
+}
 export function firstHeading(content) {
     return content
         .split("\n")

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/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.1.0`.
+Current package target: `@trieungoctam/speckit@0.3.0`.
 
-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 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
 
@@ -14,18 +14,20 @@ 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`, `run`, `review`, and `close` generate linked artifacts. |
+| 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. |
 | 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
 
-- Release Speckit-only vocabulary cleanup as `0.1.1` or fold it into `0.2.0`.
-- Expand Speckit Enterprise Harness with richer profile and context-pack layers.
-- Add graph commands: `graph-plan`, `insights`, and `drift`.
+- Add `review --deep` with blind, edge-case, and acceptance audit prompts.
+- Add graph drift and history correlation commands.
 - Add GitHub trusted publishing for npm releases.
 - Add snapshot tests for full adapter file contents.

package/docs/product-contract.md

@@ -5,7 +5,10 @@ Speckit owns the workflow contract for enterprise Agile + TDD development with a
 ## Speckit Owns
 
 - The `.speckit/` source of truth: config, rules, workflows, templates, generated artifacts.
-- The command surface: `init`, `doctor`, `start`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `next`, `run`, `review`, `close`.
+- The command surface: `init`, `doctor`, `start`, `memory`, `session`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `sprint`, `graph`, `next`, `ready`, `run`, `review`, `close`.
+- The skill catalog and super-agent routing contract for phase-specific agent behavior.
+- IDE-specific initialization that installs the shared Speckit runtime plus only the selected IDE adapter when `--ide <name>` is provided.
+- The long-session contract: project memory, active session state, checkpoints, compaction summaries, and resume handoffs.
 - The TDD gate: code stories require red, green, and refactor evidence.
 - The adapter compiler for Claude Code, Codex, Antigravity, OpenCode, and Cursor.
 - The safety policy for destructive commands, secrets, production access, and review readiness.
@@ -15,13 +18,13 @@ Speckit owns the workflow contract for enterprise Agile + TDD development with a
 - Implementation to the selected IDE and agent runtime.
 - Product lifecycle, story readiness, and quality gates to Speckit-native phases.
 - Execution orchestration to Speckit-native plan/run/test/review flows.
-- Task graph prioritization to beads and Beads Viewer robot commands.
+- Task graph prioritization to beads and Beads Viewer robot commands, with local JSON fallback when `bv` is unavailable.
 - Git, tests, CI, and deployment to project-local tooling.
 
 ## State Model
 
 ```text
-intake -> session -> shaped -> planned -> context-ready -> synced -> triaged -> tests-red -> running -> tests-green -> refactor -> review-ready -> closed
+intake -> session -> memory-ready -> shaped -> planned -> sprint-ready -> context-ready -> synced -> graph-triaged -> ready-for-dev -> tests-red -> checkpointed -> running -> tests-green -> refactor -> compacted -> review-ready -> closed
 ```
 
-Implementation starts only after a story is spec-ready. Review starts only after test evidence exists.
+Implementation starts only after `speckit ready <story>` passes. Review starts only after test evidence exists and the active session has a current checkpoint.

package/docs/project-changelog.md

@@ -1,5 +1,67 @@
 # Project Changelog
 
+## 0.3.0 - 2026-05-10
+
+### Added
+
+- Added `speckit memory refresh` for durable project context, decisions, and lessons.
+- Added `speckit session start`, `checkpoint`, `compact`, `resume`, and `status`.
+- Added `speckit sprint plan` and `speckit sprint next` from synced stories.
+- Added `speckit graph triage`, `graph plan`, and `graph insights` with Beads Viewer robot mode and local JSON fallback.
+- Added `.speckit/agents/super-agent.md` as the portable orchestration router.
+- Added `.speckit/skills/catalog.md` plus a curated Speckit skill set for shape, research, plan, context, graph, session, TDD, test, debug, review, docs, and ship phases.
+- Added `.speckit/skills/schema.json` to define the portable skill contract and delegation statuses.
+- Added long-session prompt requirements for project memory, active session state, checkpoints, and compaction summaries.
+- Added automatic `.beads/beads.jsonl` mirror generation so Beads Viewer robot commands can run without missing-project errors.
+- Standard `speckit init --ide <name>` now installs the shared Speckit runtime, super-agent, and skill catalog for the selected IDE.
+
+### Changed
+
+- Enterprise flow now includes memory, sprint planning, graph triage, readiness, checkpoint, and compaction phases.
+- Enterprise adapters now route through the Speckit super agent and smallest matching skill before execution.
+- Super-agent routing now includes delegation status, task hydration, and sync-back contracts adapted from long-session orchestration patterns.
+- IDE adapters now instruct agents to checkpoint red-green-refactor boundaries and compact before handoff.
+- `speckit graph triage|plan|insights` now prepares the Beads Viewer mirror before invoking `bv --robot-*` from the project root.
+- Selected-IDE init now avoids unrelated IDE adapters while still installing shared runtime files.
+
+### Quality
+
+- Added workflow tests for memory/session state, sprint planning, and graph fallback.
+- Expanded prompt quality tests for project memory, active session, checkpoint, and compaction.
+- Added init and flow contract coverage for the curated skill catalog.
+
+## 0.2.2 - 2026-05-10
+
+### Added
+
+- Added `speckit ready <story>` readiness gate.
+- Added status frontmatter to generated stories, evidence files, and current context.
+- Added `.speckit/context/subagent-handoff.md` generation from story context.
+- Added anti-mistake checklist sections to story and context artifacts.
+
+### Changed
+
+- `speckit run <story>` now refuses blocked stories until readiness checks pass.
+- Prompt contracts now require readiness status, fresh context, and subagent handoff.
+
+### Quality
+
+- Added readiness and blocked-run tests.
+- Expanded prompt quality tests for readiness and subagent handoff.
+- `npm test` passes with 26 tests.
+
+## 0.2.1 - 2026-05-10
+
+### Changed
+
+- Strengthened generated prompts across Claude Code, Codex, Antigravity, OpenCode, Cursor, and the enterprise run prompt.
+- Made prompt contracts explicitly require current context, acceptance criteria, session handoff, red-green-refactor evidence, and robot-safe graph commands.
+
+### Quality
+
+- Added prompt quality tests covering enterprise prompts, IDE adapter prompts, and tracked generated prompt files.
+- `npm test` passes with 24 tests.
+
 ## 0.2.0 - 2026-05-10
 
 ### Added
@@ -16,6 +78,10 @@
 - `npm pack --dry-run` passes.
 - Full enterprise temp flow passes: `init --enterprise -> start -> quick -> context -> sync -> triage -> close -> doctor --deep`.
 
+### Published
+
+- Published `@trieungoctam/speckit@0.2.0` to npm with `latest` dist-tag.
+
 ## 2026-05-10
 
 ### Changed

package/docs/release-checklist.md

@@ -16,5 +16,5 @@ Before publishing Speckit:
 - [x] README quickstart is accurate.
 - [x] No secrets, local credentials, or generated private data are included.
 - [x] Initial code pushed to `git@github.com:trieungoctam/speckit.git`.
-- [ ] npm package published.
+- [x] npm package published.
 - [ ] GitHub trusted publishing configured for npm releases.