@trieungoctam/speckit 0.3.6 → 0.4.1

package/dist/core/team-report.js

@@ -0,0 +1,149 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { extractSection, resolveStory } from "./story.js";
+export async function buildTeamReport(root, target) {
+    const story = await resolveStory(root, target);
+    if (!story) {
+        return {
+            status: "blocked",
+            roles: [],
+            blockers: [`Story not found: ${target}`],
+            warnings: [],
+        };
+    }
+    const evidence = await readEvidence(root, story.evidencePath);
+    const roles = [
+        productOwner(story.content),
+        analyst(story.content),
+        architect(story.content),
+        developer(story.content),
+        await qa(story.evidencePath, evidence),
+        reviewer(evidence),
+    ];
+    const blockers = roles.flatMap((role) => role.checks.filter((check) => !check.ok).map((check) => `${role.role}: ${check.name} - ${check.detail}`));
+    return {
+        status: blockers.length ? "blocked" : "ok",
+        story: {
+            id: story.id,
+            path: story.path,
+            title: story.title,
+            status: story.status,
+            evidencePath: story.evidencePath,
+        },
+        roles,
+        blockers,
+        warnings: story.status === "ready-for-dev" ? [] : [`Story status is ${story.status ?? "missing"}`],
+    };
+}
+function productOwner(content) {
+    return role("Product Owner", [
+        check("business-goal", sectionHasDetail(content, "Business Goal") || sectionHasDetail(content, "Intent"), "Business goal or intent is filled"),
+        check("priority", sectionHasValue(content, "Business Goal", "Priority"), "Priority is recorded"),
+    ]);
+}
+function analyst(content) {
+    return role("Analyst", [
+        check("acceptance-criteria", hasActionableAcceptanceCriteria(content), "Acceptance criteria are testable"),
+        check("edge-cases", sectionHasDetail(content, "Edge Cases") || sectionHasValue(content, "Dev Notes", "Edge cases"), "Edge cases are recorded"),
+    ]);
+}
+function architect(content) {
+    return role("Architect", [
+        check("implementation-scope", sectionHasDetail(content, "Implementation Scope"), "Implementation scope is recorded"),
+        check("risk-notes", sectionHasDetail(content, "Architecture Notes") || sectionHasValue(content, "Notes", "Risks"), "Constraints or risks are recorded"),
+    ]);
+}
+function developer(content) {
+    return role("Developer", [
+        check("dev-agent-record", sectionHasDetail(content, "Dev Agent Record"), "Dev Agent Record exists"),
+        check("file-list", subsectionHasDetail(content, "File List"), "File List has at least one entry"),
+        check("change-log", sectionHasDetail(content, "Change Log"), "Change Log is updated"),
+    ]);
+}
+async function qa(evidencePath, evidence) {
+    return role("QA/Test", [
+        check("evidence-link", Boolean(evidencePath), evidencePath ?? "Missing linked evidence file"),
+        check("evidence-file", Boolean(evidence), evidencePath ?? "Missing linked evidence file"),
+        check("red-evidence", evidence ? sectionHasDetail(evidence, "Red") : false, "Red evidence is recorded"),
+        check("green-evidence", evidence ? sectionHasDetail(evidence, "Green") : false, "Green evidence is recorded"),
+        check("refactor-evidence", evidence ? sectionHasDetail(evidence, "Refactor") : false, "Refactor validation is recorded"),
+    ]);
+}
+function reviewer(evidence) {
+    const checks = [
+        check("review-evidence", evidence ? sectionHasDetail(evidence, "Review Evidence") : false, "Review outcome is recorded"),
+    ];
+    const report = role("Reviewer/Lead", checks);
+    return report.status === "blocked" ? { ...report, status: "waiting" } : report;
+}
+function role(roleName, checks) {
+    return {
+        role: roleName,
+        status: checks.every((item) => item.ok) ? "ok" : "blocked",
+        checks,
+    };
+}
+function check(name, ok, detail) {
+    return { name, ok, detail };
+}
+function hasActionableAcceptanceCriteria(content) {
+    const criteria = extractSection(content, "Acceptance Criteria");
+    if (!criteria)
+        return false;
+    return /Given .+|When .+|Then .+|AC\d+:/i.test(criteria) && !criteria.includes("...");
+}
+function sectionHasValue(content, heading, label) {
+    const section = extractSection(content, heading);
+    if (!section)
+        return false;
+    const pattern = new RegExp(`${escapeRegExp(label)}:\\s*\\S+`, "i");
+    return pattern.test(section);
+}
+function sectionHasDetail(content, heading) {
+    const section = extractSection(content, heading);
+    if (!section)
+        return false;
+    return hasDetail(section);
+}
+function subsectionHasDetail(content, heading) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => /^#{2,3}\s+/.test(line) && line.replace(/^#{2,3}\s+/, "").trim().toLowerCase() === heading.toLowerCase());
+    if (start === -1)
+        return false;
+    const collected = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{2,3}\s+/.test(line))
+            break;
+        collected.push(line);
+    }
+    return hasDetail(collected.join("\n"));
+}
+function hasDetail(section) {
+    return section
+        .split("\n")
+        .map((line) => line.replace(/^[-*\s]+/, "").trim())
+        .filter((line) => line && !line.startsWith("###"))
+        .some((line) => {
+        if (line.includes("..."))
+            return false;
+        if (/^[A-Za-z -]+:\s*$/.test(line))
+            return false;
+        if (/^(Command|Result|Reviewer|Outcome|Follow-ups):\s*$/i.test(line))
+            return false;
+        return true;
+    });
+}
+async function readEvidence(root, evidencePath) {
+    if (!evidencePath)
+        return undefined;
+    try {
+        await access(join(root, evidencePath));
+        return await readFile(join(root, evidencePath), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/core/team-scaffold.d.ts

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

package/dist/core/team-scaffold.js

@@ -0,0 +1,92 @@
+import { markdown } from "./managed-files.js";
+export function teamFiles() {
+    return [
+        {
+            path: ".speckit/team/roles.md",
+            content: markdown(`# Spec Team Roles
+
+## Purpose
+
+Speckit maps team collaboration to owned artifacts. Roles do not imply separate people; one person can hold multiple roles, but every story must show which artifact is ready and which role is blocked.
+
+## Roles
+
+| Role | Owns | Exit Signal |
+| --- | --- | --- |
+| Product Owner | business goal, priority, scope intent | story has clear business value |
+| Analyst | acceptance criteria, edge cases, assumptions | story is testable |
+| Architect | implementation scope, constraints, risks | dev can start without guessing |
+| Developer | Dev Agent Record, File List, Change Log | implementation evidence is traceable |
+| QA/Test | red, green, refactor evidence | behavior is validated |
+| Reviewer/Lead | review evidence, approval, follow-ups | story can close |
+`),
+        },
+        {
+            path: ".speckit/team/artifact-ownership.md",
+            content: markdown(`# Spec Artifact Ownership
+
+## Story Artifacts
+
+- Product Owner owns \`Business Goal\`, \`Priority\`, and high-level intent.
+- Analyst owns \`Acceptance Criteria\`, \`Edge Cases\`, and assumptions.
+- Architect owns \`Implementation Scope\`, \`Architecture Notes\`, and risks.
+- Developer owns \`Dev Agent Record\`, \`File List\`, and \`Change Log\`.
+- QA/Test owns the linked TDD evidence file.
+- Reviewer/Lead owns review outcome and closure readiness.
+
+## Rule
+
+Do not move a story to the next gate by chat memory alone. Update the durable artifact first, then run \`speckit team status <story>\` or \`speckit team audit <story>\`.
+`),
+        },
+        {
+            path: ".speckit/team/working-agreement.md",
+            content: markdown(`# Spec Working Agreement
+
+## Agreements
+
+- One story is the unit of planning, implementation, review, and closure.
+- Every implementation story must have a linked TDD evidence file.
+- Agents and humans hand off through files, not conversation history.
+- Graph commands stay robot-safe through Speckit wrappers.
+- Review blocks closure when acceptance criteria, evidence, or file traceability are missing.
+`),
+        },
+        {
+            path: ".speckit/team/review-gates.md",
+            content: markdown(`# Spec Review Gates
+
+## Gates
+
+| Gate | Required Checks |
+| --- | --- |
+| shape | business goal, priority |
+| ready | acceptance criteria, scope, context, graph sync |
+| dev | Dev Agent Record, File List, Change Log |
+| qa | red, green, refactor evidence |
+| review | review outcome, follow-ups, unresolved risk |
+| close | sync, compact summary, docs impact |
+
+Run \`speckit team audit <story>\` before review and close.
+`),
+        },
+        {
+            path: ".speckit/team/handoff-protocol.md",
+            content: markdown(`# Spec Handoff Protocol
+
+## Handoff Contract
+
+Each handoff must include:
+
+- Story path and current status.
+- From role and to role.
+- Current blockers and warnings.
+- Files changed or expected files to inspect.
+- Test evidence state.
+- Next role checklist.
+
+Use \`speckit team handoff <story> --from <role> --to <role>\` to generate a durable handoff.
+`),
+        },
+    ];
+}

package/dist/core/templates.d.ts

@@ -1,2 +1,2 @@
-export declare const storyTemplate = "---\nstatus: draft\nevidence: .speckit/evidence/{{slug}}-tdd-evidence.md\ncontext: pending\nstory_key: {{slug}}\nac_count: 0\n---\n\n# Story: {{title}}\n\n## Intent\n{{intent}}\n\n## Acceptance Criteria\n- AC1: Given ...\n  When ...\n  Then ...\n\n## Implementation Scope\n- In scope:\n- Out of scope:\n- Files likely to read:\n- Files likely to modify:\n\n## Dev Notes\n- Existing patterns to reuse:\n- Architecture constraints:\n- Edge cases:\n- Previous-story learnings:\n\n## Tasks / Subtasks\n- [ ] Map acceptance criteria to tests.\n- [ ] RED: create or identify failing test.\n- [ ] GREEN: implement minimum passing change.\n- [ ] REFACTOR: improve design while tests stay green.\n- [ ] Update evidence, file list, and change log.\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## Dev Agent Record\n### Test Intent\n\n### Debug Log\n\n### Completion Notes\n\n### File List\n\n## Change Log\n- {{date}}: Story drafted.\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- Do not mark any task complete without test or validation evidence.\n";
+export declare const storyTemplate = "---\nstatus: draft\nevidence: .speckit/evidence/{{slug}}-tdd-evidence.md\ncontext: pending\nstory_key: {{slug}}\nac_count: 0\n---\n\n# Story: {{title}}\n\n## Intent\n{{intent}}\n\n## Business Goal\n- Goal:\n- Priority: medium\n- Success signal:\n\n## Acceptance Criteria\n- AC1: Given ...\n  When ...\n  Then ...\n\n## Edge Cases\n- Boundary:\n- Error path:\n- State transition:\n\n## Implementation Scope\n- In scope:\n- Out of scope:\n- Files likely to read:\n- Files likely to modify:\n\n## Architecture Notes\n- Constraints:\n- Integration points:\n- Risks:\n\n## Dev Notes\n- Existing patterns to reuse:\n- Architecture constraints:\n- Edge cases:\n- Previous-story learnings:\n\n## Tasks / Subtasks\n- [ ] Map acceptance criteria to tests.\n- [ ] RED: create or identify failing test.\n- [ ] GREEN: implement minimum passing change.\n- [ ] REFACTOR: improve design while tests stay green.\n- [ ] Update evidence, file list, and change log.\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## Dev Agent Record\n### Test Intent\n\n### Debug Log\n\n### Completion Notes\n\n### File List\n\n## Change Log\n- {{date}}: Story drafted.\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- Do not mark any task complete without test or validation evidence.\n";
 export declare const tddEvidenceTemplate = "---\nstatus: missing\nstory: {{story}}\nphase: not-started\n---\n\n# TDD Evidence: {{story}}\n\n## Test Intent\n- Acceptance criteria covered:\n- Test files:\n- Command:\n\n## Red\n- Command:\n- Result:\n- Failing reason:\n\n## Green\n- Command:\n- Result:\n- Passing evidence:\n\n## Refactor\n- Command:\n- Result:\n- Regression evidence:\n\n## Review Evidence\n- Reviewer:\n- Outcome:\n- Follow-ups:\n";

package/dist/core/templates.js

@@ -11,17 +11,32 @@ ac_count: 0
 ## Intent
 {{intent}}
 
+## Business Goal
+- Goal:
+- Priority: medium
+- Success signal:
+
 ## Acceptance Criteria
 - AC1: Given ...
   When ...
   Then ...
 
+## Edge Cases
+- Boundary:
+- Error path:
+- State transition:
+
 ## Implementation Scope
 - In scope:
 - Out of scope:
 - Files likely to read:
 - Files likely to modify:
 
+## Architecture Notes
+- Constraints:
+- Integration points:
+- Risks:
+
 ## Dev Notes
 - Existing patterns to reuse:
 - Architecture constraints:

package/docs/adapters.md

@@ -14,6 +14,18 @@ Speckit compiles one workflow into native files for five IDEs.
 
 Generated files include the `speckit:managed` marker. Speckit updates managed files idempotently and skips unmanaged files unless `--force` is provided.
 
+## Shared Enterprise Contract
+
+All adapters point agents back to the shared Speckit runtime:
+
+- `.speckit/agents/super-agent.md`
+- `.speckit/skills/catalog.md`
+- `.speckit/team/*.md`
+- `.speckit/context/current.md`
+- `.speckit/context/subagent-handoff.md`
+
+Adapters should not redefine team workflow rules independently. Update the shared generator and re-run `speckit init --enterprise --ide <name>` when the contract changes.
+
 ## Cursor Policy
 
 Cursor uses `.cursor/rules/*.mdc`. Speckit does not generate the legacy `.cursorrules` file.

package/docs/code-standards.md

@@ -5,5 +5,7 @@
 - Prefer deterministic file generation over runtime prompts.
 - Use `writeManagedFiles` for generated files so unmanaged user files are protected.
 - Keep adapter logic declarative: `name`, `displayName`, `outputPaths`, `render`.
+- Keep enterprise evaluators artifact-based. Team status, audit, and score should inspect durable files instead of chat history.
+- Keep public docs aligned with CLI help whenever a command is added.
 - Add tests for command behavior and adapter contracts before expanding implementation scope.
 - Do not invoke interactive external tools from automation paths.

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.3.5`.
+Current package target: `@trieungoctam/speckit@0.4.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 prompt/readiness/session 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 now exposes team-role workflow status, review-gate audit, handoff files, and runtime scoring.
 
 ## Milestones
 
@@ -20,17 +20,21 @@ The CLI is npx-ready, generates Agile + TDD rules, creates workflow artifacts, s
 | Beads integration | MVP Complete | `graph setup` prints install commands and prepares `.beads/beads.jsonl`; `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. |
+| Enterprise team workflow | Complete | `init --enterprise` creates `.speckit/team/*`; `team status`, `team audit`, and `team handoff` expose role-owned artifacts and review blockers. |
+| Runtime scoring | Complete | `score` reports project or story workflow health across contract, team, session/context, graph, TDD, and review categories. |
 | 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. |
 | Prompt architecture | Complete | Generated prompts now enforce artifact contracts, hard gates, common mistake prevention, TDD evidence, and review layers across adapters. |
 | 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. |
+| npm package readiness | Ready | Package scoped as `@trieungoctam/speckit`; `npm pack --dry-run` passes for `0.4.0`. |
 
 ## Next Roadmap
 
+- Add `score --threshold <n>` for CI gating after teams agree on rollout policy.
 - Add `review --deep` with multi-layer acceptance, edge-case, and production-readiness prompts.
 - Add graph drift and history correlation commands.
+- Add lockfile and drift detection for generated Speckit contracts.
 - Add GitHub trusted publishing for npm releases.
 - Add snapshot tests for full adapter file contents.

package/docs/enterprise-rollout.md

@@ -6,9 +6,10 @@ Speckit works best as a repo-local standard, then as an organization template.
 
 1. Pilot in one service repository with `speckit init --ide all`.
 2. Require stories to include acceptance criteria and TDD evidence.
-3. Add `speckit doctor` and project tests to CI.
-4. Export stories with `speckit sync` for task graph visibility.
-5. Roll the generated adapter pack into team templates.
+3. Require `speckit team status <story>` before implementation handoff.
+4. Add `speckit doctor`, `speckit validate`, `speckit score --json`, and project tests to CI.
+5. Export stories with `speckit sync` for task graph visibility.
+6. Roll the generated adapter pack into team templates.
 
 ## Governance Layers
 
@@ -16,12 +17,16 @@ Speckit works best as a repo-local standard, then as an organization template.
 | --- | --- | --- |
 | Company policy | Engineering leadership | `.speckit/rules/enterprise-safety.md` |
 | Team workflow | Tech lead | `.speckit/workflows/*.md` |
+| Team roles | Product / engineering lead | `.speckit/team/*.md` |
 | Repo standard | Maintainers | `AGENTS.md`, `CLAUDE.md`, IDE config |
 | Story evidence | Implementer | `.speckit/evidence/*.md` |
+| Review readiness | Reviewer / lead | `speckit team audit <story>` |
 
 ## Recommended Controls
 
 - Do not allow code stories to merge without red-green-refactor evidence.
 - Keep adapter output generated from Speckit instead of hand-maintaining per-IDE rules.
 - Treat `speckit doctor` warnings as rollout debt.
+- Treat `speckit score` as the adoption health metric. Start non-blocking, then define a threshold after the pilot.
+- Use `speckit team handoff` whenever work moves from development to QA or review.
 - Use Beads Viewer only through robot commands for non-interactive automation.

package/docs/getting-started.md

@@ -0,0 +1,131 @@
+# Getting Started
+
+This guide is the shortest path to reset a repository, install Speckit, and run one enterprise Agile + TDD story.
+
+## 1. Install Or Reinstall Runtime Files
+
+Interactive setup:
+
+```bash
+npx @trieungoctam/speckit@latest setup
+```
+
+Recommended answers for enterprise use:
+
+```text
+Setup mode: Enterprise Agile + TDD harness
+IDE adapter: All supported IDEs
+Overwrite unmanaged files if needed: yes
+Run Beads Viewer setup after init: yes
+```
+
+Scripted setup:
+
+```bash
+npx @trieungoctam/speckit@latest init --enterprise --ide all --force
+npx @trieungoctam/speckit@latest graph setup
+```
+
+Use one adapter when a repo standardizes on one IDE:
+
+```bash
+npx @trieungoctam/speckit@latest init --enterprise --ide cursor --force
+```
+
+Supported adapter names:
+
+- `claude-code`
+- `codex`
+- `antigravity`
+- `opencode`
+- `cursor`
+- `all`
+
+## 2. Verify The Install
+
+```bash
+speckit doctor --deep
+speckit validate
+speckit score
+```
+
+Expected behavior:
+
+- `doctor --deep` checks generated files and external tools.
+- `validate` checks prompt, skill, adapter, and workflow contract alignment.
+- `score` may be below 100 before a session, context, and graph sync exist. That is normal.
+
+## 3. Start Work
+
+```bash
+speckit memory refresh
+speckit session start "Add customer export"
+speckit quick "Add customer export"
+```
+
+`quick` prints two paths:
+
+- `.speckit/stories/<story>.md`
+- `.speckit/evidence/<story>-tdd-evidence.md`
+
+Use the printed story path in the next commands.
+
+## 4. Prepare Context And Graph
+
+```bash
+speckit context .speckit/stories/<story>.md
+speckit sync
+speckit ready .speckit/stories/<story>.md
+```
+
+If `ready` is blocked, fix the reported story, context, evidence, or graph issue before implementation.
+
+## 5. Implement With TDD
+
+```bash
+speckit run .speckit/stories/<story>.md
+```
+
+Then follow the red-green-refactor loop:
+
+```bash
+npm test
+speckit session checkpoint --note "red evidence captured"
+npm test
+speckit session checkpoint --note "green evidence captured"
+speckit session checkpoint --note "refactor validated"
+```
+
+Update the story and evidence file with command summaries, changed files, and completion notes.
+
+## 6. Team Review Flow
+
+```bash
+speckit team status .speckit/stories/<story>.md
+speckit team handoff .speckit/stories/<story>.md --from dev --to qa
+speckit team audit .speckit/stories/<story>.md
+speckit score .speckit/stories/<story>.md
+```
+
+Use `team status` to see which role-owned artifact is missing. Use `team audit` before review or close.
+
+## 7. Review And Close
+
+```bash
+speckit review
+speckit session compact
+speckit close .speckit/stories/<story>.md
+speckit sync
+speckit validate
+```
+
+## Resetting Adapters
+
+To remove generated IDE adapter files before reinstalling Speckit in a repository:
+
+```bash
+rm -rf .claude CLAUDE.md .codex AGENTS.md .cursor .opencode opencode.json
+npx @trieungoctam/speckit@latest setup
+```
+
+This removes repo-local adapter files only. Do not remove global IDE configuration unless you intentionally want to affect every project on the machine.

package/docs/product-contract.md

@@ -5,11 +5,13 @@ 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`, `validate`, `start`, `memory`, `permissions`, `session`, `shape`, `plan`, `context`, `quick`, `sync`, `triage`, `sprint`, `graph`, `next`, `ready`, `run`, `review`, `close`.
+- The command surface: `init`, `doctor`, `validate`, `start`, `memory`, `permissions`, `session`, `team`, `score`, `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 workflow validation contract: phase order, core skills, super-agent routing, run prompt terms, and installed adapter prompt parity.
+- The enterprise team contract: Product Owner, Analyst, Architect, Developer, QA/Test, and Reviewer/Lead artifact ownership.
+- The runtime score contract: project and story health across workflow, team, session/context, graph, TDD, and review categories.
 - 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.
@@ -26,7 +28,24 @@ Speckit owns the workflow contract for enterprise Agile + TDD development with a
 ## State Model
 
 ```text
-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
+intake -> session -> memory-ready -> shaped -> planned -> sprint-ready -> context-ready -> synced -> graph-triaged -> team-status -> ready-for-dev -> tests-red -> checkpointed -> running -> tests-green -> refactor -> team-audit -> compacted -> review-ready -> closed
 ```
 
 Implementation starts only after `speckit ready <story>` passes. Review starts only after test evidence exists and the active session has a current checkpoint.
+
+## Team Artifact Model
+
+| Role | Owned Artifact |
+| --- | --- |
+| Product Owner | `Business Goal`, priority, success signal |
+| Analyst | `Acceptance Criteria`, `Edge Cases` |
+| Architect | `Implementation Scope`, `Architecture Notes` |
+| Developer | `Dev Agent Record`, `File List`, `Change Log` |
+| QA/Test | linked TDD evidence red, green, refactor sections |
+| Reviewer/Lead | `Review Evidence`, follow-ups, close readiness |
+
+`speckit team status` reports current ownership gaps. `speckit team audit` enforces the review gate. `speckit team handoff` records role transfer.
+
+## Runtime Score Model
+
+`speckit score` is a health signal, not a replacement for tests. It shows whether the project or story has enough durable workflow evidence to be understandable, reviewable, and handoff-ready.

package/docs/project-changelog.md

@@ -1,5 +1,33 @@
 # Project Changelog
 
+## 0.4.1 - 2026-05-11
+
+### Changed
+
+- Added `docs/getting-started.md` with setup, adapter reset, verification, one-story execution, team audit, score, and close steps.
+- Updated README, use-case, team workflow, and release checklist guidance for reinstalling repo-local adapters through Speckit.
+- Updated prompt quality tests so adapter prompt coverage is validated from generators instead of requiring checked-out adapter files after local reset.
+
+## 0.4.0 - 2026-05-11
+
+### Added
+
+- Added the Enterprise Team Workflow layer with generated team role, artifact ownership, working agreement, review gate, and handoff protocol files.
+- Added `speckit team status <story>` to show role-by-role artifact readiness for Product Owner, Analyst, Architect, Developer, QA/Test, and Reviewer/Lead.
+- Added `speckit team audit <story> [--json]` for review-gate blocking checks that can run in CI.
+- Added `speckit team handoff <story> --from <role> --to <role>` to create durable role handoff files.
+- Added `speckit score [story] [--json]` to score project or story workflow health for enterprise demos and CI health reporting.
+
+### Changed
+
+- Story templates and generated quick/plan stories now include business goal, priority, edge cases, implementation scope, architecture notes, Dev Agent Record, File List, and Change Log sections for team traceability.
+- `.beads/` is ignored as runtime graph mirror state.
+- README and use-case guides now include adapter reset, reinstall, verification, story execution, score, team audit, and close steps.
+
+### Quality
+
+- Added enterprise team workflow tests for generated files, status, audit, and handoff behavior.
+
 ## 0.3.6 - 2026-05-11
 
 ### Added

package/docs/release-checklist.md

@@ -6,12 +6,17 @@ Before publishing Speckit:
 - [x] `npm run lint` passes.
 - [x] `npm test` passes.
 - [x] `bin/speckit init --ide all` works in a temporary directory.
+- [x] `speckit init --enterprise --ide all` creates `.speckit/team/*`.
+- [x] `speckit team status|audit|handoff` has test coverage.
+- [x] `speckit score [story] --json` has test coverage.
 - [x] `npm pack --dry-run` includes only package-safe files.
 - [x] `package.json` name is `@trieungoctam/speckit` and `publishConfig.access` is `public`.
 - [x] README uses `npx @trieungoctam/speckit@latest`.
+- [x] Getting started guide covers setup, adapter reset, verification, one story, team audit, score, and close.
 - [x] Adapter output paths match `docs/adapters.md`.
 - [x] Cursor output uses `.cursor/rules/*.mdc`, not `.cursorrules`.
 - [x] `speckit next` only invokes `bv --robot-*`.
+- [x] `.beads/` runtime mirror files are ignored by git.
 - [ ] 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.

package/docs/spec-quality-gates.md

@@ -29,6 +29,8 @@ Every phase must link to the next durable artifact.
 | context | story | context pack | story -> context |
 | sync | story | graph task | story -> task id |
 | run | task/story | TDD evidence | task -> evidence |
+| team status | story + evidence | role readiness | role -> artifact |
+| team audit | story + evidence | gate report | blocker -> owner |
 | review | diff + evidence | review checklist | evidence -> review |
 | close | review | changelog / graph close | review -> close |
 
@@ -51,6 +53,30 @@ All supported IDEs must receive the same Speckit policy:
 - Session/context instructions
 - Graph command safety
 
+## Team Gate
+
+Enterprise stories must expose role-owned artifacts:
+
+- Product Owner: business goal, priority, success signal.
+- Analyst: testable acceptance criteria and edge cases.
+- Architect: implementation scope, constraints, and risks.
+- Developer: Dev Agent Record, File List, and Change Log.
+- QA/Test: red, green, and refactor evidence.
+- Reviewer/Lead: review outcome and follow-ups.
+
+Run:
+
+```bash
+speckit team status <story>
+speckit team audit <story> --json
+```
+
+## Score Gate
+
+`speckit score` gives a project-level health signal across workflow contract, team operating model, context/session, and graph sync. `speckit score <story>` gives a story-level signal across team readiness, developer trace, TDD evidence, and review gate.
+
+Use score as a rollout metric first. Only turn it into a hard CI threshold after the team agrees on acceptable minimums.
+
 ## Release Gate
 
 Before release:
@@ -67,4 +93,5 @@ For enterprise releases:
 ```bash
 speckit init --enterprise --ide all
 speckit doctor --deep --json
+speckit score --json
 ```