vibe-coding-master 0.7.26 → 0.7.28

package/README.md

@@ -148,12 +148,15 @@ the active task worktree:
 - `.claude/agents/**`
 - `.claude/skills/**`
 - `.claude/settings.json` hooks
-- `.ai/tools/**`
+- VCM protocol and runtime tools under `.ai/tools/**`
 - `.gitignore` entries for VCM runtime state and task worktrees
-- generated-context tooling
+- initial project-owned generated-context tooling
 - pull request template
 
 VCM preserves user-authored content outside VCM managed blocks.
+VCM seeds `.ai/tools/generate-module-index` and
+`.ai/tools/generate-public-surface` only when missing. After installation these
+generators belong to the project and later harness updates do not replace them.
 
 The fixed harness install is deterministic and creates a commit in the active
 task worktree. Bootstrap is AI-assisted and is run through the Harness Engineer

package/dist/backend/cli/install-vcm-harness.js

@@ -229,13 +229,7 @@ const DURABLE_DOC_TEMPLATES = [
         content: "# Testing\n"
     },
 ];
-const WHOLE_FILES = [
-    {
-        path: ".ai/tools/check-durable-docs",
-        category: "durable-docs-tool",
-        mode: 0o755,
-        templatePath: "scripts/harness-tools/check-durable-docs"
-    },
+const PROJECT_OWNED_FILES = [
     {
         path: ".ai/tools/generate-module-index",
         category: "generated-context-tool",
@@ -247,6 +241,14 @@ const WHOLE_FILES = [
         category: "generated-context-tool",
         mode: 0o755,
         templatePath: "scripts/harness-tools/generate-public-surface"
+    }
+];
+const WHOLE_FILES = [
+    {
+        path: ".ai/tools/check-durable-docs",
+        category: "durable-docs-tool",
+        mode: 0o755,
+        templatePath: "scripts/harness-tools/check-durable-docs"
     },
     {
         path: ".claude/skills/vcm-architecture-interview/SKILL.md",
@@ -397,6 +399,9 @@ async function main() {
     for (const file of WHOLE_FILES) {
         await installWholeFile({ projectRoot, file, dryRun, operations });
     }
+    for (const file of PROJECT_OWNED_FILES) {
+        await installProjectOwnedFile({ projectRoot, file, dryRun, operations });
+    }
     await removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations });
     await removeLegacyCodexHarnessPaths({ projectRoot, dryRun, operations });
     await installManifest({
@@ -511,6 +516,14 @@ async function buildManifest(projectRoot) {
             ...fixedDirectories().map((directory) => manifestEntry(directory, "directory", directoryCategory(directory), "vcm-created")),
             manifestEntry("docs/GLOSSARY.md", "file", "project-glossary", "project-owned"),
             manifestEntry("docs/CODING_STANDARDS.md", "file", "project-coding-standards", "project-owned"),
+            ...PROJECT_OWNED_FILES.map((file) => ({
+                path: file.path,
+                entryType: "file",
+                category: file.category,
+                ownership: "project-owned",
+                source: "vcm-template",
+                lifecycle: "long-term"
+            })),
             ...WHOLE_FILES.map((file) => ({
                 path: file.path,
                 entryType: "file",
@@ -820,6 +833,23 @@ async function installWholeFile({ projectRoot, file, dryRun, operations }) {
         action: "write fixed VCM file"
     });
 }
+async function installProjectOwnedFile({ projectRoot, file, dryRun, operations }) {
+    const targetPath = resolveInside(projectRoot, file.path);
+    if (await pathExists(targetPath)) {
+        operations.push(skip(file.path, "exists; project-owned"));
+        return;
+    }
+    const content = await wholeFileContent(file);
+    await writeIfChanged({
+        targetPath,
+        relativePath: file.path,
+        content: ensureTrailingNewline(content),
+        mode: file.mode,
+        dryRun,
+        operations,
+        action: "seed project-owned VCM file"
+    });
+}
 async function removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations }) {
     const wholeFilesByPath = new Map(WHOLE_FILES.map((file) => [file.path, file]));
     for (const legacy of LEGACY_FLAT_SKILL_FILES) {

package/dist/backend/server.js

@@ -312,7 +312,8 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         appSettings,
         sessionService,
-        roundService
+        roundService,
+        onArchitecturePlanDisposition: ({ repoRoot, taskSlug, accepted }) => architectRestartService.recordArchitectureGateDisposition(repoRoot, taskSlug, accepted)
     });
     const translationWorkerService = createTranslationWorkerService({
         fs,

package/dist/backend/services/architect-restart-service.js

@@ -14,7 +14,7 @@ Before performing any assigned work, read:
 - the current scaffold commit and worktree state
 - the latest Gate Review report when present
 
-Treat the current artifacts and worktree as the source of truth. Do not repeat the completed interview or planning work unless current evidence contradicts them.`;
+Treat the current artifacts and worktree as the source of truth. The architecture-plan Gate has accepted the current planning artifacts or VCM recorded an explicit Gate exception. Do not repeat the completed interview or planning work unless a later route explicitly reopens it.`;
 export function createArchitectRestartService(deps) {
     const pendingByTask = new Map();
     return {
@@ -24,6 +24,11 @@ export function createArchitectRestartService(deps) {
             const key = taskKey(repoRoot, taskSlug);
             const existing = pendingByTask.get(key);
             if (existing?.sessionId === session.id) {
+                existing.stopped = false;
+                existing.deliveredMessageId = undefined;
+                existing.acceptedMessageId = undefined;
+                existing.gateAccepted = false;
+                existing.executing = false;
                 return { taskSlug, sessionId: session.id, status: "scheduled" };
             }
             pendingByTask.set(key, {
@@ -31,6 +36,7 @@ export function createArchitectRestartService(deps) {
                 taskSlug,
                 sessionId: session.id,
                 stopped: false,
+                gateAccepted: false,
                 executing: false
             });
             return { taskSlug, sessionId: session.id, status: "scheduled" };
@@ -65,6 +71,14 @@ export function createArchitectRestartService(deps) {
             pending.acceptedMessageId = message.id;
             await tryRestart(pending);
         },
+        async recordArchitectureGateDisposition(repoRoot, taskSlug, accepted) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.gateAccepted = accepted;
+            await tryRestart(pending);
+        },
         clear(repoRoot, taskSlug) {
             pendingByTask.delete(taskKey(repoRoot, taskSlug));
         }
@@ -95,7 +109,8 @@ export function createArchitectRestartService(deps) {
         if (pending.executing
             || !pending.stopped
             || !pending.deliveredMessageId
-            || pending.deliveredMessageId !== pending.acceptedMessageId) {
+            || pending.deliveredMessageId !== pending.acceptedMessageId
+            || !pending.gateAccepted) {
             return;
         }
         const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);

package/dist/backend/services/gate-review-service.js

@@ -121,6 +121,7 @@ export function createGateReviewService(deps) {
                 error: undefined
             }, now());
             await saveIndex(deps.fs, context.taskRepoRoot, index);
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return { status: "disabled", gate, record: index.gates[gate], message: "Gate review is disabled." };
         }
         if (!record.required) {
@@ -130,6 +131,7 @@ export function createGateReviewService(deps) {
                 error: undefined
             }, now());
             await saveIndex(deps.fs, context.taskRepoRoot, index);
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return { status: "not_required", gate, record: index.gates[gate], message: "This gate is not required." };
         }
         if (index.activeGate && index.activeGate !== gate) {
@@ -348,6 +350,7 @@ export function createGateReviewService(deps) {
             && record.status === "completed"
             && record.decision === "approve"
             && record.inputHash === inputHash) {
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return {
                 status: "already_approved",
                 gate,
@@ -359,6 +362,7 @@ export function createGateReviewService(deps) {
         const requestId = createRequestId(gate);
         const requestPath = path.posix.join(REQUESTS_DIR, `${requestId}.json`);
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
+        const requestReportPath = reportPathForRequest(requestId);
         const nextRecord = {
             ...record,
             status: "running",
@@ -402,10 +406,12 @@ export function createGateReviewService(deps) {
             codeDiffSource,
             codeDiffSources,
             codeDiff: codeDiffInput,
-            reportPath: nextRecord.reportPath,
+            reportPath: requestReportPath,
+            latestReportPath: nextRecord.reportPath,
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
+        await notifyArchitecturePlanDisposition(context, gate, false);
         void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources).catch(() => {
             // runGateReview records failures in the persisted gate state.
         });
@@ -456,11 +462,15 @@ export function createGateReviewService(deps) {
                 eventName: "UserPromptSubmit"
             });
             const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs);
+            await publishLatestGateReport(deps.fs, context.taskRepoRoot, gate, parsed.content);
             const completedAt = now();
             await updateRequestStatus(deps.fs, context, requestId, "completed", {
                 completedAt,
                 decision: parsed.decision,
-                reportPath: parsed.reportPath
+                summary: parsed.summary,
+                findings: parsed.findings,
+                reportPath: parsed.reportPath,
+                latestReportPath: reportPathForGate(gate)
             });
             activeRuns.delete(runKey);
             await updateGateRecord(context, gate, {
@@ -474,6 +484,7 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: completedAt
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, parsed.decision === "approve");
             await callbackProjectManager(context, gate, "completed", parsed.decision, parsed.reportPath);
         }
         catch (error) {
@@ -492,7 +503,8 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: timestamp
             }, { clearActiveGate: true });
-            await callbackProjectManager(context, gate, "failed", undefined, reportPathForGate(gate), message);
+            await notifyArchitecturePlanDisposition(context, gate, false);
+            await callbackProjectManager(context, gate, "failed", undefined, reportPathForRequest(requestId), message);
         }
         finally {
             activeRuns.delete(runKey);
@@ -570,6 +582,21 @@ export function createGateReviewService(deps) {
             });
         }
     }
+    async function notifyArchitecturePlanDisposition(context, gate, accepted) {
+        if (gate !== "architecture-plan" || !deps.onArchitecturePlanDisposition) {
+            return;
+        }
+        try {
+            await deps.onArchitecturePlanDisposition({
+                repoRoot: context.repoRoot,
+                taskSlug: context.taskSlug,
+                accepted
+            });
+        }
+        catch {
+            // Gate state remains authoritative even if the deferred session restart cannot run yet.
+        }
+    }
     return {
         async getState(repoRoot, taskSlug) {
             const context = await getContext(repoRoot, taskSlug);
@@ -628,6 +655,7 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: now()
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "skipped", undefined, index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
         },
@@ -653,12 +681,13 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: now()
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "overridden", "approve", index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
         },
         async readReport(repoRoot, taskSlug, gate) {
             const context = await getContext(repoRoot, taskSlug);
-            return parseGateReport(deps.fs, context.taskRepoRoot, gate, undefined, now());
+            return parseGateReport(deps.fs, context.taskRepoRoot, gate, undefined, now(), reportPathForGate(gate));
         }
     };
 }
@@ -985,10 +1014,12 @@ async function readArchitectureBriefError(fs, taskRepoRoot) {
     const content = await fs.readText(absolutePath);
     const check = checkMarkdownArtifact("architecture-brief", relativePath, content);
     if (check.status !== "ok") {
-        return `${relativePath} is incomplete. Complete and confirm Architect Interview before requesting architecture-plan review.`;
+        return `${relativePath} is incomplete and cannot start architecture-plan review. ${formatArtifactCheckFailure(check)}`;
     }
-    if (!/^\s*Architecture Brief Status\s*:\s*confirmed\s*$/im.test(content)) {
-        return `${relativePath} is not confirmed. Obtain explicit user confirmation before architecture planning.`;
+    const status = /^\s*Architecture Brief Status\s*:\s*(.+?)\s*$/im.exec(content)?.[1]?.trim();
+    if (status?.toLowerCase() !== "confirmed") {
+        return `${relativePath} is not confirmed and cannot start architecture-plan review. `
+            + `Architecture Brief Status must be exactly "confirmed"; found ${renderFoundValue(status)}.`;
     }
     return undefined;
 }
@@ -1003,12 +1034,8 @@ async function readValidationReportError(fs, taskRepoRoot) {
     if (check.status === "ok") {
         return undefined;
     }
-    const details = [
-        check.missingHeadings.length > 0 ? `missing headings: ${check.missingHeadings.join(", ")}` : "",
-        check.invalidFields.length > 0 ? check.invalidFields.join(" ") : "",
-        check.hasPlaceholder ? "contains placeholders" : ""
-    ].filter(Boolean).join("; ");
-    return `${relativePath} is incomplete and cannot start validation-adequacy review.${details ? ` ${details}` : ""}`;
+    return `${relativePath} is incomplete and cannot start validation-adequacy review. `
+        + formatValidationArtifactFailure(check, content);
 }
 async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
@@ -1020,8 +1047,10 @@ async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     if (content.trim().length === 0) {
         return `${relativePath} is empty. Complete architecture evidence before requesting architecture-plan review.`;
     }
-    if (!/^\s*Architecture Evidence Status\s*:\s*complete\s*$/im.test(content)) {
-        return `${relativePath} is incomplete. Finish current-worktree evidence before requesting architecture-plan review.`;
+    const status = /^\s*Architecture Evidence Status\s*:\s*(.+?)\s*$/im.exec(content)?.[1]?.trim();
+    if (status?.toLowerCase() !== "complete") {
+        return `${relativePath} is incomplete and cannot start architecture-plan review. `
+            + `Architecture Evidence Status must be exactly "complete"; found ${renderFoundValue(status)}.`;
     }
     return undefined;
 }
@@ -1036,7 +1065,7 @@ function splitLines(value) {
         .filter(Boolean);
 }
 function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources) {
-    const reportPath = reportPathForGate(gate);
+    const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
     const evidence = getSourceArtifacts(gate, codeDiffSources)
         .map((relativePath) => `- ${relativePath}`)
@@ -1089,9 +1118,10 @@ Summary: <one or two sentences>
 [/VCM GATE REVIEW]`;
 }
 async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
+    const reportPath = reportPathForRequest(requestId);
     while (true) {
         try {
-            return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp);
+            return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath);
         }
         catch (error) {
             if (!isPendingReportError(error)) {
@@ -1101,8 +1131,7 @@ async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, i
         await delay(intervalMs);
     }
 }
-async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
-    const reportPath = reportPathForGate(gate);
+async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath) {
     const absolutePath = resolveRepoPath(taskRepoRoot, reportPath);
     if (!(await fs.pathExists(absolutePath))) {
         throw new VcmError({
@@ -1231,18 +1260,35 @@ async function validateValidationApprovalInput(fs, taskRepoRoot) {
     if (check.status === "ok") {
         return;
     }
-    const details = [
-        `status=${check.status}`,
-        check.missingHeadings.length > 0 ? `missing headings: ${check.missingHeadings.join(", ")}` : "",
-        check.invalidFields.length > 0 ? check.invalidFields.join(" ") : "",
-        check.hasPlaceholder ? "contains placeholders" : ""
-    ].filter(Boolean).join("; ");
     throw new VcmError({
         code: "GATE_REVIEW_VALIDATION_INPUT_INCOMPLETE",
-        message: `Validation-adequacy cannot approve incomplete Tester evidence in ${relativePath}. ${details}`,
+        message: `Validation-adequacy cannot approve incomplete Tester evidence in ${relativePath}. `
+            + formatValidationArtifactFailure(check, content),
         statusCode: 500
     });
 }
+function formatValidationArtifactFailure(check, content) {
+    return /^\s*Test Result\s*:\s*incomplete\s*$/im.test(content ?? "")
+        ? 'Test Result must be exactly one of "pass|fail"; found "incomplete".'
+        : formatArtifactCheckFailure(check);
+}
+function formatArtifactCheckFailure(check) {
+    const details = [
+        check.status === "missing" ? "Artifact is missing." : "",
+        check.status === "empty" ? "Artifact is empty." : "",
+        check.missingHeadings.length > 0
+            ? `Missing headings: ${check.missingHeadings.join(", ")}.`
+            : "",
+        ...check.invalidFields,
+        check.hasPlaceholder ? "Replace every standalone TBD, Not run yet, or draft-status placeholder." : ""
+    ].filter(Boolean);
+    return details.length > 0
+        ? details.join(" ")
+        : "Artifact is not in a gate-ready terminal state.";
+}
+function renderFoundValue(value) {
+    return value && value.trim().length > 0 ? JSON.stringify(value.trim()) : "<missing>";
+}
 function validateRequestChangeFindings(findings) {
     if (findings.length === 0) {
         throw new VcmError({
@@ -1296,9 +1342,20 @@ async function updateRequestStatus(fs, context, requestId, status, patch) {
         updatedAt: new Date().toISOString()
     });
 }
+async function publishLatestGateReport(fs, taskRepoRoot, gate, content) {
+    const latestPath = resolveRepoPath(taskRepoRoot, reportPathForGate(gate));
+    if (fs.writeTextAtomic) {
+        await fs.writeTextAtomic(latestPath, content);
+        return;
+    }
+    await fs.writeText(latestPath, content);
+}
 function reportPathForGate(gate) {
     return path.posix.join(GATE_REVIEW_DIR, `${gate}-review.md`);
 }
+function reportPathForRequest(requestId) {
+    return path.posix.join(REQUESTS_DIR, `${requestId}.report.md`);
+}
 function promptPathForRequest(requestId) {
     return path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
 }

package/dist/backend/templates/handoff.js

@@ -1,7 +1,8 @@
+import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_RESULTS, renderArtifactOptions } from "../../shared/validation/artifact-contract.js";
 export function renderArchitectureBriefTemplate(taskSlug) {
     return `# Architecture Brief: ${taskSlug}
 
-Architecture Brief Status: interviewing|confirmed
+Architecture Brief Status: ${renderArtifactOptions(ARCHITECTURE_BRIEF_STATUSES)}
 
 ## Accepted Outcome
 
@@ -17,7 +18,7 @@ TBD
 
 ## Unresolved User Decisions
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## User Confirmation
 
@@ -27,7 +28,7 @@ TBD
 export function renderArchitecturePlanTemplate(taskSlug) {
     return `# Architecture Plan: ${taskSlug}
 
-Planning Result: complete|incomplete|user clarification required
+Planning Result: ${renderArtifactOptions(ARCHITECTURE_PLAN_RESULTS)}
 
 ## Accepted Scope
 
@@ -100,10 +101,13 @@ TBD
 Task-specific context and coder guidance go here, not in source-code comments.
 Source-code comments should only describe durable behavior, contracts, invariants,
 error boundaries, or non-obvious logic that should remain useful after this task.
+Use an ID matching \`[A-Z]{2,6}-[0-9]{1,4}\`, choose exactly one Action
+(\`create\`, \`change\`, or \`delete\`), put the repo-relative File path in
+backticks, and enumerate every implementation item explicitly.
 
 | ID | Action | File | Symbol Or Site | Coder Work | Allowed Implementation Freedom | Behavior / Contract Proof Point |
 | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| <ID> | <create|change|delete> | \`<repo-relative-file>\` | TBD | TBD | TBD | TBD |
 
 ## Scaffold Build Evidence
 
@@ -143,7 +147,7 @@ At task close, promote still-relevant confirmed issues to \`docs/known-issues.md
 export function renderTestReportTemplate(taskSlug) {
     return `# Test Report: ${taskSlug}
 
-Test Result: pass|fail
+Test Result: ${renderArtifactOptions(TEST_RESULTS)}
 
 ## Evidence Reviewed
 
@@ -157,9 +161,19 @@ TBD
 
 TBD
 
+## Validation Progress
+
+### Completed Validation
+
+TBD
+
+### Remaining Validation
+
+${STRICT_NONE_VALUE}
+
 ## L3 Coverage
 
-L3 Required: yes|no
+L3 Required: ${renderArtifactOptions(L3_REQUIRED_VALUES)}
 
 ### Trigger Assessment
 
@@ -169,7 +183,7 @@ TBD
 
 | Flow | Trigger | Case ID | Test File | Entry Point | Final Observable Result | Action | Result |
 | --- | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| TBD | TBD | TBD | TBD | TBD | TBD | <${renderArtifactOptions(L3_ACTIONS)}> | TBD |
 
 ### L3 Commands And Evidence
 
@@ -189,27 +203,27 @@ TBD
 
 ## Failed Expectations
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Reproduction Steps
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Skipped Checks With Reasons
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Coverage Gaps
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Blocking Validation Issues
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## User Approval Evidence
 
-TBD
+${STRICT_NONE_VALUE}
 `;
 }
 export function renderCoderCompletionTemplate(taskSlug) {
@@ -338,7 +352,7 @@ TBD
 
 ## Decision
 
-TBD
+${renderArtifactOptions(DOCS_SYNC_DECISIONS)}
 `;
 }
 export function renderFinalAcceptanceTemplate(taskSlug) {
@@ -346,7 +360,7 @@ export function renderFinalAcceptanceTemplate(taskSlug) {
 
 ## Decision
 
-TBD
+${renderArtifactOptions(FINAL_ACCEPTANCE_DECISIONS)}
 
 ## Evidence Reviewed
 

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

@@ -78,7 +78,7 @@ ${renderRoleMemoryRules("architect")}
 - \`Architecture Decision\`: use the required Changed Behavior Flow, Ownership, Data Flow, Lifecycle, Boundaries, Invariants, Failure Model, and Decision Rationale subsections. Describe why the design fits verified current code.
 - \`Module/File Plan\`: list each affected module, changed or created file, file responsibility, why it is in scope, expected change, dependency direction, user-visible behavior change, durable comment needs, and every non-private callable surface intended for use outside its file. For every ledger item that consumes or sources cross-module data, name the module and symbol that owns or produces the data, trace the source-to-consumer path, and identify every field, parameter, accessor, trait method, command field, dependency, or other cross-file surface required by that path.
 - \`Public Surface Impact\`: state changed APIs, routes, commands, events, exports, storage formats, configuration, UI behavior, visibility changes, side effects, error boundaries, expected callers, or explicitly state none.
-- \`Scaffold Manifest\`: an item ledger — one entry per implementation item. An item is one of: a created body or surface (\`create\`), one required change site — one contiguous edit region inside an existing body or surface (\`change\`), or one deletion of a body, site, or file (\`delete\`). An item not in the ledger is not in the plan; coder must not implement it.
+- \`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.
 - 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.
@@ -116,7 +116,7 @@ ${renderRoleMemoryRules("architect")}
 #### Planning Completion
 
 - After the complete plan, scaffold, reconciliation, L0 evidence, and commits are ready, use the \`restart-architect\` skill before writing the completed Architect-to-PM route message.
-- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. Do not wait for or inspect the replacement session.
+- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. VCM keeps this session for any architecture-plan Gate revision and restarts it only after the Gate is accepted. Do not wait for or inspect the replacement session.
 
 ### Complete Task Planning
 

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

@@ -46,7 +46,18 @@ ${renderRoleMemoryRules("coder")}
 - Use workers when the task has at least 20 \`VCM:CODE\` markers and the marker distribution can form at least two worker-sized groups.
 - Under a complete scaffold, marker implementations are order-independent — signatures, types, and cross-item contracts are frozen by the scaffold — so never serialize worker-sized groups for presumed implementation-order dependencies. When a group's module-scoped checks need peers that are still unimplemented, narrow that worker's assigned validation scope instead of serializing.
 - An item counts as blocked only when a genuine implementation attempt has produced objective compile/check evidence already reported under the failure rules; prediction never blocks an item. A blocked marker item never exempts the remaining markers from worker dispatch.
-- Before invoking workers, count \`VCM:CODE\` markers by module and create one runtime state file per worker under \`.ai/vcm/coder-workers/tasks/<worker-id>.json\` with \`status: running\`.
+- Before invoking workers, count \`VCM:CODE\` markers by module and create one runtime state file per worker under \`.ai/vcm/coder-workers/tasks/<worker-id>.json\` with exactly this initial shape:
+
+\`\`\`json
+{
+  "workerId": "<worker-id>",
+  "status": "running",
+  "reportPath": ".ai/vcm/coder-workers/reports/<worker-id>.md",
+  "handled": false
+}
+\`\`\`
+
+- After a worker completes, its state must retain those fields, set \`status\` to \`completed\`, and add the exact \`commitHash\` from its report. Only Coder changes \`handled\` to \`true\` after inspecting that report and commit.
 - Create one worker task for each module with more than 10 \`VCM:CODE\` markers.
 - Group modules with 10 or fewer \`VCM:CODE\` markers into one small-modules worker when their combined marker count is more than 10.
 - If the combined small-module marker count is 10 or fewer, Coder handles those modules directly after worker results return.

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

@@ -14,8 +14,19 @@ You are \`vcm-coder-worker\`, a bounded implementation worker invoked by Coder.
 ### Worker Runtime State
 
 - Worker runtime status is only \`running\` or \`completed\`.
-- Coder creates the assigned worker state with \`status: running\` and assigns its state path and report path.
+- Coder creates the assigned worker state with this exact initial shape:
+
+\`\`\`json
+{
+  "workerId": "<worker-id>",
+  "status": "running",
+  "reportPath": ".ai/vcm/coder-workers/reports/<worker-id>.md",
+  "handled": false
+}
+\`\`\`
+
 - After the sweep of assigned items and their assigned checks, commit the assigned files. After the commit succeeds, write the assigned report with the commit hash and \`Implementation Result: success|has_failed_items\`, then update only the assigned worker state to \`completed\` with the same \`commitHash\` as the final step.
+- The completed state must retain \`workerId\`, \`reportPath\`, and \`handled: false\`, set \`status\` to \`completed\`, and add \`"commitHash": "<exact-report-commit-hash>"\`.
 - Use \`completed\` only after every assigned item reached a terminal state. A successful item has green assigned proof and its marker removed. A failed item has a genuine attempt committed with objective failure evidence and its marker retained. Use \`success\` only when every item succeeded; otherwise use \`has_failed_items\`.
 - If execution is interrupted before the sweep, commit, or report completes, leave the worker state as \`running\`. Coder must resume the worker or take over the remaining work.
 - Do not set \`handled: true\`; only Coder may do that after reviewing and integrating the worker result.

package/dist/backend/templates/harness/gate-review.js

@@ -135,6 +135,10 @@ when the active flow produced an architecture plan. Read
 When the report contains an approved Coverage Gap, also read the relevant
 Architect Debug and Architecture Diagnosis evidence.
 
+Validation-adequacy reviews only a terminal \`Test Result: pass|fail\`.
+\`Test Result: incomplete\` is Tester continuation state and must not enter this
+gate.
+
 Reconstruct the accepted validation target, observable behavior, and risks
 from the active flow evidence and current implementation. Treat Tester
 conclusions, green commands, and
@@ -460,7 +464,7 @@ Use this skill at every project-manager Gate Review trigger point and whenever V
 ## Trigger Points
 
 - \`architecture-plan\`: after the user confirms \`.ai/vcm/handoffs/architecture-brief.md\` and architect writes \`.ai/vcm/handoffs/architecture-plan.md\`, before coder dispatch.
-- \`validation-adequacy\`: after tester writes \`.ai/vcm/handoffs/test-report.md\`, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion.
+- \`validation-adequacy\`: after tester writes a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion. Never request this gate for \`Test Result: incomplete\`.
 - \`code-diff\`: after Coder returns \`Decision: ready_for_review\`, Architect Debug Mode completes a code fix, or Architecture Diagnosis Mode completes a code fix, before PM routes to Tester. Identify the source with \`--source coder\`, \`--source architect-debug\`, or \`--source architect-diagnosis\`.
 
 ## Request
@@ -508,7 +512,7 @@ from pathlib import Path
 
 GATES = ("architecture-plan", "validation-adequacy", "code-diff")
 CODE_DIFF_SOURCES = ("coder", "architect-debug", "architect-diagnosis")
-REPORTS = {
+LATEST_REPORTS = {
     "architecture-plan": ".ai/vcm/gate-reviews/architecture-plan-review.md",
     "validation-adequacy": ".ai/vcm/gate-reviews/validation-adequacy-review.md",
     "code-diff": ".ai/vcm/gate-reviews/code-diff-review.md",
@@ -931,13 +935,14 @@ def local_request(gate: str, source: str | None) -> int:
         and gate_record.get("decision") == "approve"
         and gate_record.get("inputHash") == current_hash
     ):
-        print_result("already_approved", gate=gate, report=gate_record.get("reportPath", REPORTS[gate]))
+        print_result("already_approved", gate=gate, report=gate_record.get("reportPath", LATEST_REPORTS[gate]))
         return 0
 
     rid = request_id(gate)
     request_path = root / ".ai/vcm/gate-reviews/requests" / f"{rid}.json"
     prompt_path = f".ai/vcm/gate-reviews/requests/{rid}.prompt.md"
-    report_path = REPORTS[gate]
+    report_path = f".ai/vcm/gate-reviews/requests/{rid}.report.md"
+    latest_report_path = LATEST_REPORTS[gate]
     requested_at = now_iso()
     write_json(request_path, {
         "version": 1,
@@ -950,6 +955,7 @@ def local_request(gate: str, source: str | None) -> int:
         "codeDiffSources": sources,
         "codeDiff": code_diff or None,
         "reportPath": report_path,
+        "latestReportPath": latest_report_path,
         "promptPath": prompt_path,
     })
 
@@ -959,7 +965,7 @@ def local_request(gate: str, source: str | None) -> int:
         "required": True,
         "status": "running",
         "decision": None,
-        "reportPath": report_path,
+        "reportPath": latest_report_path,
         "promptPath": prompt_path,
         "inputHash": current_hash,
         "baseCommit": code_diff.get("baseCommit"),

package/dist/backend/templates/harness/project-manager-agent.js

@@ -93,6 +93,7 @@ PM may leave this path only through the allowed branches below.
 - **Coder Continuation:** If Coder returns \`Decision: incomplete\`, lacks the required completion artifact, or has not completed implementation and L0/L1 validation, route Coder again — this is the only route for an in-progress sweep. Problems recorded inside an incomplete report are sweep state, not routable failures; PM routes problems onward only from a post-sweep \`failed\` report carrying the consolidated per-item disposition.
 - **Coder Failure Debug:** If Coder returns \`Decision: failed\` with compile, typecheck, or L0/L1 failure evidence after implementation, suspend the main flow and enter Architect Debug Branch.
 - **Code-Diff Correction:** If the code-diff Gate returns \`request_changes\`, suspend the main flow and enter Architect Debug Branch with the Gate report.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation. Do not enter Debug, Diagnosis, or validation-adequacy Gate Review.
 - **Tester Failure:** If Tester returns \`Test Result: fail\` for the original Coder implementation, enter Architect Debug Branch.
 - **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester, then rerun the validation-adequacy Gate after Tester updates the tests or test report.
 - **Docs Sync Correction:** \`Decision: synced\` or \`unchanged\` continues to Final Acceptance. \`Decision: blocked\` remains at docs sync unless the report identifies an allowed Debug, Diagnosis, or user-decision branch.
@@ -151,6 +152,7 @@ The shared path is:
 
 - **Normal Plan Required:** If Architect returns \`normal architecture plan required\`, enter Code-Change Flow at Architect planning. When Debug is a branch of Code-Change Flow, resume that parent flow at Architect planning.
 - **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architect Debug Mode and rerun \`code-diff --source architect-debug\` after correction.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Architecture Diagnosis:** If Tester returns \`Test Result: fail\`, enter Architecture Diagnosis Branch.
 
 #### Successful Exit
@@ -180,6 +182,7 @@ Architecture Diagnosis Mode must run before another Debug Mode fix or Coder disp
 #### Allowed Branches
 
 - **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architecture Diagnosis Mode and rerun \`code-diff --source architect-diagnosis\` after correction.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Tester Failure:** If Tester returns \`Test Result: fail\` for the Diagnosis implementation, pause and report to the user. If required validation remains unavailable, ask whether the user explicitly approves retaining that exact Coverage Gap.
 
 #### Successful Exit
@@ -242,7 +245,7 @@ The flow is:
 
 \`Tester validation and test update -> validation-adequacy Gate -> PM completion\`
 
-Tester must complete the accepted validation work, write \`.ai/vcm/handoffs/test-report.md\`, and return \`Test Result: pass|fail\`.
+Tester must write \`.ai/vcm/handoffs/test-report.md\` and return \`Test Result: pass|fail|incomplete\`.
 
 If Tester changes tests, fixtures, test-only helpers, or \`docs/TESTING.md\`, Tester must commit those changes and record the changed files and commit in \`test-report.md\`.
 
@@ -252,7 +255,7 @@ PM may leave this path only through the allowed branches below.
 
 #### Allowed Branches
 
-- **Tester Continuation:** If the assigned validation work or test report is incomplete, route Tester again.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester and rerun the Gate after correction.
 - **Code Change Required:** If the accepted outcome requires production-code, runtime-behavior, public-contract, dependency, or system-architecture changes, enter Code-Change Flow at Architect planning.
 - **User Decision:** If validation requires missing user intent, credentials, environment access, sensitive data, real cost, or external authorization, pause and ask the user.
@@ -321,6 +324,7 @@ PM may lightly rewrite the user's words to:
 - In an Architect Debug Branch or Architecture Diagnosis Branch, track the parent flow, resume point, Architect result, test report, and required Gate Review results. Do not require a branch-level final acceptance report.
 - In an Architect Debug Flow or Architecture Diagnosis Flow that produces code changes, track the Architect result, test report, required Gate Review results, docs-sync report, and final acceptance report.
 - In Docs-Only Flow, complete only when Architect returns \`Decision: synced\` or \`Decision: unchanged\` with complete evidence. In Validation-Only Flow, complete only from a complete \`test-report.md\` after the validation-adequacy Gate finishes successfully.
+- A Tester \`Test Result: incomplete\` is continuation state, not failure evidence. Route Tester again and do not run validation-adequacy Gate Review or Final Acceptance from it.
 - The Architect does not begin planning until \`architecture-brief.md\` is confirmed (this happens inside the same Architect Interview-and-planning turn, not a separate PM route). Advance to the next gate only when the required role artifact/result is complete and PM routing rules allow that gate.
 - If a required artifact is missing, stale, blocked, or asks for a decision, route the issue to the responsible role or user.
 - In Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes, request Architect post-validation docs sync after Tester completes. Architect Debug Branch and Architecture Diagnosis Branch return to their recorded resume points after Tester passes.
@@ -329,7 +333,7 @@ PM may lightly rewrite the user's words to:
 
 - Gate Review requests are mandatory and unconditional. At every trigger point, use the \`vcm-gate-review\` skill to run \`.ai/tools/request-gate-review\` with the matching gate and code source arguments without first judging whether Gate Review is enabled. The tool (via VCM) is the single source of truth for enable state; never skip the run because you assume Gate Review is off or because the worktree has no gate-review index yet.
 - The tool's first output line decides the next step: \`disabled\`, \`not_required\`, or \`already_approved\` continue the normal VCM flow; \`started\` or \`running\` stop the turn and wait for the VCM callback; \`failed_to_start\` is a hard stop — report it to the user and do not silently proceed past the gate.
-- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion, run \`validation-adequacy\`; after any Coder \`Decision: ready_for_review\` result run \`code-diff --source coder\`; after any Architect Debug Mode completed code fix run \`code-diff --source architect-debug\`; after any Architecture Diagnosis Mode completed code fix run \`code-diff --source architect-diagnosis\`. Run code-diff before routing to Tester.
+- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; after Tester returns a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion, run \`validation-adequacy\`; after any Coder \`Decision: ready_for_review\` result run \`code-diff --source coder\`; after any Architect Debug Mode completed code fix run \`code-diff --source architect-debug\`; after any Architecture Diagnosis Mode completed code fix run \`code-diff --source architect-diagnosis\`. Never run validation-adequacy for \`Test Result: incomplete\`. Run code-diff before routing to Tester.
 - PM does not inspect commits or decide whether code changes exist. At a \`code-diff\` trigger point, run the tool; the tool decides \`disabled\`, \`not_required\`, \`already_approved\`, or starts review.
 - Do not run \`code-diff\` for incomplete, failed, planning-only, Docs-Only Flow, Validation-Only Flow, PR-Preparation Flow, or Communication-Only Flow.
 - Gate Review trigger points apply only when the active delivery flow reaches that milestone. Do not run Gate Review for Communication-Only Flow.

package/dist/backend/templates/harness/restart-architect-skill.js

@@ -9,7 +9,7 @@ Run:
 .ai/tools/request-architect-restart
 \`\`\`
 
-If VCM reports \`scheduled\`, write the completed Architect-to-PM route message and end the turn. VCM restarts Architect only after the route is accepted by PM.
+If VCM reports \`scheduled\`, write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session through any architecture-plan Gate revision rounds and restarts it only after the route is accepted by PM and that Gate is approved or explicitly excepted.
 
 Do not use this skill for incomplete planning, user clarification, Debug Mode, Architecture Diagnosis Mode, or docs sync.`;
 }

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

@@ -26,7 +26,7 @@ ${renderRoleMemoryRules("tester")}
 - Do not treat "looks normal", "no error", log absence, or implementation reasoning as validation evidence.
 - Coder may write and run L0/L1 baseline tests during implementation, but Tester owns final test adequacy for all validation levels.
 - Review Coder-provided L0/L1 evidence and changed unit tests against \`docs/CODING_STANDARDS.md\`; confirm changed callable units have required success, failure, boundary, validation, branching, error-handling, lifecycle, retry, or state-transition coverage.
-- If required L0/L1 coverage is missing or weak, add or update the required tests. If the coverage cannot be completed, return \`Test Result: fail\` with concrete blocking evidence.
+- If required L0/L1 coverage is missing or weak, add or update the required tests. If the current turn ends while that work can continue in another Tester turn and no blocking issue has been found, return \`Test Result: incomplete\` with completed and remaining validation. If Tester continuation cannot resolve the missing coverage, return \`Test Result: fail\` with concrete blocking evidence.
 - Own L2/L3/L4 final-validation design, execution, and acceptance evidence.
 - Targeted diagnostic L2 checks run by Coder or Architect are implementation evidence only and do not replace Tester final validation.
 - Use L2 integration coverage when changed behavior crosses internal module or component boundaries and can be completely proved from a stable integration entry point without triggering the mandatory L3 rules below.
@@ -53,7 +53,8 @@ ${renderRoleMemoryRules("tester")}
 - Before exact user approval is routed by project-manager, record missing required coverage under \`Blocking Validation Issues\`, keep \`Coverage Gaps\` as \`None\`, and return \`Test Result: fail\`.
 - Add a Coverage Gap only after project-manager routes the user's exact approval for that specific unresolved gap. Record the approval verbatim in \`User Approval Evidence\`.
 - User approval permits the gap to remain and the workflow to continue; it does not change the factual \`Test Result: fail\`.
-- If a required validation check is skipped or cannot complete, \`Test Result\` must be \`fail\`.
+- If the current turn ends before required validation finishes, use \`Test Result: incomplete\` only when no blocking issue has been found and Tester can continue the remaining checks in another turn.
+- A required check that fails, is skipped, or cannot be completed by Tester continuation is a blocking validation issue and requires \`Test Result: fail\`.
 - Update \`docs/TESTING.md\` when validation strategy, commands, level mapping, integration/E2E case definitions, selection rules, final-validation cleanup, test gaps, or test expectations change.
 
 ### Mandatory L3 End-To-End Coverage
@@ -125,7 +126,7 @@ Coverage Gap.
 
 ### Outputs
 
-- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail\`, evidence reviewed, tests added or updated, coverage mapping, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
 - \`test-report.md\` must include this L3 section:
 
 \`\`\`md
@@ -150,12 +151,15 @@ L3 Required: yes|no
 - In Validation-Only Flow, if tests, fixtures, test-only helpers, or \`docs/TESTING.md\` changed, commit those changes before reporting and record the changed files and commit in \`test-report.md\`. If no tracked files changed, record that no commit was required.
 - \`test-report.md\` is the current validation evidence, not a log; when rewriting it, carry forward still-unresolved findings or explicitly mark them resolved instead of dropping them.
 - In \`Coverage Mapping\`, map each accepted changed behavior or relevant risk to its validation level, actual test file and case or external evidence, exercised entry path and key assertions, result, and any remaining gap.
+- In \`Validation Progress\`, record \`Completed Validation\` and \`Remaining Validation\`. A final \`pass\` report must set remaining validation to \`None\`.
 - Use \`pass\` only when required validation completed and no blocking test failure, missing required coverage, unacceptable test weakness, or unresolved validation risk remains.
-- Use \`fail\` when tests fail, coverage is insufficient, important validation cannot complete, test quality is unacceptable, or validation risk needs project-manager routing.
-- When \`Test Result: pass\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
+- Use \`fail\` only when tests fail, coverage is insufficient and Tester continuation cannot resolve it, required validation is blocked from completion, test quality is unacceptable, or validation risk needs project-manager routing.
+- Use \`incomplete\` only when required validation remains, no blocking issue has been found, and another Tester turn can continue the recorded remaining work.
+- When \`Test Result: pass\`, the entire body of \`Remaining Validation\`, \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be exactly \`None.\` with no additional text.
+- When \`Test Result: incomplete\`, \`Completed Validation\` and \`Remaining Validation\` must both contain concrete progress, while the entire body of \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be exactly \`None.\` with no additional text.
 - When \`Test Result: fail\`, \`Blocking Validation Issues\` must list concrete blocking evidence.
 - When \`Coverage Gaps\` is not \`None\`, \`Test Result\` must be \`fail\`, \`User Approval Evidence\` must contain the user's exact authorization, and every recorded gap must match that authorization.
-- When no gap has been approved, \`User Approval Evidence\` must be \`None\`.
+- When no gap has been approved, the entire \`User Approval Evidence\` section must be exactly \`None.\` with no additional text.
 - For feature or cross-boundary changes, map required L2 integration coverage and mandatory L3 coverage separately. If required coverage is unavailable, report it as a blocking issue.
 - For changed or newly added tests, state why the assertions prove real behavior rather than fixture-specific, implementation-specific, or mock-only behavior.
 - Report confirmed unresolved issues that should survive current-task cleanup in \`.ai/vcm/handoffs/test-report.md\`; do not write \`.ai/vcm/handoffs/known-issues.md\` (architect-owned).

package/dist/backend/templates/harness/vcm-architecture-interview-skill.js

@@ -65,14 +65,14 @@ Architecture Brief Status: interviewing|confirmed
 
 ## Unresolved User Decisions
 
-...
+None.
 
 ## User Confirmation
 
 ...
 \`\`\`
 
-Record concise confirmed requirements and constraints. Tag each entry under Confirmed User Decisions with its provenance and depth — [user-stated | architect-proposed, user-approved | architect-inferred] and [intent-level | mechanism-level] — and record the user's real input faithfully as a short summary; never present an architect inference as a user requirement. Record correctness-critical mechanism choices surfaced during the interview with their options, your recommendation, the user's decision, and the rejected alternative, so later stages can tell a chosen mechanism from an inferred one. Keep this to decisions and their provenance — not a full implementation design, and not a transcript. Use \`None\` under Unresolved User Decisions only when no user-owned decision remains.
+Record concise confirmed requirements and constraints. Tag each entry under Confirmed User Decisions with its provenance and depth — [user-stated | architect-proposed, user-approved | architect-inferred] and [intent-level | mechanism-level] — and record the user's real input faithfully as a short summary; never present an architect inference as a user requirement. Record correctness-critical mechanism choices surfaced during the interview with their options, your recommendation, the user's decision, and the rejected alternative, so later stages can tell a chosen mechanism from an inferred one. Keep this to decisions and their provenance — not a full implementation design, and not a transcript. When no user-owned decision remains, the entire Unresolved User Decisions section must be exactly \`None.\` with no additional text.
 
 Maintain the evidence artifact with this structure:
 

package/dist/backend/templates/harness/vcm-final-acceptance-skill.js

@@ -30,7 +30,7 @@ Check whether the required role evidence exists, is current, and gives a clear r
 Acceptable evidence must show:
 
 - architect plan, architecture diagnosis, or docs-sync decision when required by the completed flow
-- tester \`Test Result: pass|fail\` and validation evidence when code, behavior, tests, or generated context changed
+- tester terminal \`Test Result: pass|fail\` and validation evidence when code, behavior, tests, or generated context changed; \`incomplete\` is not acceptance evidence
 - required Gate Review decisions, skip reasons, or override reasons when Gate Reviews were enabled
 - known-issues disposition when unresolved findings were recorded
 - explicit user approval for accepted high-risk decisions or intentionally skipped required gates
@@ -58,7 +58,7 @@ Check:
 - required route was followed, or an explicit user-approved exception is recorded
 - required handoff artifacts exist and are current
 - architecture plan, Architecture Diagnosis, Replan, or architect follow-up completion is recorded when required by the flow
-- tester report records \`Test Result: pass|fail\`, validation commands, results, and skipped checks with reasons
+- tester report records terminal \`Test Result: pass|fail\`, validation commands, results, and skipped checks with reasons; do not accept \`Test Result: incomplete\`
 - required Gate Reviews are approved, or skipped/overridden through a VCM-recorded user action
 - Gate Review enable state is confirmed authoritatively: do not infer that no Gate Reviews were required from an absent or empty \`.ai/vcm/gate-reviews/index.json\`. When Gate Review is enabled, a missing index or a required gate without a recorded decision means the gate was skipped — run the matching command from the \`vcm-gate-review\` skill, including the code source for \`code-diff\`, and do not accept until each required gate returns \`approve\`/\`already_approved\`, \`disabled\`/\`not_required\`, or a VCM-recorded user skip/override
 - docs-sync report records docs updated, docs intentionally left unchanged, or required follow-up when docs sync was required
@@ -94,7 +94,7 @@ Use this structure:
 
 ## Decision
 
-accepted | accepted-with-known-risks | needs-coder-follow-up | needs-architect-follow-up | needs-docs-sync | blocked-by-user-decision
+accepted|accepted-with-known-risks|needs-coder-follow-up|needs-architect-follow-up|needs-docs-sync|blocked-by-user-decision
 
 ## Evidence Reviewed
 

package/dist/backend/templates/harness/vcm-route-message-skill.js

@@ -56,9 +56,7 @@ type: task
 workflow_flow: code-change
 workflow_step: coder-implementation
 workflow_status: active
-artifact_refs:
-  - .ai/vcm/handoffs/architecture-plan.md
-  - docs/plans/example.md
+artifact_refs: .ai/vcm/handoffs/architecture-plan.md, docs/plans/example.md
 ---
 
 Summary:
@@ -84,8 +82,7 @@ For non-PM reports, use:
 \`\`\`md
 ---
 type: result
-artifact_refs:
-  - .ai/vcm/handoffs/example.md
+artifact_refs: .ai/vcm/handoffs/example.md
 ---
 
 Summary:

package/dist/shared/validation/artifact-check.js

@@ -1,3 +1,4 @@
+import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_RESULTS } from "./artifact-contract.js";
 const REQUIRED_HEADINGS = {
     "architecture-brief": [
         "Accepted Outcome",
@@ -39,6 +40,9 @@ const REQUIRED_HEADINGS = {
         "Evidence Reviewed",
         "Tests Added Or Updated",
         "Coverage Mapping",
+        "Validation Progress",
+        "Completed Validation",
+        "Remaining Validation",
         "L3 Coverage",
         "Trigger Assessment",
         "Affected End-To-End Flows",
@@ -105,6 +109,8 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
     const missingHeadings = REQUIRED_HEADINGS[kind].filter((heading) => !hasHeading(trimmed, heading));
     const hasPlaceholder = PLACEHOLDER_PATTERN.test(trimmed);
     const invalidFields = validateArtifactFields(kind, trimmed);
+    const isWorkInProgress = kind === "test-report"
+        && /^\s*Test Result\s*:\s*incomplete\s*$/im.test(trimmed);
     return {
         kind,
         path: artifactPath,
@@ -113,45 +119,47 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
         hasPlaceholder,
         missingHeadings,
         invalidFields,
-        status: missingHeadings.length === 0 && !hasPlaceholder && invalidFields.length === 0 ? "ok" : "incomplete"
+        status: missingHeadings.length === 0
+            && !hasPlaceholder
+            && invalidFields.length === 0
+            && !isWorkInProgress
+            ? "ok"
+            : "incomplete"
     };
 }
 function validateArtifactFields(kind, content) {
     if (kind === "architecture-plan") {
-        const result = /^\s*Planning Result\s*:\s*(.+?)\s*$/im.exec(content)?.[1]?.trim().toLowerCase();
-        if (!result) {
-            return ["Planning Result is required and must be complete."];
-        }
-        return result === "complete"
+        const result = readInlineField(content, "Planning Result");
+        return result === ARCHITECTURE_PLAN_RESULTS[0]
             ? []
-            : [`Planning Result must be complete; received "${result}".`];
+            : [renderExactFieldError("Planning Result", [ARCHITECTURE_PLAN_RESULTS[0]], result)];
     }
     if (kind === "architecture-brief") {
-        const status = /^\s*Architecture Brief Status\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
-        const invalidFields = status === "interviewing" || status === "confirmed"
+        const status = readInlineField(content, "Architecture Brief Status");
+        const invalidFields = isAllowedValue(status, ARCHITECTURE_BRIEF_STATUSES)
             ? []
-            : ["Architecture Brief Status must be interviewing or confirmed."];
+            : [renderExactFieldError("Architecture Brief Status", ARCHITECTURE_BRIEF_STATUSES, status)];
         if (status === "confirmed") {
-            const unresolved = readArtifactSectionValue(content, "Unresolved User Decisions");
-            if (!unresolved || !/^none\.?$/i.test(unresolved)) {
-                invalidFields.push("Unresolved User Decisions must be None when Architecture Brief Status is confirmed.");
+            const unresolved = readArtifactSectionContent(content, "Unresolved User Decisions");
+            if (!isExactNone(unresolved)) {
+                invalidFields.push(renderExactSectionError("Unresolved User Decisions", STRICT_NONE_VALUE, unresolved, "when Architecture Brief Status is confirmed"));
             }
         }
         return invalidFields;
     }
     if (kind === "test-report") {
-        const result = /^\s*Test Result\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
-        const invalidFields = result === "pass" || result === "fail"
+        const result = readInlineField(content, "Test Result");
+        const invalidFields = isAllowedValue(result, TEST_RESULTS)
             ? []
-            : ["Test Result must be pass or fail."];
-        const l3Required = /^\s*L3 Required\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
-        if (l3Required !== "yes" && l3Required !== "no") {
-            invalidFields.push("L3 Required must be yes or no.");
+            : [renderExactFieldError("Test Result", TEST_RESULTS, result)];
+        const l3Required = readInlineField(content, "L3 Required");
+        if (!isAllowedValue(l3Required, L3_REQUIRED_VALUES)) {
+            invalidFields.push(renderExactFieldError("L3 Required", L3_REQUIRED_VALUES, l3Required));
         }
-        const l3TriggerAssessment = readArtifactSectionValue(content, "Trigger Assessment");
+        const l3TriggerAssessment = readArtifactSectionContent(content, "Trigger Assessment");
         const l3AffectedFlows = readArtifactSectionContent(content, "Affected End-To-End Flows");
-        const l3Commands = readArtifactSectionValue(content, "L3 Commands And Evidence");
-        const l3NotRequiredEvidence = readArtifactSectionValue(content, "Not-Required Evidence");
+        const l3Commands = readArtifactSectionContent(content, "L3 Commands And Evidence");
+        const l3NotRequiredEvidence = readArtifactSectionContent(content, "Not-Required Evidence");
         if (l3Required === "yes") {
             if (!hasSubstantiveSectionValue(l3TriggerAssessment)) {
                 invalidFields.push("Trigger Assessment is required when L3 Required is yes.");
@@ -166,21 +174,51 @@ function validateArtifactFields(kind, content) {
         if (l3Required === "no" && !hasSubstantiveSectionValue(l3NotRequiredEvidence)) {
             invalidFields.push("Not-Required Evidence is required when L3 Required is no.");
         }
-        const coverageGaps = readArtifactSectionValue(content, "Coverage Gaps");
-        const blockingIssues = readArtifactSectionValue(content, "Blocking Validation Issues");
-        const userApproval = readArtifactSectionValue(content, "User Approval Evidence");
-        const hasCoverageGaps = Boolean(coverageGaps && !/^none\.?$/i.test(coverageGaps));
-        const hasBlockingIssues = Boolean(blockingIssues && !/^none\.?$/i.test(blockingIssues));
-        const hasUserApproval = Boolean(userApproval && !/^none\.?$/i.test(userApproval));
+        const coverageGaps = readArtifactSectionContent(content, "Coverage Gaps");
+        const blockingIssues = readArtifactSectionContent(content, "Blocking Validation Issues");
+        const userApproval = readArtifactSectionContent(content, "User Approval Evidence");
+        const failedExpectations = readArtifactSectionContent(content, "Failed Expectations");
+        const completedValidation = readArtifactSectionContent(content, "Completed Validation");
+        const remainingValidation = readArtifactSectionContent(content, "Remaining Validation");
+        const hasCoverageGaps = hasSubstantiveSectionValue(coverageGaps);
+        const hasBlockingIssues = hasSubstantiveSectionValue(blockingIssues);
+        const hasUserApproval = hasSubstantiveSectionValue(userApproval);
+        const hasFailedExpectations = hasSubstantiveSectionValue(failedExpectations);
         if (result === "pass") {
-            if (!coverageGaps || hasCoverageGaps) {
-                invalidFields.push("Coverage Gaps must be None when Test Result is pass.");
+            if (!isExactNone(coverageGaps)) {
+                invalidFields.push(renderExactSectionError("Coverage Gaps", STRICT_NONE_VALUE, coverageGaps, "when Test Result is pass"));
+            }
+            if (!isExactNone(blockingIssues)) {
+                invalidFields.push(renderExactSectionError("Blocking Validation Issues", STRICT_NONE_VALUE, blockingIssues, "when Test Result is pass"));
+            }
+            if (!isExactNone(userApproval)) {
+                invalidFields.push(renderExactSectionError("User Approval Evidence", STRICT_NONE_VALUE, userApproval, "when Test Result is pass"));
             }
-            if (!blockingIssues || hasBlockingIssues) {
-                invalidFields.push("Blocking Validation Issues must be None when Test Result is pass.");
+            if (!isExactNone(failedExpectations)) {
+                invalidFields.push(renderExactSectionError("Failed Expectations", STRICT_NONE_VALUE, failedExpectations, "when Test Result is pass"));
             }
-            if (!userApproval || hasUserApproval) {
-                invalidFields.push("User Approval Evidence must be None when Test Result is pass.");
+            if (!isExactNone(remainingValidation)) {
+                invalidFields.push(renderExactSectionError("Remaining Validation", STRICT_NONE_VALUE, remainingValidation, "when Test Result is pass"));
+            }
+        }
+        if (result === "incomplete") {
+            if (!hasSubstantiveSectionValue(completedValidation)) {
+                invalidFields.push("Completed Validation must record progress when Test Result is incomplete.");
+            }
+            if (!hasSubstantiveSectionValue(remainingValidation)) {
+                invalidFields.push("Remaining Validation must list continuation work when Test Result is incomplete.");
+            }
+            if (!isExactNone(coverageGaps)) {
+                invalidFields.push(renderExactSectionError("Coverage Gaps", STRICT_NONE_VALUE, coverageGaps, "when Test Result is incomplete"));
+            }
+            if (!isExactNone(blockingIssues)) {
+                invalidFields.push(renderExactSectionError("Blocking Validation Issues", STRICT_NONE_VALUE, blockingIssues, "when Test Result is incomplete"));
+            }
+            if (!isExactNone(userApproval)) {
+                invalidFields.push(renderExactSectionError("User Approval Evidence", STRICT_NONE_VALUE, userApproval, "when Test Result is incomplete"));
+            }
+            if (!isExactNone(failedExpectations)) {
+                invalidFields.push(renderExactSectionError("Failed Expectations", STRICT_NONE_VALUE, failedExpectations, "when Test Result is incomplete"));
             }
         }
         if (result === "fail" && !hasBlockingIssues) {
@@ -195,22 +233,15 @@ function validateArtifactFields(kind, content) {
             }
         }
         else if (hasUserApproval) {
-            invalidFields.push("User Approval Evidence must be None when no Coverage Gaps are recorded.");
+            invalidFields.push(renderExactSectionError("User Approval Evidence", STRICT_NONE_VALUE, userApproval, "when no Coverage Gaps are recorded"));
         }
         return invalidFields;
     }
     if (kind === "docs-sync-report") {
-        return validateDecision(content, ["synced", "unchanged", "blocked"]);
+        return validateDecision(content, DOCS_SYNC_DECISIONS);
     }
     if (kind === "final-acceptance") {
-        return validateDecision(content, [
-            "accepted",
-            "accepted-with-known-risks",
-            "needs-coder-follow-up",
-            "needs-architect-follow-up",
-            "needs-docs-sync",
-            "blocked-by-user-decision"
-        ]);
+        return validateDecision(content, FINAL_ACCEPTANCE_DECISIONS);
     }
     return [];
 }
@@ -221,7 +252,7 @@ function hasCompleteL3FlowMapping(value) {
     if (!value) {
         return false;
     }
-    const allowedActions = new Set(["run-existing", "updated", "added"]);
+    const allowedActions = new Set(L3_ACTIONS);
     return value
         .split(/\r?\n/)
         .map((line) => line.trim())
@@ -234,10 +265,10 @@ function hasCompleteL3FlowMapping(value) {
     });
 }
 function validateDecision(content, allowed) {
-    const decision = readArtifactSectionValue(content, "Decision")?.toLowerCase();
-    return decision && allowed.includes(decision)
+    const decision = readArtifactSectionContent(content, "Decision")?.trim();
+    return decision && allowed.includes(decision.toLowerCase())
         ? []
-        : [`Decision must be one of: ${allowed.join(", ")}.`];
+        : [renderExactSectionError("Decision", allowed.join("|"), decision)];
 }
 export function readArtifactSectionValue(content, heading) {
     return readArtifactSectionContent(content, heading)
@@ -245,7 +276,7 @@ export function readArtifactSectionValue(content, heading) {
         .map((line) => line.trim())
         .find(Boolean);
 }
-function readArtifactSectionContent(content, heading) {
+export function readArtifactSectionContent(content, heading) {
     const match = new RegExp(`^#{1,6}\\s+${escapeRegExp(heading)}\\s*$`, "im").exec(content);
     if (!match || match.index === undefined) {
         return undefined;
@@ -257,6 +288,29 @@ function readArtifactSectionContent(content, heading) {
         : afterHeading.slice(0, nextHeading.index);
     return section.trim();
 }
+function readInlineField(content, field) {
+    return new RegExp(`^\\s*${escapeRegExp(field)}\\s*:\\s*(.+?)\\s*$`, "im")
+        .exec(content)?.[1]?.trim().toLowerCase();
+}
+function isAllowedValue(value, allowed) {
+    return value !== undefined && allowed.includes(value);
+}
+function isExactNone(value) {
+    return value?.trim() === STRICT_NONE_VALUE;
+}
+function renderExactFieldError(field, allowed, found) {
+    return `${field} must be exactly one of "${allowed.join("|")}"; found ${renderFoundValue(found)}.`;
+}
+function renderExactSectionError(section, expected, found, condition) {
+    const suffix = condition ? ` ${condition}` : "";
+    return `${section} must contain exactly "${expected}"${suffix}; found ${renderFoundValue(found)}.`;
+}
+function renderFoundValue(value) {
+    if (value === undefined || value.trim().length === 0) {
+        return "<missing>";
+    }
+    return JSON.stringify(value.trim().replace(/\s+/g, " "));
+}
 function hasHeading(content, heading) {
     const pattern = new RegExp(`^#{1,6}\\s+${escapeRegExp(heading)}\\s*$`, "im");
     return pattern.test(content);

package/dist/shared/validation/artifact-contract.js

@@ -0,0 +1,22 @@
+export const STRICT_NONE_VALUE = "None.";
+export const ARCHITECTURE_BRIEF_STATUSES = ["interviewing", "confirmed"];
+export const ARCHITECTURE_PLAN_RESULTS = [
+    "complete",
+    "incomplete",
+    "user clarification required"
+];
+export const TEST_RESULTS = ["pass", "fail", "incomplete"];
+export const L3_REQUIRED_VALUES = ["yes", "no"];
+export const L3_ACTIONS = ["run-existing", "updated", "added"];
+export const DOCS_SYNC_DECISIONS = ["synced", "unchanged", "blocked"];
+export const FINAL_ACCEPTANCE_DECISIONS = [
+    "accepted",
+    "accepted-with-known-risks",
+    "needs-coder-follow-up",
+    "needs-architect-follow-up",
+    "needs-docs-sync",
+    "blocked-by-user-decision"
+];
+export function renderArtifactOptions(values) {
+    return values.join("|");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.7.26",
+  "version": "0.7.28",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [

package/scripts/uninstall-vcm-harness.mjs

@@ -137,6 +137,11 @@ async function processEntry(context) {
     return;
   }
 
+  if (entry.ownership === "project-owned") {
+    context.operations.push(skip(entry.path, "project-owned; preserved"));
+    return;
+  }
+
   if (entry.ownership === "managed-block" || uninstallAction === "remove-managed-block") {
     await removeManagedBlock(context);
     return;