rcf-lite 0.0.1 → 0.7.1

package/rcf/fbs/fbs-014.json

@@ -0,0 +1,49 @@
+{
+  "createdAt": "2026-07-20T17:05:46.941Z",
+  "updatedAt": "2026-07-20T17:05:46.941Z",
+  "summary": "Harden the build-cycle guidance so every build lands a documented local preview as its default outcome, every verification claim names the runtime it was checked against, and the method carries interim fresh-context self-review guidance. Edits the build-cycle playbook, the build-cycle contract and the harness fragment; no runtime subsystem.",
+  "approach": "In the build-cycle guidance, make a working, documented local preview loop (dev server, seeded data where needed, ideally one command) a required, hosting-independent part of a build's definition of done. Require every 'verified'/'tested' claim - in the Test and Finalise stages and in the PR body's verification section - to name the runtime it was checked against, forbid any claim implying deploy-runtime verification that did not happen, and add an explicit labelled-claim example. Add an interim self-review section describing a periodic and end-of-build fresh-context reviewer dispatch that drives the app against its ACs, targeting session-class bugs, false-promise UI, runtime mismatch, dead auth paths and dead code, scoped honestly as a stopgap until rcf-verify-lite and explicitly not the independent gate. Add matching harness-fragment rules and extend the guidance drift tests.",
+  "deliverables": [
+    "Build-cycle guidance: local preview loop as default, hosting-independent definition-of-done item",
+    "Build-cycle and PR-authoring guidance: runtime-provenance labelling with a worked example",
+    "Build-cycle guidance: interim self-review section, honestly scoped away from the independent gate",
+    "Harness fragment rules and guidance drift tests for the new invariants"
+  ],
+  "estimatedSize": "large",
+  "estimatedHours": 12,
+  "riskLevel": "medium",
+  "domain": "guidance",
+  "notes": "Implements US-801, US-804 and US-805. Targets the build/verification surface; pairs with FBS-013 on the elicitation surface. Self-review is guidance/docs only, not a new subsystem (ADR-009).",
+  "contextRequirements": {
+    "tacIds": [
+      "TAC-008",
+      "TAC-005"
+    ],
+    "adrIds": [
+      "ADR-006",
+      "ADR-008",
+      "ADR-009"
+    ]
+  },
+  "acIds": [
+    "AC-801-1",
+    "AC-801-2",
+    "AC-801-3",
+    "AC-801-4",
+    "AC-804-1",
+    "AC-804-2",
+    "AC-804-3",
+    "AC-804-4",
+    "AC-805-1",
+    "AC-805-2",
+    "AC-805-3",
+    "AC-805-4"
+  ],
+  "fbsId": "FBS-014",
+  "prdId": "PRD-001",
+  "bsId": "BS-001",
+  "buildOrder": 14,
+  "executionStatus": "notStarted",
+  "title": "Local-preview default, runtime-honest verification, interim self-review",
+  "dependsOnFbsIds": []
+}

package/rcf/fbs/fbs-015.json

