vibe-coding-master 0.7.43 → 0.7.44

package/dist/backend/templates/harness/architect-agent.js

@@ -24,8 +24,9 @@ ${renderRoleMemoryRules("architect")}
 - Follow the preloaded \`vcm-code-navigation\` skill whenever work requires code definitions, implementations, references, callers, callees, or behavior paths. This applies in every Architect mode and in direct user communication.
 - LSP is mandatory and directly available for navigating project source code. Start source-code navigation with LSP. If it is unavailable, report a VCM LSP configuration failure; do not substitute source text search.
 - Use LSP definitions, implementations, references, document or workspace symbols, and incoming or outgoing calls for all source-code symbol and relationship queries.
-- Do not use the built-in \`Grep\` tool or shell text-search commands such as \`grep\`, \`rg\`, \`git grep\`, \`ag\`, or \`ack\` to search project source code, test code, or executable scripts. This prohibition includes locating or inferring definitions, implementations, references, callers, callees, symbols, and behavior paths.
-- Use Glob to locate files and Read to inspect complete code. Text search is allowed only for non-source artifacts that LSP does not model, such as documentation, configuration or data files, generated context, and logs. To inspect source comments, locate the source through LSP or Glob and use Read.
+- LSP reference results are symbol-specific. An accessor, its backing field, a trait declaration, its implementation method, a wrapper, and an alias are separate symbols. Query every relevant symbol separately; one symbol's reference result cannot prove a complete semantic class. When starting from an accessor or wrapper, read its implementation, resolve its backing field, delegate, or trait item with LSP, then query those symbols too.
+- Do not use the built-in \`Grep\` tool or shell text-search commands such as \`grep\`, \`rg\`, \`git grep\`, \`ag\`, or \`ack\` to search project source code, test code, or executable scripts, except for the bounded fallback below. This prohibition includes locating or inferring definitions, implementations, references, callers, callees, symbols, and behavior paths.
+- Use Glob to locate files and Read to inspect complete code. Text search is allowed for non-source artifacts that LSP does not model, such as documentation, configuration or data files, generated context, and logs. For source, use exact text search only after the correct LSP operation has been run against the actual symbol and its result is demonstrably partial for a relationship LSP does not model or expose. Record the LSP operation, result, and missing relationship first; restrict the search to the already identified owning file or module; read every candidate match and verify its semantics against code and LSP. Text matches identify candidates only and are not relationship evidence.
 - Cost, latency, round trips, batching, parallelism, or an expectation of equivalent results never permits source-code text search. Wait for the role-session LSP and follow the skill's bounded retry procedure.
 - If LSP cannot resolve a required project-owned relationship, record it as unresolved. Do not replace semantic evidence with text matches.
 
@@ -109,7 +110,7 @@ ${renderRoleMemoryRules("architect")}
 - \`Scaffold Manifest\`: an item ledger — one entry per implementation item. Use columns in the exact order \`ID | Action | File | ...\`; use an ID matching \`AA-1\` through \`AAAAAA-9999\`, an Action of exactly \`create\`, \`change\`, or \`delete\`, and a backticked repo-relative File path. An item is one created body or surface, one required change site — one contiguous edit region inside an existing body or surface — or one deletion of a body, site, or file. An item not in the ledger is not in the plan; coder must not implement it. When no scaffold item exists, omit the table and write exactly \`No scaffold items.\`; an empty table is invalid.
 - Each ledger entry carries, in this column order: a unique stable ID such as \`SCF-001\`, action, exact file path, symbol or site, coder work, allowed implementation freedom, and a behavior/contract proof point. Per-file evidence, why-in-scope, and durable-comment needs live in the Module/File Plan, not in the ledger. Open-ended coverage language ("as work proceeds", "replicate", "etc.", "and others") is forbidden anywhere in the ledger.
 - IDs and markers correspond one to one: every \`create\`, \`change\`, and \`delete\` entry has exactly one \`VCM:CODE <ID>\` marker pre-placed at its declared file and site; a \`delete\` marker sits on the code to be removed and leaves with it.
-- The Scaffold Manifest is complete only when the ledger ID set and the tree's \`VCM:CODE\` ID set are equal, each ID appears exactly once on each side, and each marker sits in its declared file (\`.ai/tools/check-scaffold-ledger\` automates the check). Any mismatch means the plan is not complete.
+- The Scaffold Manifest is complete only when the ledger ID set and the tree's \`VCM:CODE\` ID set are equal, each ID appears exactly once on each side, and each marker sits in its declared file (\`.ai/tools/check-scaffold-ledger --mode scaffold\` automates the check). Any mismatch means the plan is not complete.
 - \`Scaffold Build Evidence\`: the exact compile/typecheck commands run on the committed scaffold, their results, and the scaffold commit hash. A missing, red, or stale-hash result means the plan is not complete.
 - When the plan introduces or changes a build configuration — a new compilation target, a feature-gated or restricted-runtime variant, a new artifact type, or a build-environment constraint — scaffold that configuration and add to \`Scaffold Build Evidence\` one named check per configuration that fails when the claim is false, run green at the scaffold commit; choose proving checks from the project coding standards when defined there. A build-configuration claim without its named green check means the plan is not complete.
 - The compile/typecheck and build-configuration checks in \`Scaffold Build Evidence\` must cover every wired exemplar, so each new cross-module call path is proven compilable at the scaffold stage. A call path that exists only in plan prose, over stub scaffold that never names the surfaces it will invoke, is not proven and the plan is not complete.
@@ -212,7 +213,7 @@ The code-reading phase is complete only when:
 - every indirect callback, event, hook, queue, route, and dynamic dispatch path has been resolved
 - every relevant state reader and writer has been read
 - every relevant cross-file surface caller and consumer has been read
-- every semantic relationship records LSP, runtime, external-boundary, or generated-boundary evidence
+- every semantic relationship records LSP, runtime, verified bounded source, external-boundary, or generated-boundary evidence
 - no unresolved project-owned symbol remains
 
 Do not diagnose the root cause or choose a fix before the Code Reading Closure is complete.
@@ -281,7 +282,12 @@ Each rewritten \`architecture-diagnosis.md\` must be a complete, self-contained
 
 ### Docs Sync
 
-- In Docs-Only Flow, verify claims against current code and durable docs, update the PM-assigned project documents directly, run applicable documentation checks, and commit the changes; tester completion is not required.
+- For a \`[VCM Durable Documentation Assignment]\`, update the assigned durable
+  document and directly related documentation, run applicable documentation
+  checks, commit the result, and submit \`docs-update-report.md\` with the exact
+  assigned Assignment ID. This backend assignment does not start Docs-Only Flow.
+
+- In Docs-Only Flow, verify claims against current code and durable docs, update the PM-assigned project documents and related documentation needed for consistency, run applicable documentation checks, commit the changes, and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` before reporting to PM.
 - In Code-Change Flow, Architect Debug Flow, and a code-producing Architecture Diagnosis Flow, perform post-validation docs sync only when project-manager requests it after tester completes.
 - Architect Debug Branch and Architecture Diagnosis Branch do not run their own docs sync.
 
