@trieungoctam/speckit 0.1.0 → 0.2.0

package/README.md

@@ -2,12 +2,13 @@
 
 Speckit is a local-first Agile + TDD workflow compiler for agentic IDEs. It turns rough intent into specs, stories, TDD evidence, and native IDE instruction packs.
 
-It is inspired by the operating patterns in ClaudeKit, BMad Method, and Beads Viewer, but it does not fork their runtime. Speckit owns the workflow contract and generates adapters for the tools you already use.
+Speckit owns the workflow contract and generates adapters for the tools you already use. The public product vocabulary is Speckit-only: Agile shaping, TDD execution, task graph triage, and IDE adapter compilation.
 
 ## Quickstart
 
 ```bash
 npx @trieungoctam/speckit@latest init --ide all
+npx @trieungoctam/speckit@latest init --enterprise --ide all
 npx @trieungoctam/speckit@latest quick "Add checkout validation"
 npx @trieungoctam/speckit@latest review
 ```
@@ -24,9 +25,12 @@ speckit doctor
 
 ```text
 intent
+  -> start session
   -> shape
   -> plan
+  -> context
   -> story with acceptance criteria
+  -> sync / triage
   -> red test evidence
   -> minimal implementation
   -> green test evidence
@@ -41,15 +45,21 @@ For implementation stories, red-green-refactor evidence is mandatory. A story is
 | Command | Purpose |
 | --- | --- |
 | `speckit init` | Create `.speckit/` core rules and all IDE adapters. |
+| `speckit init --enterprise` | Add flow, tool policy, and prompt harness files. |
 | `speckit init --ide <name>` | Generate one adapter: `claude-code`, `codex`, `antigravity`, `opencode`, or `cursor`. |
 | `speckit doctor` | Report required tools, optional integrations, test commands, and adapter readiness. |
+| `speckit doctor --deep` | Verify core enterprise harness files. |
+| `speckit start "<idea>"` | Create a durable session handoff and current context. |
 | `speckit shape "<intent>"` | Create a short spec contract. |
+| `speckit context <story>` | Build the current implementation context from a story. |
 | `speckit quick "<intent>"` | Create one story plus matching TDD evidence file. |
 | `speckit plan "<intent>"` | Create PRD, architecture, story, and evidence skeletons. |
+| `speckit triage` | Summarize synced story state without interactive graph commands. |
 | `speckit next` | Safely wraps `bv --robot-next --format json`. |
 | `speckit sync` | Export Speckit stories as beads-compatible JSONL metadata. |
 | `speckit run <story>` | Print the TDD execution handoff for a story. |
 | `speckit review` | Print the review checklist and current diff summary. |
+| `speckit close <story>` | Create a closure checklist linked to the story and sync step. |
 
 ## Supported IDEs
 

package/dist/adapters/tool-checks.js

@@ -2,7 +2,6 @@ import { spawnSync } from "node:child_process";
 const tools = [
     ["git", true, "Install Git and run Speckit inside a repository."],
     ["node", true, "Install Node.js 20 or newer."],
-    ["ck", false, "Recommended for ClaudeKit-style skills and workflows."],
     ["br", false, "Recommended beads CLI. Use bd only for older projects."],
     ["bd", false, "Legacy beads CLI fallback."],
     ["bv", false, "Recommended for Beads Viewer robot commands."],

package/dist/cli.js

@@ -1,12 +1,16 @@
 import { initCommand } from "./commands/init.js";
 import { doctorCommand } from "./commands/doctor.js";
+import { startCommand } from "./commands/start.js";
 import { shapeCommand } from "./commands/shape.js";
+import { contextCommand } from "./commands/context.js";
 import { quickCommand } from "./commands/quick.js";
 import { planCommand } from "./commands/plan.js";
+import { triageCommand } from "./commands/triage.js";
 import { nextCommand } from "./commands/next.js";
 import { syncCommand } from "./commands/sync.js";
 import { runCommand } from "./commands/run.js";
 import { reviewCommand } from "./commands/review.js";
+import { closeCommand } from "./commands/close.js";
 export async function main(argv = process.argv.slice(2), root = process.cwd()) {
     const parsed = parseArgs(argv);
     try {
@@ -16,15 +20,22 @@ export async function main(argv = process.argv.slice(2), root = process.cwd()) {
                     root,
                     ide: value(parsed, "ide"),
                     force: has(parsed, "force"),
+                    enterprise: has(parsed, "enterprise"),
                 });
             case "doctor":
-                return doctorCommand({ root, json: has(parsed, "json") });
+                return doctorCommand({ root, json: has(parsed, "json"), deep: has(parsed, "deep") });
+            case "start":
+                return startCommand({ root, intent: requiredIntent(parsed) });
             case "shape":
                 return shapeCommand({ root, intent: requiredIntent(parsed) });
+            case "context":
+                return contextCommand({ root, target: requiredIntent(parsed) });
             case "quick":
                 return quickCommand({ root, intent: requiredIntent(parsed) });
             case "plan":
                 return planCommand({ root, intent: requiredIntent(parsed) });
+            case "triage":
+                return triageCommand({ root, json: has(parsed, "json") });
             case "next":
                 return nextCommand();
             case "sync":
@@ -33,6 +44,8 @@ export async function main(argv = process.argv.slice(2), root = process.cwd()) {
                 return runCommand({ root, target: requiredIntent(parsed) });
             case "review":
                 return reviewCommand({ root });
+            case "close":
+                return closeCommand({ root, target: requiredIntent(parsed) });
             case "help":
             case "":
                 printHelp();
@@ -88,14 +101,19 @@ function printHelp() {
 
 Usage:
   speckit init [--ide all|claude-code|codex|antigravity|opencode|cursor] [--force]
-  speckit doctor [--json]
+  speckit init --enterprise [--ide all] [--force]
+  speckit doctor [--json] [--deep]
+  speckit start "<idea>"
   speckit shape "<intent>"
+  speckit context <story-path-or-id>
   speckit quick "<intent>"
   speckit plan "<intent>"
+  speckit triage [--json]
   speckit next
   speckit sync
   speckit run <story-path-or-id>
   speckit review
+  speckit close <story-path-or-id>
 `);
 }
 if (import.meta.url === `file://${process.argv[1]}`) {

package/dist/commands/close.d.ts

@@ -0,0 +1,6 @@
+export type CloseOptions = {
+    root: string;
+    target: string;
+    stdout?: Pick<typeof console, "log" | "error">;
+};
+export declare function closeCommand(options: CloseOptions): Promise<number>;

package/dist/commands/close.js

@@ -0,0 +1,34 @@
+import { markdown, writeManagedFiles } from "../core/managed-files.js";
+import { slugify, timestamp } from "../core/slug.js";
+import { resolveStory } from "../core/story.js";
+export async function closeCommand(options) {
+    const stdout = options.stdout ?? console;
+    const story = await resolveStory(options.root, options.target);
+    if (!story) {
+        stdout.error(`Story not found: ${options.target}`);
+        return 1;
+    }
+    const closePath = `.speckit/closures/${timestamp()}-${slugify(story.id)}.md`;
+    await writeManagedFiles(options.root, [
+        {
+            path: closePath,
+            content: markdown(`# Spec Close: ${story.title}
+
+## Story
+\`${story.path}\`
+
+## Required Verification
+- [ ] Acceptance criteria reviewed
+- [ ] TDD evidence reviewed
+- [ ] Tests passed
+- [ ] Docs impact recorded
+- [ ] Graph sync completed with \`speckit sync\`
+
+## Review Command
+\`speckit review\`
+`),
+        },
+    ]);
+    stdout.log(closePath);
+    return 0;
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,6 @@
+export type ContextOptions = {
+    root: string;
+    target: string;
+    stdout?: Pick<typeof console, "log" | "error">;
+};
+export declare function contextCommand(options: ContextOptions): Promise<number>;

package/dist/commands/context.js

@@ -0,0 +1,53 @@
+import { markdown, writeManagedFiles } from "../core/managed-files.js";
+import { resolveStory } from "../core/story.js";
+export async function contextCommand(options) {
+    const stdout = options.stdout ?? console;
+    const story = await resolveStory(options.root, options.target);
+    if (!story) {
+        stdout.error(`Story not found: ${options.target}`);
+        return 1;
+    }
+    const contextPath = ".speckit/context/current.md";
+    await writeManagedFiles(options.root, [
+        {
+            path: contextPath,
+            content: markdown(`# Current Spec Context
+
+## Story
+${story.title}
+
+## Story Path
+\`${story.path}\`
+
+## Acceptance Criteria
+${extractSection(story.content, "Acceptance Criteria") ?? "- Not defined"}
+
+## TDD Evidence
+${extractEvidenceReference(story.content) ?? "- Create or update matching `.speckit/evidence/*tdd-evidence.md`"}
+
+## Next Command
+\`speckit run ${story.id}\`
+`),
+        },
+    ], true);
+    stdout.log(contextPath);
+    return 0;
+}
+function extractEvidenceReference(content) {
+    const match = content.match(/`([^`]*tdd-evidence\.md)`/i);
+    return match ? `\`${match[1]}\`` : undefined;
+}
+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;
+}

package/dist/commands/doctor.d.ts

@@ -1,6 +1,7 @@
 export type DoctorOptions = {
     root: string;
     json?: boolean;
+    deep?: boolean;
     stdout?: Pick<typeof console, "log">;
 };
 export declare function doctorCommand(options: DoctorOptions): Promise<number>;

package/dist/commands/doctor.js

@@ -3,10 +3,12 @@ import { join } from "node:path";
 import { getAdapters } from "../config/adapter-registry.js";
 import { checkTools } from "../adapters/tool-checks.js";
 import { detectTestCommands } from "../core/test-detection.js";
+import { coreFiles, enterpriseFiles } from "../core/scaffold.js";
 export async function doctorCommand(options) {
     const stdout = options.stdout ?? console;
     const tools = checkTools();
     const tests = await detectTestCommands(options.root);
+    const deepChecks = options.deep ? await runDeepChecks(options.root) : [];
     const adapters = await Promise.all(getAdapters("all").map(async (adapter) => ({
         name: adapter.name,
         ...(await adapterStatus(options.root, adapter.outputPaths)),
@@ -15,8 +17,9 @@ export async function doctorCommand(options) {
         node: process.versions.node,
         tools,
         tests,
+        deepChecks,
         adapters,
-        status: tools.filter((tool) => tool.required && !tool.available).length === 0 ? "ok" : "needs-attention",
+        status: statusFor(tools, deepChecks),
     };
     if (options.json) {
         stdout.log(JSON.stringify(report, null, 2));
@@ -26,12 +29,37 @@ export async function doctorCommand(options) {
         stdout.log(`Node: ${report.node}`);
         stdout.log(`Tools: ${tools.map((tool) => `${tool.name}=${tool.available ? "ok" : "missing"}`).join(", ")}`);
         stdout.log(`Tests: ${tests[0]?.command ?? "not detected"}`);
+        for (const check of deepChecks) {
+            stdout.log(`Deep ${check.name}: ${check.ok ? "ok" : "missing"}`);
+        }
         for (const adapter of adapters) {
             stdout.log(`Adapter ${adapter.name}: ${adapter.present}/${adapter.total} files present`);
         }
     }
     return report.status === "ok" ? 0 : 1;
 }
+async function runDeepChecks(root) {
+    const requiredFiles = [...coreFiles(), ...enterpriseFiles()];
+    return Promise.all(requiredFiles.map(async (file) => ({
+        name: file.path,
+        path: file.path,
+        ok: await fileExists(root, file.path),
+    })));
+}
+async function fileExists(root, path) {
+    try {
+        await access(join(root, path));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function statusFor(tools, deepChecks) {
+    const requiredToolsMissing = tools.some((tool) => tool.required && !tool.available);
+    const deepChecksMissing = deepChecks.some((check) => !check.ok);
+    return requiredToolsMissing || deepChecksMissing ? "needs-attention" : "ok";
+}
 async function adapterStatus(root, paths) {
     const missing = [];
     for (const path of paths) {

package/dist/commands/init.d.ts

@@ -2,6 +2,7 @@ export type InitOptions = {
     root: string;
     ide?: string;
     force?: boolean;
+    enterprise?: boolean;
     stdout?: Pick<typeof console, "log">;
 };
 export declare function initCommand(options: InitOptions): Promise<number>;

package/dist/commands/init.js

@@ -1,15 +1,17 @@
-import { coreFiles } from "../core/scaffold.js";
+import { coreFiles, enterpriseFiles } from "../core/scaffold.js";
 import { writeManagedFiles } from "../core/managed-files.js";
 import { getAdapters } from "../config/adapter-registry.js";
 export async function initCommand(options) {
     const stdout = options.stdout ?? console;
     const selectedIde = options.ide ?? "all";
+    const baseFiles = options.enterprise ? [...coreFiles(), ...enterpriseFiles()] : coreFiles();
     const adapterFiles = getAdapters(selectedIde).flatMap((adapter) => adapter.render());
-    const results = await writeManagedFiles(options.root, [...coreFiles(), ...adapterFiles], options.force ?? false);
+    const results = await writeManagedFiles(options.root, [...baseFiles, ...adapterFiles], options.force ?? false);
     const created = results.filter((result) => result.status === "created").length;
     const updated = results.filter((result) => result.status === "updated").length;
     const skipped = results.filter((result) => result.status === "skipped");
-    stdout.log(`Speckit initialized: ${created} created, ${updated} updated, ${skipped.length} skipped.`);
+    const mode = options.enterprise ? "enterprise" : "standard";
+    stdout.log(`Speckit initialized (${mode}): ${created} created, ${updated} updated, ${skipped.length} skipped.`);
     for (const result of skipped) {
         stdout.log(`skipped ${result.path}: ${result.reason}`);
     }

package/dist/commands/run.js

@@ -1,15 +1,14 @@
-import { access } from "node:fs/promises";
-import { join } from "node:path";
+import { resolveStory } from "../core/story.js";
 export async function runCommand(options) {
     const stdout = options.stdout ?? console;
-    const storyPath = await resolveStory(options.root, options.target);
-    if (!storyPath) {
+    const story = await resolveStory(options.root, options.target);
+    if (!story) {
         stdout.error(`Story not found: ${options.target}`);
         return 1;
     }
     stdout.log(`# Speckit TDD Run
 
-Story: ${storyPath}
+Story: ${story.path}
 
 1. Read the story and acceptance criteria.
 2. Identify the smallest executable test that should fail.
@@ -23,20 +22,3 @@ Recommended handoff:
 `);
     return 0;
 }
-async function resolveStory(root, target) {
-    const candidates = [
-        target,
-        `.speckit/stories/${target}`,
-        `.speckit/stories/${target}.md`,
-    ];
-    for (const candidate of candidates) {
-        try {
-            await access(join(root, candidate));
-            return candidate;
-        }
-        catch {
-            // Try the next candidate.
-        }
-    }
-    return undefined;
-}

package/dist/commands/start.d.ts

@@ -0,0 +1,6 @@
+export type StartOptions = {
+    root: string;
+    intent: string;
+    stdout?: Pick<typeof console, "log">;
+};
+export declare function startCommand(options: StartOptions): Promise<number>;

package/dist/commands/start.js

@@ -0,0 +1,47 @@
+import { markdown, writeManagedFiles } from "../core/managed-files.js";
+import { slugify, timestamp } from "../core/slug.js";
+export async function startCommand(options) {
+    const stdout = options.stdout ?? console;
+    const sessionId = `${timestamp()}-${slugify(options.intent)}`;
+    const handoffPath = `.speckit/sessions/${sessionId}/handoff.md`;
+    const contextPath = ".speckit/context/current.md";
+    await writeManagedFiles(options.root, [
+        {
+            path: handoffPath,
+            content: markdown(`# Spec Session: ${sessionId}
+
+## Idea
+${options.intent}
+
+## Current Phase
+shape
+
+## Linked Artifacts
+- Context: \`${contextPath}\`
+
+## Next Command
+\`speckit shape "${options.intent}"\`
+`),
+        },
+        {
+            path: contextPath,
+            content: markdown(`# Current Spec Context
+
+## Session
+${sessionId}
+
+## Idea
+${options.intent}
+
+## Active Artifact
+\`${handoffPath}\`
+
+## Next Command
+\`speckit shape "${options.intent}"\`
+`),
+        },
+    ], true);
+    stdout.log(sessionId);
+    stdout.log(handoffPath);
+    return 0;
+}

package/dist/commands/sync.js

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { markdown, writeManagedFiles } from "../core/managed-files.js";
+import { firstHeading } from "../core/story.js";
 export async function syncCommand(options) {
     const stdout = options.stdout ?? console;
     const storiesDir = join(options.root, ".speckit", "stories");
@@ -45,10 +46,3 @@ bv --robot-next --format json
     stdout.log(`Synced ${stories.length} stories to .speckit/sync/beads-sync.jsonl`);
     return 0;
 }
-function firstHeading(content) {
-    return content
-        .split("\n")
-        .find((line) => line.startsWith("# "))
-        ?.replace(/^#\s+/, "")
-        .trim();
-}

package/dist/commands/triage.d.ts

@@ -0,0 +1,6 @@
+export type TriageOptions = {
+    root: string;
+    json?: boolean;
+    stdout?: Pick<typeof console, "log" | "error">;
+};
+export declare function triageCommand(options: TriageOptions): Promise<number>;

package/dist/commands/triage.js

@@ -0,0 +1,33 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function triageCommand(options) {
+    const stdout = options.stdout ?? console;
+    const stories = await readSyncedStories(options.root);
+    const open = stories.filter((story) => story.status === "open");
+    const ready = stories.filter((story) => story.status !== "open");
+    const report = {
+        source: ".speckit/sync/beads-sync.jsonl",
+        open: open.length,
+        ready: ready.length,
+        next: open[0] ?? null,
+    };
+    if (options.json) {
+        stdout.log(JSON.stringify(report, null, 2));
+        return 0;
+    }
+    stdout.log(`Spec triage: ${open.length} open, ${ready.length} ready`);
+    stdout.log(open[0] ? `Next: ${open[0].id} (${open[0].path})` : "Next: none");
+    return 0;
+}
+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 [];
+    }
+}

package/dist/core/scaffold.d.ts

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

package/dist/core/scaffold.js

@@ -69,3 +69,49 @@ adapters:
         },
     ];
 }
+export function enterpriseFiles() {
+    return [
+        {
+            path: ".speckit/flows/spec-flow.md",
+            content: markdown(`# Spec Flow
+
+## Order
+start -> shape -> plan -> context -> sync -> triage -> run -> review -> close
+
+## Traceability
+- A session links the original idea to every downstream artifact.
+- A story links acceptance criteria to TDD evidence.
+- Sync links stories to graph-ready JSONL.
+- Close links review output back to story and graph sync.
+`),
+        },
+        {
+            path: ".speckit/tool-policy.yaml",
+            content: text(`version: 1
+phases:
+  shape:
+    may_edit_code: false
+  plan:
+    may_edit_code: false
+  run:
+    may_edit_code: true
+    requires_tdd_evidence: true
+  review:
+    may_edit_code: false
+graph:
+  robot_only: true`),
+        },
+        {
+            path: ".speckit/prompts/spec-run.md",
+            content: markdown(`# Spec Run Prompt
+
+1. Read \`.speckit/context/current.md\`.
+2. Confirm story acceptance criteria.
+3. Write or run the failing test first.
+4. Implement the smallest change.
+5. Record red, green, and refactor evidence.
+6. Run \`speckit review\` before handoff.
+`),
+        },
+    ];
+}

package/dist/core/story.d.ts

@@ -0,0 +1,8 @@
+export type StoryResolution = {
+    path: string;
+    content: string;
+    id: string;
+    title: string;
+};
+export declare function resolveStory(root: string, target: string): Promise<StoryResolution | undefined>;
+export declare function firstHeading(content: string): string | undefined;

package/dist/core/story.js

@@ -0,0 +1,33 @@
+import { access, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+export async function resolveStory(root, target) {
+    const candidates = [
+        target,
+        `.speckit/stories/${target}`,
+        `.speckit/stories/${target}.md`,
+    ];
+    for (const candidate of candidates) {
+        try {
+            const fullPath = join(root, candidate);
+            await access(fullPath);
+            const content = await readFile(fullPath, "utf8");
+            return {
+                path: candidate,
+                content,
+                id: basename(candidate).replace(/\.md$/, ""),
+                title: firstHeading(content) ?? basename(candidate).replace(/\.md$/, ""),
+            };
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return undefined;
+}
+export function firstHeading(content) {
+    return content
+        .split("\n")
+        .find((line) => line.startsWith("# "))
+        ?.replace(/^#\s+/, "")
+        .trim();
+}

package/docs/development-roadmap.md

@@ -6,7 +6,7 @@ Speckit MVP is implemented and pushed to `git@github.com:trieungoctam/speckit.gi
 
 Current package target: `@trieungoctam/speckit@0.1.0`.
 
-The CLI is npx-ready, generates Agile + TDD rules, creates workflow artifacts, supports five IDE adapters, wraps Beads Viewer safely, 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 tests plus CI.
 
 ## Milestones
 
@@ -14,17 +14,18 @@ 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 | MVP Complete | `shape`, `plan`, `quick`, `run`, and `review` generate usable artifacts. |
+| Workflow engine | Complete | `start`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `run`, `review`, and `close` generate linked artifacts. |
 | IDE adapters | Complete | Claude Code, Codex, Antigravity, OpenCode, Cursor. |
 | Beads integration | MVP Complete | `next` wraps BV robot mode; `sync` exports story metadata JSONL. |
-| Validation | Complete | Build and `node:test` suite pass locally. |
+| Enterprise harness | MVP Complete | `init --enterprise` creates flow, tool-policy, and prompt harness files; `doctor --deep` verifies them. |
+| 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
 
-- Publish `@trieungoctam/speckit` to npm.
+- 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 GitHub trusted publishing for npm releases.
-- Add richer config loading from `.speckit/config.yaml`.
-- Add optional direct `br`/`bd` import once command compatibility is pinned.
 - Add snapshot tests for full adapter file contents.

package/docs/product-contract.md

@@ -5,7 +5,7 @@ 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`, `shape`, `plan`, `quick`, `next`, `sync`, `run`, `review`.
+- The command surface: `init`, `doctor`, `start`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `next`, `run`, `review`, `close`.
 - 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.
@@ -13,15 +13,15 @@ Speckit owns the workflow contract for enterprise Agile + TDD development with a
 ## Speckit Delegates
 
 - Implementation to the selected IDE and agent runtime.
-- Product lifecycle inspiration to BMad-style phases, without copying BMad personas or branding.
-- Execution orchestration inspiration to ClaudeKit-style plan/cook/test/review flows.
+- 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.
 - Git, tests, CI, and deployment to project-local tooling.
 
 ## State Model
 
 ```text
-intake -> shaped -> planned -> sliced -> spec-ready -> tests-red -> running -> tests-green -> refactor -> review-ready -> closed
+intake -> session -> shaped -> planned -> context-ready -> synced -> triaged -> tests-red -> running -> tests-green -> refactor -> review-ready -> closed
 ```
 
 Implementation starts only after a story is spec-ready. Review starts only after test evidence exists.

package/docs/project-changelog.md

@@ -1,7 +1,36 @@
 # Project Changelog
 
+## 0.2.0 - 2026-05-10
+
+### Added
+
+- Added enterprise harness generation with `speckit init --enterprise`.
+- Added deep harness verification with `speckit doctor --deep`.
+- Added linked flow commands: `start`, `context`, `triage`, and `close`.
+- Added quality gates for Speckit-only vocabulary, flow linkage, adapter parity, and robot-safe graph commands.
+
+### Validation
+
+- `npm run lint` passes.
+- `npm test` passes with 21 tests.
+- `npm pack --dry-run` passes.
+- Full enterprise temp flow passes: `init --enterprise -> start -> quick -> context -> sync -> triage -> close -> doctor --deep`.
+
 ## 2026-05-10
 
+### Changed
+
+- Migrated product vocabulary to Speckit-only workflow language.
+- Added Spec Enterprise Harness planning and quality gates.
+- Removed legacy workflow runtime checks from `speckit doctor`.
+- Added enterprise flow commands for session start, story context, graph triage, and closure.
+
+### Quality
+
+- Added forbidden vocabulary regression test.
+- Added Spec flow contract tests for TDD linkage, adapter parity, and robot-safe graph commands.
+- Added end-to-end command tests for `start`, `context`, `triage`, and `close`.
+
 ### Added
 
 - Created Speckit TypeScript CLI package.
@@ -9,6 +38,7 @@
 - Added GitHub repository metadata for `trieungoctam/speckit`.
 - Added GitHub Actions CI for lint, test, and package dry-run checks.
 - Added `init`, `doctor`, `shape`, `quick`, `plan`, `next`, `sync`, `run`, and `review` commands.
+- Added `init --enterprise`, `doctor --deep`, `start`, `context`, `triage`, and `close` commands.
 - Added managed-file generation with overwrite protection.
 - Added native adapter generation for Claude Code, Codex, Antigravity, OpenCode, and Cursor.
 - Added Beads Viewer-safe `next` command using robot mode only.
@@ -21,7 +51,7 @@
 - `bin/speckit init --ide all` works in a temporary directory.
 - `npm run build` passes.
 - `npm run lint` passes.
-- `npm test` passes with 13 tests.
+- `npm test` passes with 21 tests.
 - `npm pack --dry-run` passes.
 
 ### Published

package/docs/release-checklist.md

@@ -12,7 +12,7 @@ Before publishing Speckit:
 - [x] Adapter output paths match `docs/adapters.md`.
 - [x] Cursor output uses `.cursor/rules/*.mdc`, not `.cursorrules`.
 - [x] `speckit next` only invokes `bv --robot-*`.
-- [ ] License and attribution review is complete for ClaudeKit, BMad Method, and Beads Viewer inspiration.
+- [ ] License and attribution review is complete for Speckit, Speckit Method, and Beads Viewer inspiration.
 - [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`.

package/docs/spec-enterprise-harness-plan.md

@@ -0,0 +1,68 @@
+# Spec Enterprise Harness Plan
+
+## Goal
+
+Speckit Enterprise must behave like one coherent Spec system, not a bundle of unrelated prompts.
+
+The product vocabulary is Spec-only. External tools may exist underneath, but generated prompts, docs, commands, sessions, context packs, and adapter outputs must speak Speckit terms.
+
+## Operating Model
+
+```text
+idea
+  -> spec start
+  -> spec shape
+  -> spec plan
+  -> spec context
+  -> graph triage
+  -> spec run
+  -> spec review
+  -> spec close
+```
+
+## Harness Layers
+
+| Layer | Responsibility | Required Output |
+| --- | --- | --- |
+| Spec Flow | Phase order and state transitions | `.speckit/flows/*.md` |
+| Spec Prompt | Phase-specific instructions | `.speckit/prompts/**/*.md` |
+| Spec Session | Durable continuity across agents | `.speckit/sessions/<id>/*` |
+| Spec Context | Bounded task context | `.speckit/context/current.md` |
+| Spec Tool | Phase-aware allowed/denied actions | `.speckit/tool-policy.yaml` |
+| Spec Graph | Work queue and priority bridge | `.speckit/graph/*` |
+| IDE Compiler | Native adapter generation | IDE-specific config files |
+
+## Command Contract
+
+```bash
+speckit init --enterprise --ide all
+speckit doctor --deep
+speckit start "<idea>"
+speckit shape "<idea>"
+speckit plan "<feature>"
+speckit context <story-or-bead>
+speckit triage
+speckit next
+speckit run <story-or-bead>
+speckit review
+speckit close <story-or-bead>
+speckit sync
+```
+
+## Quality Gates
+
+- Forbidden legacy vocabulary must not appear in publishable source, docs, tests, prompts, or generated adapter templates.
+- Every implementation story must link to acceptance criteria and TDD evidence.
+- Every run must have a session handoff.
+- Every graph task must trace back to a story or spec artifact.
+- Every review must check AC coverage, TDD evidence, tool policy, and docs impact.
+- All robot task graph commands must use non-interactive flags.
+
+## Definition Of Enterprise Ready
+
+- `speckit init --enterprise --ide all` creates a complete harness in a temp repo.
+- `speckit doctor --deep --json` returns stable machine-readable status.
+- `speckit start -> context -> run -> review -> close` preserves a single session id.
+- `speckit sync -> triage -> next` preserves story-to-graph traceability.
+- All IDE adapters compile from the same Spec policies.
+- Tests enforce vocabulary, flow links, adapter parity, and robot-safe graph commands.

package/docs/spec-quality-gates.md

@@ -0,0 +1,70 @@
+# Spec Quality Gates
+
+## Vocabulary Gate
+
+Publishable files must not contain legacy workflow brand names or command prefixes.
+
+Allowed:
+
+- `Speckit`
+- `Spec`
+- IDE names such as `Claude Code`
+- external graph tool names such as `Beads` and `Beads Viewer`
+
+Forbidden in publishable files:
+
+- old workflow brand names
+- old slash command prefixes
+- old implementation command names
+
+## Flow Link Gate
+
+Every phase must link to the next durable artifact.
+
+| Phase | Input | Output | Required Link |
+| --- | --- | --- | --- |
+| start | idea | session | session id |
+| shape | session | spec brief | session -> spec |
+| plan | spec brief | PRD / architecture / story | spec -> plan |
+| context | story | context pack | story -> context |
+| sync | story | graph task | story -> task id |
+| run | task/story | TDD evidence | task -> evidence |
+| review | diff + evidence | review checklist | evidence -> review |
+| close | review | changelog / graph close | review -> close |
+
+## Tool Gate
+
+Tool permissions are phase-specific.
+
+- Shape and plan may inspect files but should not edit implementation code.
+- Run may edit code but must record TDD evidence.
+- Review should inspect and test; it should not implement.
+- Graph commands must never launch an interactive TUI.
+
+## Adapter Parity Gate
+
+All supported IDEs must receive the same Speckit policy:
+
+- Spec policy
+- TDD policy
+- Enterprise safety policy
+- Session/context instructions
+- Graph command safety
+
+## Release Gate
+
+Before release:
+
+```bash
+npm run lint
+npm test
+npm pack --dry-run
+speckit doctor --json
+```
+
+For enterprise releases:
+
+```bash
+speckit init --enterprise --ide all
+speckit doctor --deep --json
+```

package/docs/system-architecture.md

@@ -24,4 +24,4 @@ bin/speckit
 user intent -> CLI command -> markdown/json artifact -> IDE adapter -> agent workflow
 ```
 
-The CLI does not depend on running ClaudeKit, BMad, or Beads code. External tools are optional integrations discovered at runtime.
+The CLI does not depend on external workflow runtimes. Beads and Beads Viewer are optional integrations discovered at runtime.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trieungoctam/speckit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Enterprise Agile + TDD workflow compiler for agentic IDEs.",
   "type": "module",
   "files": [