@@ -0,0 +1,32 @@
+{
+  "fbsId": "FBS-015",
+  "prdId": "PRD-001",
+  "bsId": "BS-001",
+  "buildOrder": 15,
+  "executionStatus": "complete",
+  "title": "`rcf verify` subcommand routing (0.7.1 consolidation)",
+  "summary": "Route the adversarial ship-gate verifier under the unified `rcf` CLI as `rcf verify <run|report|provision|cleanup|mcp>`. The pre-existing `rcf-verify` bin becomes a transition-grace alias that dispatches through the same handlers and emits a one-line stderr deprecation notice when invoked directly.",
+  "approach": "One dispatcher, two entry points. bin/rcf.js imports the `main` export from bin/rcf-verify.js and registers it as the `verify` entry on the top-level SUBCOMMANDS map, so `rcf verify --help` and `rcf-verify --help` share the same code path by construction. The alias bin gains a deprecation notice guarded by RCF_QUIET for scripted callers. The unified CLI's help output lists `verify <verb>` alongside the other top-level commands, sourced from the same verify TOP_LEVEL_HELP the alias bin uses (single-source rule).",
+  "deliverables": [
+    "bin/rcf.js: `verify` on the top-level SUBCOMMANDS map, dispatching to the alias bin's exported main",
+    "bin/rcf-verify.js: one-line stderr deprecation notice on direct invocation, suppressible via RCF_QUIET",
+    "src/cli/help.js: `verify <verb>` listed in the top-level command table; `help verify` prints the alias bin's TOP_LEVEL_HELP block"
+  ],
+  "estimatedSize": "small",
+  "estimatedHours": 1,
+  "riskLevel": "low",
+  "domain": "cli",
+  "notes": "Ratified in the 2026-08-06 packaging-consolidation proposal (R3). Pure repackage relative to 0.7.0 verify behaviour; the invocation form gains a canonical route, existing scripts keep working via the alias.",
+  "contextRequirements": {
+    "tacIds": [],
+    "adrIds": []
+  },
+  "acIds": [
+    "AC-901-1",
+    "AC-901-2",
+    "AC-901-3"
+  ],
+  "dependsOnFbsIds": [],
+  "createdAt": "2026-08-11T00:00:00Z",
+  "updatedAt": "2026-08-11T00:00:00Z"
+}

package/rcf/manifest.json

@@ -0,0 +1,17 @@
+{
+  "version": "2.0.0",
+  "projectName": "RCF Build Lite",
+  "description": "RCF tree for the RCF Build Lite product. Manifest declares the three root documents; every other document is discovered by walking from the roots.",
+  "prd": {
+    "id": "PRD-001",
+    "path": "prd.json"
+  },
+  "tad": {
+    "id": "TAD-001",
+    "path": "tad.json"
+  },
+  "bs": {
+    "id": "BS-001",
+    "path": "build-sequence.json"
+  }
+}

package/rcf/prd.json

@@ -0,0 +1,47 @@
+{
+  "prdId": "PRD-001",
+  "productName": "RCF Build Lite",
+  "version": "0.1.0",
+  "status": "draft",
+  "executiveSummary": "RCF Build Lite is the tooling product of the RCF suite. It runs the full Requirements Confidence Framework over a project whose RCF documents live in the source repository, alongside the code. It gives a non-engineering product owner deterministic create, read, update and delete operations on every RCF document type, a visual review surface, traceability and query, a build loop that turns build specifications into implementation prompts, and a local MCP surface that exposes all of this to AI tooling.",
+  "problemStatement": "Power vibe-coders build real applications without engineering teams. They cannot read code, so they cannot judge whether what an AI tool produces is trustworthy. The full RCF chain makes output trustworthy without reading code, but authoring that chain by hand is the very effort these users lack the time and discipline for. There is no tool that runs the full RCF method over in-repository documents and surfaces it through structured, deterministic operations.",
+  "targetUsers": [
+    "Power vibe-coders: product owners, founders and business voices building applications without engineering teams",
+    "AI coding tools that need a structured, deterministic surface over a project's RCF documents",
+    "Maintainers dogfooding RCF on the Build Lite repository itself"
+  ],
+  "inScope": [
+    "On-disk RCF project structure under a project rcf folder",
+    "Visual review surface rendering the whole RCF tree as a diagram and a browsable page",
+    "Deterministic create, read, update and delete on every RCF document type",
+    "Traceability and query: coverage, trace forward, trace back, impact analysis",
+    "SDD build loop: assemble an implementation prompt from a build specification and mark it done on merge",
+    "Local stdio MCP surface exposing query, CRUD, view and build to AI tooling",
+    "Validation of every document against the published schema package at every boundary",
+    "Deploy-aware, runtime-honest build guidance: a documented local preview as the default build outcome, an early deploy-target question that constrains the stack, and runtime-provenance labels on verification claims"
+  ],
+  "outOfScope": [
+    "The schema package itself, which is the separately published rcf-schemas contract",
+    "A hosted service: MCP is local stdio and the CLI is a local binary",
+    "A web application with a server, authentication or a database",
+    "Language-agnostic tooling: Build Lite is Node 24 ESM",
+    "The one-off v1 to v2 migration script, which is not a product feature",
+    "Generation of executable test code: verification artefacts accrue per implementation phase"
+  ],
+  "objectives": [
+    "Make the full RCF chain usable with minimal user effort while keeping the method full-strength",
+    "Guarantee the in-repository differentiator by operating directly on local files as the source of truth",
+    "Keep every RCF document valid against the published schemas at all times",
+    "Surface the whole tree visually so a non-coder can review what is being built in their name",
+    "Stay harness-agnostic so the tooling survives a change of AI harness"
+  ],
+  "constraints": [
+    "Node 24 ESM, plain JavaScript, no TypeScript pin",
+    "Apache 2.0 license",
+    "Depends on the published rcf-schemas package as an external contract",
+    "Local filesystem is the source of truth; no network source of truth",
+    "MCP transport is local stdio only"
+  ],
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-07-20T17:56:57.237Z"
+}