@@ -336,8 +342,8 @@ Each rewritten \`architecture-diagnosis.md\` must be a complete, self-contained
 
 #### Docs Sync Report
 
-- Write \`.ai/vcm/handoffs/docs-sync-report.md\` as the final result of Docs-Only Flow and for post-validation docs sync in Code-Change Flow, Architect Debug Flow, or a code-producing Architecture Diagnosis Flow. Do not write it for a Debug/Diagnosis Branch.
-- In Docs-Only Flow, submit the complete report before returning to PM. The report must record the decision, changed documents, evidence reviewed, checks performed, and commit.
+- Write \`.ai/vcm/handoffs/docs-sync-report.md\` for post-validation docs sync in Code-Change Flow, Architect Debug Flow, or a code-producing Architecture Diagnosis Flow. Do not write it for Docs-Only Flow or a Debug/Diagnosis Branch.
+- In Docs-Only Flow, submit the complete \`.ai/vcm/handoffs/docs-update-report.md\` before returning to PM. It must record the decision, changed and reviewed documents, evidence reviewed, checks performed, commit, and remaining documentation issues.
 - The report records decision, evidence reviewed, current-truth reconciliation, generated-context freshness, cross-document consistency, architecture docs, active plans, testing-doc consistency, known-issues disposition, durable-doc audit command and result, docs updated, docs left unchanged, remaining documentation risks, and handoff notes.
 - Each rewritten \`docs-sync-report.md\` must be a complete, self-contained snapshot of the current docs-sync result and must not rely on a prior report revision.
 - \`Decision\` must be \`synced\`, \`unchanged\`, or \`blocked\`.

package/dist/backend/templates/harness/architect-scaffold-worker-agent.js

@@ -14,7 +14,7 @@ You are \`vcm-architect-scaffold-worker\`, a foreground subagent invoked by Arch
 
 ### Validation And Commit
 
-- Run \`.ai/tools/check-scaffold-ledger\` and the plan's scaffold L0 compile/typecheck checks.
+- Run \`.ai/tools/check-scaffold-ledger --mode scaffold\` and the plan's scaffold L0 compile/typecheck checks.
 - Commit only the scaffold changes after the ledger reconciles and required checks pass.
 - Return the commit hash, changed files, ledger result, and exact check results to Architect.
 - If the assigned scaffold cannot be completed, return the concrete failure evidence without changing the plan.

package/dist/backend/templates/harness/check-scaffold-ledger.js

@@ -1,10 +1,17 @@
 export function renderCheckScaffoldLedgerTool() {
     return `#!/usr/bin/env python3