package/rcf/requirements/req-001.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-001",
+  "prdId": "PRD-001",
+  "title": "On-disk RCF project structure",
+  "description": "Build Lite initialises and maintains a project's RCF documents on the local filesystem, under a top-level rcf folder, with the project manifest declaring the three root documents (PRD, TAD, Build Sequence) and every other document discovered by walking from the roots. The local files are the single source of truth; no external store mirrors them.",
+  "category": "functional",
+  "domain": "projectStructure",
+  "priority": "must",
+  "rationale": "The in-repository differentiator depends on RCF documents living beside the code. A predictable on-disk layout is the foundation every other capability reads from and writes to.",
+  "tags": [
+    "structure",
+    "manifest",
+    "filesystem"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-002.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-002",
+  "prdId": "PRD-001",
+  "title": "Visual review surface",
+  "description": "Build Lite renders the whole RCF tree as a diagram and as a browsable static page, so a non-coding owner can see the documents and their links without reading any JSON. The view is read-only and generated from the on-disk tree on demand.",
+  "category": "functional",
+  "domain": "view",
+  "priority": "must",
+  "rationale": "The owner cannot review code and will not read raw JSON. A visual surface is the only way they can see and steer what is being built in their name. It is delivered first (Phase 3) so every later phase has a review surface.",
+  "tags": [
+    "view",
+    "diagram",
+    "review"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-003.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-003",
+  "prdId": "PRD-001",
+  "title": "Deterministic create, read, update and delete over RCF documents",
+  "description": "Build Lite provides deterministic create, read, update and delete operations for every RCF document type, operating directly on the local files. Operations are structural and predictable so an AI agent cannot fudge document shape: each operation validates before it writes and reports a clear error on failure.",
+  "category": "functional",
+  "domain": "crud",
+  "priority": "must",
+  "rationale": "Deterministic CRUD is the foundational primitive everything else sits on. Hand-writing the tree in this phase surfaces exactly which operations the owner and the agent need.",
+  "tags": [
+    "crud",
+    "cli",
+    "validation"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-004.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-004",
+  "prdId": "PRD-001",
+  "title": "Traceability and query over the RCF chain",
+  "description": "Build Lite answers traceability questions over the RCF chain: coverage (which requirements lack stories, which acceptance criteria lack tests), trace forward (from a PRD or requirement down to acceptance criteria and tests), trace back (from a test or acceptance criterion up to its requirement and PRD), and impact analysis (what is affected if a given document changes). Queries walk the chain from the on-disk tree.",
+  "category": "functional",
+  "domain": "traceability",
+  "priority": "must",
+  "rationale": "Traceability is the confidence the framework is named for. The owner needs to know that nothing is unspecified and nothing is untested, and what an edit ripples into, without reading the documents end to end.",
+  "tags": [
+    "traceability",
+    "query",
+    "coverage"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-005.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-005",
+  "prdId": "PRD-001",
+  "title": "Specification-driven build loop",
+  "description": "Build Lite turns a Functional Build Specification into a single implementation prompt by walking the FBS, its acceptance criteria (to the parent user stories), and its declared architectural context (referenced TACs and ADRs), then assembles a markdown prompt for a coding agent. It marks a build slice done when the slice is finished.",
+  "category": "functional",
+  "domain": "build",
+  "priority": "must",
+  "rationale": "For someone who cannot read code, the specification-to-build loop is the only thing between them and a confident but wrong result. Assembling the prompt from the tree is what makes the output solid and traceable to an agreed decision.",
+  "tags": [
+    "build",
+    "sdd",
+    "fbs"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-006.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-006",
+  "prdId": "PRD-001",
+  "title": "Local MCP surface over the full feature set",
+  "description": "Build Lite exposes its query, CRUD, view and build operations through a local stdio MCP server, so an AI harness can drive the whole feature set as structured tools. The MCP server is a thin adapter over the same operations the CLI uses; it carries no behaviour the core does not already own.",
+  "category": "functional",
+  "domain": "mcp",
+  "priority": "should",
+  "rationale": "The harness is where the owner's AI tooling lives. A local stdio MCP surface gives that tooling the full RCF feature set while preserving filesystem access and the source-of-truth rule. Remote MCP is excluded because it cannot see the user's codebase.",
+  "tags": [
+    "mcp",
+    "harness",
+    "stdio"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-007.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-007",
+  "prdId": "PRD-001",
+  "title": "Validation at every boundary",
+  "description": "Every RCF document is validated against the published schema package on load and before persist. No operation writes an invalid document. Validation failures are reported as clear, structured errors that name the offending field and the rule it broke.",
+  "category": "nonFunctional",
+  "domain": "quality",
+  "priority": "must",
+  "rationale": "A non-coder cannot catch a malformed document by eye. The tool must refuse to write invalid state and must explain why, so the owner can trust that what is on disk is always valid.",
+  "tags": [
+    "validation",
+    "quality",
+    "schemas"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/requirements/req-008.json

@@ -0,0 +1,19 @@
+{
+  "createdAt": "2026-07-20T17:01:21.557Z",
+  "updatedAt": "2026-07-28T16:40:04.361Z",
+  "category": "functional",
+  "priority": "must",
+  "description": "The agent guidance pack teaches a build method that keeps the deployment runtime present in the loop from elicitation to verification, so that a non-coding owner who cannot self-verify is not led into an undeployable stack or a false 'verified' claim. It requires four properties of the method the tool ships: (1) every build lands a working, documented local preview loop as its default outcome; (2) elicitation establishes where the app will run early and constrains the stack to that answer, with a jargon-free hosting-choice walkthrough when the owner does not know; (3) every 'verified' or 'tested' claim names the runtime it was checked against and never implies deploy-runtime verification that did not happen; (4) the method carries guidance for a periodic and end-of-build fresh-context self-review that drives the app against its acceptance criteria, subordinate to the independent verification gate rather than a substitute for it. This requirement governs the shipped guidance/prompt surface, not a new runtime subsystem.",
+  "rationale": "The five-run rcf-persona-testing programme (concluded 2026-07-20) found the tool builds excellently at every level but its own loop missed a ship-blocking or user-facing defect in three of five runs, with a single root cause: the deploy runtime is absent from the loop. It is absent from elicitation (runs 03/04 chose Cloudflare-incompatible stacks a CF-only holder cannot host, run 03 silently) and absent from verification (run 05 shipped a production auth 500 while 89/89 tests were green and the tool claimed a live-Worker verification its E2E never ran). The target user cannot diagnose 'wrong stack for your host' or 'verified against the wrong runtime', so the method itself must foreclose both. These are Tier-1 hardening fixes to make the base offering usable now, while the productised independent verification gate (rcf-verify-lite) is built separately.",
+  "reqId": "REQ-008",
+  "prdId": "PRD-001",
+  "title": "Deploy-aware, runtime-honest build guidance",
+  "domain": "guidance",
+  "version": "0.1.0",
+  "status": "draft",
+  "tags": [
+    "guidance",
+    "deploy",
+    "verification"
+  ]
+}

package/rcf/requirements/req-009.json

@@ -0,0 +1,19 @@
+{
+  "reqId": "REQ-009",
+  "prdId": "PRD-001",
+  "title": "Umbrella CLI: verify as a first-class subcommand",
+  "description": "Post 0.7.1 packaging consolidation the RCF Lite suite ships as one npm package with one unified `rcf` CLI. The adversarial ship-gate verifier that used to live behind its own `rcf-verify` bin is mounted as `rcf verify <run|report|provision|cleanup|mcp>` on that unified CLI. The pre-existing `rcf-verify` bin remains as a transition-grace alias that dispatches through the same handlers, deprecated in favour of `rcf verify`. Behaviour of each verify verb is unchanged; only the invocation form gains a canonical route.",
+  "category": "functional",
+  "domain": "cli",
+  "priority": "must",
+  "rationale": "The packaging consolidation ruling (docs/2026-08-06_packaging-consolidation-proposal.md, ratified 2026-08-11) picks one install (`rcf-lite`) with one CLI verb space (`rcf`). Verify is a first-class part of the RCF chain (define, build, verify) and must sit inside that verb space, not beside it. Keeping `rcf-verify` as an alias avoids a hard break for existing scripts across a transition window.",
+  "tags": [
+    "packaging",
+    "cli",
+    "verify"
+  ],
+  "version": "0.1.0",
+  "status": "draft",
+  "createdAt": "2026-08-11T00:00:00Z",
+  "updatedAt": "2026-08-11T00:00:00Z"
+}

package/rcf/tacs/tac-001.json

@@ -0,0 +1,45 @@
+{
+  "tacId": "TAC-001",
+  "prdId": "PRD-001",
+  "tadId": "TAD-001",
+  "version": "0.1.0",
+  "status": "draft",
+  "name": "Document store",
+  "purpose": "Own all reads, validation and writes of RCF documents on the local filesystem, and be the only component that touches the rcf tree.",
+  "responsibilities": [
+    "Resolve a document file path from a document id by convention",
+    "Load and parse a document and validate it against its schema",
+    "Walk from the roots to assemble the full in-memory tree",
+    "Persist a document only after it validates",
+    "Surface broken references and schema failures as structured errors"
+  ],
+  "internalStructure": "A loader resolves ids to paths and parses JSON. A validator wraps the published schema bundle and is registered once at start-up. A writer serialises and persists. A tree walker reads the manifest roots and follows the parent id lists to build the full document set in memory.",
+  "interfaces": [
+    {
+      "name": "loadDocument",
+      "kind": "function",
+      "description": "Resolve an id to a path, parse and validate, return the document or a structured error."
+    },
+    {
+      "name": "saveDocument",
+      "kind": "function",
+      "description": "Validate then persist a document; refuse to write if validation fails."
+    },
+    {
+      "name": "walkTree",
+      "kind": "function",
+      "description": "From the manifest roots, resolve every child by id and return the full tree."
+    }
+  ],
+  "dependencies": [
+    {
+      "name": "rcf-schemas",
+      "kind": "external",
+      "description": "The published schema package the validator registers at start-up."
+    }
+  ],
+  "tradeoffs": "Centralising all filesystem access in one component costs a small amount of indirection but guarantees that no consumer can write an unvalidated document or bypass the source-of-truth rule.",
+  "notes": "The store is intentionally synchronous where possible; a local CLI does not benefit from streaming and synchronous code is easier for contributors to follow.",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/tacs/tac-002.json

@@ -0,0 +1,109 @@
+{
+  "tacId": "TAC-002",
+  "prdId": "PRD-001",
+  "tadId": "TAD-001",
+  "version": "0.1.0",
+  "status": "draft",
+  "name": "CLI binary",
+  "purpose": "The rcf command-line entry point. Map verbs to store, query, view or build operations and render results and errors for a terminal.",
+  "responsibilities": [
+    "Parse command-line arguments and route each verb to the matching core operation",
+    "Render results as readable terminal output by default",
+    "Honour quiet and verbose flags for scripting and diagnostics",
+    "Surface structured errors as human-readable messages with the underlying detail available"
+  ],
+  "internalStructure": "A small command router maps each verb (init, view, read, create, update, delete, coverage, trace, impact, build, validate) to a function in the store, query, view or build adapter. A formatter renders results for a terminal.",
+  "interfaces": [
+    {
+      "name": "init",
+      "kind": "command",
+      "description": "Initialise a new RCF project on disk."
+    },
+    {
+      "name": "view",
+      "kind": "command",
+      "description": "Generate the diagram and the static page."
+    },
+    {
+      "name": "read",
+      "kind": "command",
+      "description": "Read a document by id."
+    },
+    {
+      "name": "create",
+      "kind": "command",
+      "description": "Create a document with parent linkage."
+    },
+    {
+      "name": "update",
+      "kind": "command",
+      "description": "Update fields on a document."
+    },
+    {
+      "name": "delete",
+      "kind": "command",
+      "description": "Delete a document with reference safety."
+    },
+    {
+      "name": "coverage",
+      "kind": "command",
+      "description": "Report coverage gaps across the tree."
+    },
+    {
+      "name": "trace",
+      "kind": "command",
+      "description": "Trace forward or back along the intent chain."
+    },
+    {
+      "name": "impact",
+      "kind": "command",
+      "description": "Report what is affected by a document change."
+    },
+    {
+      "name": "build",
+      "kind": "command",
+      "description": "Assemble a build prompt or mark a slice done."
+    },
+    {
+      "name": "validate",
+      "kind": "command",
+      "description": "Validate every document and list broken references."
+    }
+  ],
+  "dependencies": [
+    {
+      "name": "Document store",
+      "kind": "tac",
+      "tacId": "TAC-001",
+      "description": "All filesystem access goes through the store."
+    },
+    {
+      "name": "View renderer",
+      "kind": "tac",
+      "tacId": "TAC-003",
+      "description": "The view verb routes to the renderer."
+    },
+    {
+      "name": "Query engine",
+      "kind": "tac",
+      "tacId": "TAC-004",
+      "description": "The coverage, trace and impact verbs route to the query engine."
+    },
+    {
+      "name": "Build adapter",
+      "kind": "tac",
+      "tacId": "TAC-005",
+      "description": "The build verbs route to the build adapter."
+    },
+    {
+      "name": "Error and reporting",
+      "kind": "tac",
+      "tacId": "TAC-007",
+      "description": "Structured errors are rendered consistently."
+    }
+  ],
+  "tradeoffs": "A single binary keeps the install and discovery story simple; a fragmented set of binaries would be more orthogonal but is overkill for a single project.",
+  "notes": "Verbs are kept close to the spoken vocabulary of the method so a non-coder can guess the command from the document type.",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/tacs/tac-003.json

@@ -0,0 +1,40 @@
+{
+  "tacId": "TAC-003",
+  "prdId": "PRD-001",
+  "tadId": "TAD-001",
+  "version": "0.1.0",
+  "status": "draft",
+  "name": "View renderer",
+  "purpose": "Produce the diagram source and the static browsable page from a loaded RCF tree, with broken references marked visibly and no server required.",
+  "responsibilities": [
+    "Build a diagram from the chain edges between documents",
+    "Render each document as a readable section, not raw JSON",
+    "Mark broken references visibly in both diagram and page",
+    "Write static output files that open in a browser with no server process"
+  ],
+  "internalStructure": "A diagram builder walks the loaded tree and emits Mermaid source. A page builder renders each document into a templated HTML section and links between them by id. Output is written to a fixed view directory at the project root.",
+  "interfaces": [
+    {
+      "name": "renderDiagram",
+      "kind": "function",
+      "description": "Emit the diagram source for the whole tree."
+    },
+    {
+      "name": "renderPage",
+      "kind": "function",
+      "description": "Write the static browsable page to the view output directory."
+    }
+  ],
+  "dependencies": [
+    {
+      "name": "Document store",
+      "kind": "tac",
+      "tacId": "TAC-001",
+      "description": "The renderer reads the loaded tree only through the store."
+    }
+  ],
+  "tradeoffs": "Mermaid is locked as the diagram format because it renders without a runtime and ships everywhere; a pluggable renderer would add an interface for a benefit the product does not yet need.",
+  "notes": "The fixed output directory keeps the configuration surface zero and the output discoverable.",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/tacs/tac-004.json

@@ -0,0 +1,51 @@
+{
+  "tacId": "TAC-004",
+  "prdId": "PRD-001",
+  "tadId": "TAD-001",
+  "version": "0.1.0",
+  "status": "draft",
+  "name": "Query engine",
+  "purpose": "Answer traceability questions over a loaded RCF tree without ever traversing the FBS layer.",
+  "responsibilities": [
+    "Compute coverage gaps across requirements, stories, criteria and tests",
+    "Trace forward from any document to its descendants along the intent chain",
+    "Trace back from any document to its ancestors along the intent chain",
+    "Compute impact sets across the intent chain and the architecture references on FBS",
+    "Never walk the FBS layer when computing intent-chain traces"
+  ],
+  "internalStructure": "A walker traverses the chain (PRD to REQ to US to AC to TS to TC) by id. Coverage and trace operations are layered over the walker. Impact analysis additionally inspects FBS contextRequirements references.",
+  "interfaces": [
+    {
+      "name": "coverage",
+      "kind": "function",
+      "description": "Report coverage gaps across the tree."
+    },
+    {
+      "name": "traceForward",
+      "kind": "function",
+      "description": "Trace from a document to its descendants along the intent chain."
+    },
+    {
+      "name": "traceBack",
+      "kind": "function",
+      "description": "Trace from a document back to its ancestors along the intent chain."
+    },
+    {
+      "name": "impact",
+      "kind": "function",
+      "description": "Compute the impact set of a change to a given document."
+    }
+  ],
+  "dependencies": [
+    {
+      "name": "Document store",
+      "kind": "tac",
+      "tacId": "TAC-001",
+      "description": "All traversal reads through the store."
+    }
+  ],
+  "tradeoffs": "A general graph engine would be more expressive but the intent chain is small and a hand-rolled walker is easier to reason about and to keep correct.",
+  "notes": "Keeping the FBS out of intent traces is a load-bearing design rule, not an optimisation.",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}

package/rcf/tacs/tac-005.json

@@ -0,0 +1,52 @@
+{
+  "tacId": "TAC-005",
+  "prdId": "PRD-001",
+  "tadId": "TAD-001",
+  "version": "0.1.0",
+  "status": "draft",
+  "name": "Build adapter",
+  "purpose": "Walk an FBS and its references to assemble an implementation prompt, compute the dependency-respecting build order, and mark slices done.",
+  "responsibilities": [
+    "Walk acceptance criteria in acIds to their parent user stories",
+    "Walk referenced TACs and ADRs and include their relevant content",
+    "Assemble a single markdown prompt for the named FBS",
+    "Topologically sort the FBS dependency graph and detect cycles",
+    "Advance FBS execution status and the matching Build Sequence slot status when a slice is marked done"
+  ],
+  "internalStructure": "A prompt assembler composes a markdown document from the FBS, its acceptance criteria and the referenced architecture documents. A sorter computes the build order from FBS dependency lists. A mark-done operation updates execution status fields and writes through the store.",
+  "interfaces": [
+    {
+      "name": "assemblePrompt",
+      "kind": "function",
+      "description": "Assemble the implementation prompt for a named FBS."
+    },
+    {
+      "name": "buildOrder",
+      "kind": "function",
+      "description": "Compute the dependency-respecting order and parallel-safe groups."
+    },
+    {
+      "name": "markDone",
+      "kind": "function",
+      "description": "Advance the FBS and slot status when a slice is finished."
+    }
+  ],
+  "dependencies": [
+    {
+      "name": "Document store",
+      "kind": "tac",
+      "tacId": "TAC-001",
+      "description": "Read FBS, AC, TAC and ADR through the store; write status updates through the store."
+    },
+    {
+      "name": "Query engine",
+      "kind": "tac",
+      "tacId": "TAC-004",
+      "description": "Reuse the walker to resolve AC to parent user stories."
+    }
+  ],
+  "tradeoffs": "The prompt is assembled as a single markdown document for simplicity and portability; a richer structured payload would be more flexible but would lock the consumer to a non-portable shape.",
+  "notes": "Mark-done is an explicit command so the tool stays offline and harness-agnostic; no PR-watching daemon is required.",
+  "createdAt": "2026-06-25T00:00:00Z",
+  "updatedAt": "2026-06-25T00:00:00Z"
+}