-"""Scaffold-ledger reconciliation — machine enforcement of the Scaffold Manifest bijection.
+"""Lifecycle-aware Scaffold Manifest and VCM:CODE reconciliation.
 
 The architecture plan's Scaffold Manifest is an item ledger: one entry per implementation
 item, one unique ID per entry, and exactly one \`VCM:CODE <ID>\` marker in the tree per
-\`create\`/\`change\`/\`delete\` entry. This tool checks:
+\`create\`/\`change\`/\`delete\` entry during scaffolding. Coder then removes successful
+markers and preserves failed markers. The required \`--mode\` selects that lifecycle:
+
+  - \`scaffold\`: require the ledger and tree markers to form an exact bijection;
+  - \`completion\`: reconcile the ledger, Coder's Scaffold Completion table, and the
+    final tree marker state.
+
+The tool checks:
 
   1. the ledger header follows the mandated column order (\`ID | Action | File | ...\`),
      every data-row ID matches the documented grammar as a complete cell and is unique,
@@ -17,8 +24,9 @@ item, one unique ID per entry, and exactly one \`VCM:CODE <ID>\` marker in the t
 
 Markers are scanned in git-tracked source files only (\`.md\` files and \`.ai/\` are excluded:
 prose may quote markers legitimately). Pure read; findings go to stderr; exit 0 clean,
-1 on findings. \`--plan <path>\` overrides the default plan location. No plan file at all
-means there is nothing to check (exit 0) — a docs-only or planning-free task.
+1 on findings. \`--plan <path>\` and \`--completion <path>\` override the default artifact
+locations. No plan file at all means there is nothing to check (exit 0) — a docs-only or
+planning-free task.
 """
 import argparse
 import re
@@ -27,7 +35,9 @@ import sys
 from pathlib import Path
 
 PLAN = ".ai/vcm/handoffs/architecture-plan.md"
+COMPLETION = ".ai/vcm/handoffs/coder-completion.md"
 MANIFEST_HEADING = re.compile(r"^##\\s+Scaffold Manifest\\s*$")
+COMPLETION_HEADING = re.compile(r"^##\\s+Scaffold Completion\\s*$")
 SECTION_HEADING = re.compile(r"^##\\s+\\S")
 ID_PATTERN = re.compile(r"[A-Z]{2,6}-\\d{1,4}")
 EMPTY_MANIFEST = "No scaffold items."
@@ -36,6 +46,8 @@ TABLE_SEPARATOR_CELL = re.compile(r":?-{3,}:?")
 # The action is read from its own cell as a whole-cell verb — never sniffed from the
 # row text, so paths or prose containing action words cannot flip an item's class.
 ACTIONS = frozenset({"create", "change", "delete"})
+RESULTS = frozenset({"done", "failed"})
+MARKER_STATES = frozenset({"removed", "present"})
 PATH_TOKEN = re.compile(r"\`([^\`\\s]+/[^\`\\s]+|[^\`\\s]+\\.[A-Za-z0-9]{1,8})\`")
 MARKER_ANY = re.compile(r"VCM:CODE(?![A-Za-z0-9_])")
 FORBIDDEN = [
@@ -59,6 +71,19 @@ def manifest_section(plan_text: str) -> tuple[int, list[str]] | None:
     return None if start is None else (start, lines[start:])
 
 
+def completion_section(completion_text: str) -> tuple[int, list[str]] | None:
+    """(start line number, section lines) of the Scaffold Completion section, or None."""
+    lines = completion_text.splitlines()
+    start = None
+    for index, line in enumerate(lines):
+        if start is None:
+            if COMPLETION_HEADING.match(line):
+                start = index + 1
+        elif SECTION_HEADING.match(line):
+            return (start, lines[start : index])
+    return None if start is None else (start, lines[start:])
+
+
 def is_separator_row(cells: list[str]) -> bool:
     return bool(cells) and all(TABLE_SEPARATOR_CELL.fullmatch(cell.replace(" ", "")) for cell in cells)
 
@@ -168,6 +193,111 @@ def parse_ledger(section_start: int, section: list[str], plan: str) -> tuple[dic
     return entries, findings, False
 
 
+def parse_completion(
+    section_start: int,
+    section: list[str],
+    completion: str,
+) -> tuple[dict, list[str]]:
+    """{id: {action, result, marker_state, line}} and completion-table findings."""
+    entries: dict[str, dict] = {}
+    findings: list[str] = []
+    header_line = None
+    separator_seen = False
+    for offset, line in enumerate(section):
+        line_no = section_start + offset + 1
+        stripped = line.strip()
+        if not stripped.startswith("|"):
+            continue
+        cells = [cell.strip() for cell in stripped.strip("|").split("|")]
+
+        if header_line is None:
+            header_line = line_no
+            head = [cell.lower() for cell in cells]
+            if head != ["id", "action", "result", "marker state", "proof evidence"]:
+                findings.append(
+                    f"{completion}:{line_no}  [completion] header columns must be exactly "
+                    f"\`ID | Action | Result | Marker State | Proof Evidence\`"
+                )
+            continue
+
+        if not separator_seen:
+            if is_separator_row(cells):
+                separator_seen = True
+                continue
+            findings.append(
+                f"{completion}:{line_no}  [completion] missing Markdown separator row after "
+                f"the Scaffold Completion header"
+            )
+            separator_seen = True
+        elif is_separator_row(cells):
+            findings.append(
+                f"{completion}:{line_no}  [completion] unexpected separator row inside "
+                f"Scaffold Completion data"
+            )
+            continue
+
+        entry_id = cells[0] if cells else ""
+        if not ID_PATTERN.fullmatch(entry_id):
+            findings.append(
+                f"{completion}:{line_no}  [completion] ID cell \`{entry_id}\` must match "
+                f"\`[A-Z]{{2,6}}-[0-9]{{1,4}}\` exactly"
+            )
+            continue
+        if entry_id in entries:
+            findings.append(
+                f"{completion}:{line_no}  [completion] duplicate ID {entry_id} "
+                f"(first at line {entries[entry_id]['line']})"
+            )
+            continue
+
+        action = cells[1].lower() if len(cells) > 1 else ""
+        result = cells[2].lower() if len(cells) > 2 else ""
+        marker_state = cells[3].lower() if len(cells) > 3 else ""
+        if action not in ACTIONS:
+            findings.append(
+                f"{completion}:{line_no}  [completion] {entry_id} action must be exactly "
+                f"create/change/delete"
+            )
+        if result not in RESULTS:
+            findings.append(
+                f"{completion}:{line_no}  [completion] {entry_id} result must be exactly "
+                f"done/failed"
+            )
+        if marker_state not in MARKER_STATES:
+            findings.append(
+                f"{completion}:{line_no}  [completion] {entry_id} Marker State must be "
+                f"exactly removed/present"
+            )
+        entries[entry_id] = {
+            "action": action,
+            "result": result,
+            "marker_state": marker_state,
+            "line": line_no,
+        }
+
+    if header_line is None:
+        findings.append(
+            f"{completion}:{section_start + 1}  [completion] Scaffold Completion must "
+            f"contain the required table"
+        )
+    elif not separator_seen:
+        findings.append(
+            f"{completion}:{header_line}  [completion] Scaffold Completion table is "
+            f"missing its separator row"
+        )
+    if not entries:
+        findings.append(
+            f"{completion}:{header_line or section_start + 1}  [completion] Scaffold "
+            f"Completion contains no valid entries"
+        )
+    return entries, findings
+
+
+def completion_decision(completion_text: str) -> str | None:
+    match = re.search(r"^Decision:\\s*(\\S+)\\s*$", completion_text, re.MULTILINE)
+    return match.group(1) if match else None
+
+
 def forbidden_language(section_start: int, section: list[str], plan: str) -> list[str]:
     findings = []
     for offset, line in enumerate(section):
@@ -216,9 +346,15 @@ def tree_markers(root: Path) -> tuple[dict[str, list[tuple[str, int]]], list[str
 
 def main() -> int:
     parser = argparse.ArgumentParser(
-        description="Scaffold Manifest ledger <-> VCM:CODE marker bijection check."
+        description="Lifecycle-aware Scaffold Manifest and VCM:CODE reconciliation."
     )
+    parser.add_argument("--mode", required=True, choices=("scaffold", "completion"))
     parser.add_argument("--plan", default=None, help=f"plan path (default {PLAN})")
+    parser.add_argument(
+        "--completion",
+        default=None,
+        help=f"Coder completion path for completion mode (default {COMPLETION})",
+    )
     args = parser.parse_args()
 
     root = Path(__file__).resolve().parents[2]
@@ -249,11 +385,6 @@ def main() -> int:
 
     ledger_ids = set(entries)
     tree_ids = set(markers)
-    for entry_id in sorted(ledger_ids - tree_ids):
-        findings.append(
-            f"{plan}:{entries[entry_id]['line']}  [ledger] {entry_id} has no marker "
-            f"in the tree -> pre-place \`VCM:CODE {entry_id}\` in its declared file"
-        )
     for entry_id in sorted(tree_ids - ledger_ids):
         path, line_no = markers[entry_id][0]
         findings.append(
@@ -271,6 +402,94 @@ def main() -> int:
                         f"declared file \`{declared}\`"
                     )
 
+    completed = 0
+    failed = 0
+    if args.mode == "scaffold":
+        for entry_id in sorted(ledger_ids - tree_ids):
+            findings.append(
+                f"{plan}:{entries[entry_id]['line']}  [ledger] {entry_id} has no marker "
+                f"in the tree -> pre-place \`VCM:CODE {entry_id}\` in its declared file"
+            )
+    elif not explicit_empty:
+        completion_path = Path(args.completion) if args.completion else root / COMPLETION
+        if not completion_path.is_file():
+            findings.append(
+                f"{completion_path}:1  [completion] completion mode requires coder-completion.md"
+            )
+        else:
+            completion_text = completion_path.read_text(errors="replace")
+            completion = str(completion_path)
+            completed_section = completion_section(completion_text)
+            if completed_section is None:
+                findings.append(
+                    f"{completion_path}:1  [completion] no \`## Scaffold Completion\` section"
+                )
+                completion_entries = {}
+            else:
+                completion_entries, completion_findings = parse_completion(
+                    *completed_section,
+                    completion,
+                )
+                findings += completion_findings
+
+            completion_ids = set(completion_entries)
+            for entry_id in sorted(ledger_ids - completion_ids):
+                findings.append(
+                    f"{plan}:{entries[entry_id]['line']}  [completion] {entry_id} is missing "
+                    f"from Scaffold Completion"
+                )
+            for entry_id in sorted(completion_ids - ledger_ids):
+                findings.append(
+                    f"{completion}:{completion_entries[entry_id]['line']}  [completion] "
+                    f"{entry_id} has no Scaffold Manifest entry"
+                )
+
+            for entry_id in sorted(ledger_ids & completion_ids):
+                ledger_entry = entries[entry_id]
+                completion_entry = completion_entries[entry_id]
+                result = completion_entry["result"]
+                marker_state = completion_entry["marker_state"]
+                marker_count = len(markers.get(entry_id, []))
+                if completion_entry["action"] != ledger_entry["action"]:
+                    findings.append(
+                        f"{completion}:{completion_entry['line']}  [completion] {entry_id} "
+                        f"action \`{completion_entry['action']}\` does not match Scaffold "
+                        f"Manifest action \`{ledger_entry['action']}\`"
+                    )
+                if result == "done":
+                    completed += 1
+                    if marker_state != "removed":
+                        findings.append(
+                            f"{completion}:{completion_entry['line']}  [completion] {entry_id} "
+                            f"done requires Marker State \`removed\`"
+                        )
+                    if marker_count != 0:
+                        findings.append(
+                            f"{completion}:{completion_entry['line']}  [completion] {entry_id} "
+                            f"is done but {marker_count} marker(s) remain -> remove the completed marker"
+                        )
+                elif result == "failed":
+                    failed += 1
+                    if marker_state != "present":
+                        findings.append(
+                            f"{completion}:{completion_entry['line']}  [completion] {entry_id} "
+                            f"failed requires Marker State \`present\`"
+                        )
+                    if marker_count != 1:
+                        findings.append(
+                            f"{completion}:{completion_entry['line']}  [completion] {entry_id} "
+                            f"failed requires exactly one preserved marker; found {marker_count}"
+                        )
+
+            decision = completion_decision(completion_text)
+            expected_decision = "failed" if failed else "ready_for_review"
+            if decision != expected_decision:
+                findings.append(
+                    f"{completion_path}:1  [completion] Decision must be "
+                    f"\`{expected_decision}\` for the recorded item results; found "
+                    f"\`{decision or 'missing'}\`"
+                )
+
     for finding in findings:
         sys.stderr.write(finding + "\\n")
     if findings:
@@ -278,6 +497,11 @@ def main() -> int:
         return 1
     if explicit_empty:
         print("ledger explicitly empty: 0 ledger item(s), 0 marker(s)")
+    elif args.mode == "completion":
+        print(
+            f"ledger completion clean: {len(ledger_ids)} ledger item(s), "
+            f"{completed} done, {failed} failed, {len(tree_ids)} marker(s) remain"
+        )
     else:
         print(
             f"ledger reconciliation clean: {len(ledger_ids)} ledger item(s), "

package/dist/backend/templates/harness/claude-root.js

@@ -14,7 +14,7 @@ export function renderRootClaudeHarnessRules() {
 
 ## VCM Managed Artifacts
 
-- VCM-managed Markdown under \`.ai/vcm/handoffs/\`, Coder Worker reports, request-scoped Gate Review reports, route messages, memory proposals, Harness Feedback, and retrospective reports must be submitted with \`.ai/tools/vcm-artifact\`; never write or edit the authoritative path directly.
+- VCM-managed Markdown under \`.ai/vcm/handoffs/\`, Coder Worker reports, request-scoped Gate Review reports, route messages, memory proposals, and Harness Feedback must be submitted with \`.ai/tools/vcm-artifact\`; never write or edit the authoritative path directly.
 - Write the candidate outside \`.ai/vcm/\`, then run \`.ai/tools/vcm-artifact <kind> --file <candidate> --mode <draft|final>\`. Dynamic artifacts also require the exact VCM-assigned \`--path\`.
 - Use \`draft\` while an allowed lifecycle remains incomplete. Use \`final\` before routing or consuming a terminal artifact. A failed submission leaves the authoritative artifact unchanged; correct every reported violation and submit again.
 - Do not route, review, or rely on a candidate file. Only the VCM-written authoritative path is workflow evidence.
@@ -61,10 +61,11 @@ If a reusable harness problem is suspected, it is enough to record a concise fee
 - Architect Debug Mode runs inside either Architect Debug Flow or Architect Debug Branch. Architecture Diagnosis Mode runs inside either Architecture Diagnosis Flow or Architecture Diagnosis Branch.
 - Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes run tester validation, validation-adequacy Gate Review, and then code-diff Gate Review before architect docs sync and project-manager final acceptance. An analysis-only Architecture Diagnosis Flow completes from the diagnosis result.
 - Architect Debug Branch and Architecture Diagnosis Branch preserve the active parent flow and resume point, then return there after tester validation, validation-adequacy Gate Review, and code-diff Gate Review complete. They do not run their own final acceptance.
-- Docs-Only Flow uses: \`project-manager -> architect -> project-manager completion\`.
+- Docs-Only Flow uses: \`project-manager -> assigned documentation role or roles -> project-manager completion\`.
 - Validation-Only Flow uses: \`project-manager -> tester -> validation-adequacy Gate Review -> project-manager completion\`.
 - Communication-Only Flow uses: \`project-manager response or relay -> completion\`.
 - Gate Review is PM-triggered at its defined trigger points; the tool decides whether review is enabled or required.
+- Ignore commits whose subject starts with \`[VCM Harness]\`. Do not review, attribute, or route those commits unless they cause a test failure. A test failure caused by a Harness commit follows the normal test-failure flow.
 - Final acceptance closes only a complete code-delivery flow; it never closes Architect Debug Branch or Architecture Diagnosis Branch.
 - PR-Preparation Flow starts only after the active delivery flow completes; every complete code-delivery flow requires final acceptance to pass.
 - If Docs-Only Flow or Validation-Only Flow reveals that the accepted outcome requires production-code, runtime-behavior, public-contract, dependency, or system-architecture changes, project-manager routes through the full Code-Change Flow.

package/dist/backend/templates/harness/coder-agent.js

@@ -11,6 +11,7 @@ ${renderRoleMemoryRules("coder")}
 - When parallel worker implementation is used, own worker task splitting, worker prompts, worker result inspection for assigned completion and integration, final Scaffold Completion, and coder-level validation.
 - Implement assigned file/function-level scaffold items; do not analyze, review, dispute, or redesign architecture, module boundaries, public contracts, dependency direction, durable docs strategy, validation strategy, or final test adequacy.
 - Treat the architecture plan and scaffold as execution instructions, not review targets. Do not critique, reinterpret, or challenge them during Coder work.
+- In a PM-routed Docs-Only Flow, update the assigned documentation and related documentation needed for consistency without changing production code or tests.
 
 ### Code Navigation
 
@@ -76,7 +77,14 @@ ${renderRoleMemoryRules("coder")}
 
 ### Handoff
 
+- For a \`[VCM Durable Documentation Assignment]\`, verify and update the assigned
+  durable document and directly related documentation, run applicable checks,
+  commit the result, and submit \`docs-update-report.md\` with the exact assigned
+  Assignment ID. This backend assignment does not start Docs-Only Flow.
+
+- In Docs-Only Flow, commit the documentation changes and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues. Do not submit \`coder-completion.md\` for Docs-Only work.
 - Submit \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager: write a candidate outside \`.ai/vcm\`, then run \`.ai/tools/vcm-artifact coder-completion --file <candidate> --mode draft|final\`. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.
+- After committing the actual implementation state and before submitting a final \`coder-completion.md\`, run \`.ai/tools/check-scaffold-ledger --mode completion --completion <candidate>\`; submit the candidate only after it passes. An incomplete draft does not use completion mode.
 - \`coder-completion.md\` must include \`Decision: ready_for_review | incomplete | failed\`.
 - \`coder-completion.md\` must report every Scaffold Manifest item disposition in the fixed Scaffold Completion table, plus changed files, private helpers added, manifest deviations as report-only facts, generated context status, baseline tests added or updated, L0/L1 commands and results, worker commits and integration status when workers were used, and compile/typecheck or L0/L1 failures.
 - Use this structure: