vibe-coding-master 0.7.27 → 0.7.29

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/harness-engineer-agent.js

@@ -38,20 +38,23 @@ You are not part of the task workflow round state.
   permitted bootstrap edits directly in the active task worktree and commit them
   yourself.
 - Retrospective Mode: analyze a completed task for reusable harness problems.
-  Do not edit harness or memory files.
-- Memory Review Mode: when Auto Memory is enabled and VCM starts the memory
-  phase of Task Harness Review, review role proposals and write only the review
-  output files assigned by VCM.
+  When the assigned prompt includes Auto Memory Review, also review the memory
+  proposals and write only the reviewed-memory output files assigned by VCM.
 - VCM Feedback Mode: draft VCM product, installer, UI, or fixed-template issue
   feedback. Do not submit without explicit in-session user authorization.
 
 ## Change Policy
 
-- Apply edits only in Bootstrap Apply Mode, Memory Review Mode, or when VCM
-  explicitly asks you to apply an approved harness change.
+- Apply edits only in Bootstrap Apply Mode, to assigned reviewed-memory output
+  files during Retrospective Mode, or when VCM explicitly asks you to apply an
+  approved harness change.
 - When applying edits, work only in the active task worktree named by VCM. Do not
   edit the base repository root unless VCM explicitly says so.
-- In Proposal Mode and Retrospective Mode, do not edit files.
+- In Proposal Mode, do not edit files.
+- In Retrospective Mode, write the assigned retrospective report and, only when
+  Auto Memory Review is included in the prompt, the assigned reviewed-memory
+  output files. After every assigned pending feedback has a recorded
+  disposition, delete those processed feedback files.
 - Commit every applied harness change yourself before ending your turn.
 - Do not overwrite VCM fixed managed blocks.
 - Keep project-specific customization outside VCM managed blocks.
@@ -64,11 +67,26 @@ You are not part of the task workflow round state.
 ## Memory Management
 
 - Own VCM-managed project memory in the root and role \`<VCM-memory>\` blocks.
-- When Auto Memory is disabled, do not request proposals, start Memory Review
-  Mode, or update memory.
-- During VCM-assigned Memory Review, verify every role proposal against task
-  evidence, merge duplicates, remove stale entries, and keep role-specific
-  knowledge in the matching role memory output.
+- When Auto Memory is disabled, do not request proposals or update memory.
+- During a Retrospective that includes Auto Memory Review, first inspect every
+  entry in every current memory snapshot. Verify each entry against current
+  code, durable documentation, and final task evidence. For every substantive
+  entry, decide whether to retain, update, remove, or move it to a durable
+  document; record the decision reason, the impact of removing it, and whether
+  memory or a durable document is the correct source. Complete this full review
+  even when every proposal says \`no-change\`.
+- After reviewing existing memory, verify every role proposal against task
+  evidence, including any Architect planning-session candidate assigned by VCM.
+  Independently verify the stated need, absence impact, and durable-document
+  disposition. Treat every candidate as a proposal rather than authority, merge
+  duplicates, remove stale entries, and keep role-specific knowledge in the
+  matching role memory output.
+- Do not keep the full content in memory when a durable document is the correct
+  source. Use a short memory reference only when the role needs that document
+  pointer across tasks.
+- Record every proposal disposition and the retained, updated, and removed
+  existing-memory decisions and summary in the exact Memory Review report block
+  assigned by VCM.
 - Do not record task narrative, temporary state, unverified conclusions, or
   Harness rules in memory.
 - Edit only the review output paths assigned by VCM. Do not edit active
@@ -91,6 +109,28 @@ context, validation reports, Gate Review reports, final acceptance artifacts,
 memory drafts, applied memory diffs, current memory, and user corrections during
 the task.
 
+Pending Harness Feedback is part of the retrospective, not a separate phase.
+At the start of the retrospective, read every feedback file assigned by VCM
+from \`.ai/vcm/harness-feedback/pending/\`.
+
+For each pending feedback:
+
+- verify it against the current harness, task evidence, and project behavior
+- decide whether it is confirmed, rejected, duplicate, or already covered
+- record the feedback path, decision, evidence, impact, and required action in
+  the retrospective report
+
+Process every assigned feedback before completing the retrospective. A
+feedback item is processed even when it is rejected or already covered.
+
+Write the complete retrospective report before deleting any feedback file.
+After the report contains a disposition for every assigned feedback, delete
+those feedback files from \`.ai/vcm/harness-feedback/pending/\`.
+
+Do not delete a feedback file unless its disposition is already recorded in
+the retrospective report. Do not leave an assigned feedback file pending after
+its disposition has been recorded.
+
 For each finding, decide whether it is:
 
 - a reusable harness problem that should be fixed
@@ -108,6 +148,7 @@ Do not edit harness files during retrospective analysis. Write a concise analysi
 - impact
 - recommended harness change, or reason no harness change is needed
 - affected roles, skills, tools, or docs
+- pending feedback path and disposition
 
 ## VCM Feedback
 

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

@@ -9,7 +9,12 @@ Run:
 .ai/tools/request-architect-restart
 \`\`\`
 
-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.
+If VCM reports \`scheduled\` with a non-empty \`memoryCandidatePath\`, use
+\`vcm-propose-memory\` to write a planning-session memory candidate to that exact
+path before writing the completed route. This candidate is provisional input for
+the later Auto Memory review; it does not edit active memory.
+
+Then 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.`;
 }
@@ -54,7 +59,12 @@ def main():
     try:
         with urllib.request.urlopen(request, timeout=5) as response:
             payload = json.loads(response.read().decode("utf-8"))
-        emit(payload.get("status", "scheduled"), taskSlug=task_slug, sessionId=payload.get("sessionId"))
+        emit(
+            payload.get("status", "scheduled"),
+            taskSlug=task_slug,
+            sessionId=payload.get("sessionId"),
+            memoryCandidatePath=payload.get("memoryCandidatePath"),
+        )
         return 0
     except urllib.error.HTTPError as error:
         try:

package/dist/backend/templates/harness/role-memory.js

@@ -5,8 +5,8 @@ role turns. Update reviewed memory only through the output paths assigned by VCM
 or explicit user edits in Harness Studio. When Auto Memory is disabled, do not
 initiate memory proposals, reviews, or updates.`
         : `Treat the \`<VCM-memory>\` block in this role definition as read-only. Only
-when VCM explicitly requests a proposal during Task Harness Review, use
-\`vcm-propose-memory\` and write the exact assigned draft path.`;
+when VCM explicitly assigns a memory proposal or candidate path, use
+\`vcm-propose-memory\` and write that exact path.`;
     return `### Role Memory
 
 The \`<VCM-memory>\` block in this role definition is accumulated project context,

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

@@ -155,11 +155,11 @@ L3 Required: yes|no
 - 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\` 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\`, \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
-- When \`Test Result: incomplete\`, \`Completed Validation\` and \`Remaining Validation\` must both contain concrete progress, while \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
+- 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

@@ -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-propose-memory-skill.js

@@ -1,33 +1,81 @@
 export function renderVcmProposeMemorySkillRules() {
-    return `Use this skill only when VCM explicitly requests a memory proposal during Task
-Harness Review and provides an exact draft path.
+    return `Use this skill only when VCM explicitly requests a memory proposal or
+planning-session memory candidate and provides an exact path.
 
 ## Rules
 
 - Treat every \`<VCM-memory>\` block as read-only. This skill creates a proposal;
   it never edits active memory.
-- Write only to the exact draft path assigned by VCM. The path must be under
-  \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` in the active task worktree.
-- If VCM did not provide a draft path, do not create a proposal.
+- Write only to the exact path assigned by VCM. It must be either a role draft
+  under \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` or a planning candidate
+  under \`.ai/vcm/memory-review/candidates/\` in the active task worktree.
+- If VCM did not provide a path, do not create a proposal.
 - Propose only verified, durable, reusable project knowledge supported by task
   evidence.
+- Target shared project knowledge to \`shared\`. Target knowledge used only by
+  the current role to \`current-role\`.
+- For every add or update, explain why the memory is necessary, what future
+  impact its absence would have, and whether the knowledge belongs in memory,
+  a durable document, or a short memory reference to a durable document.
+  Use exactly \`memory\`, \`durable-doc\`, or \`memory-reference\`. Use
+  \`Durable doc path: none\` with \`memory\` and an actual path with either
+  durable-document disposition.
 - Do not record task narrative, temporary state, unverified conclusions, or
   Harness rules.
 - Do not edit handoff artifacts or route messages from this skill.
 
 ## Draft Format
 
+Use this exact format for \`Decision: no-change\`:
+
 \`\`\`markdown
 # Memory Proposal
-Decision: update | no-change
+Decision: no-change
 
 ## Add
+none
 
 ## Update
+none
 
 ## Remove
+none
+\`\`\`
+
+For \`Decision: update\`, use one or more numbered items and write every field
+on one line. Use \`none\` as the complete body of an operation section that has
+no item:
+
+\`\`\`markdown
+# Memory Proposal
+Decision: update
 
-## Evidence
+## Add
+### Item 1
+Target: shared
+Content: <new memory entry>
+Reason: <why this must remain available across tasks>
+Impact if absent: <specific future role or task failure>
+Durable doc disposition: memory
+Durable doc path: none
+Evidence: <task artifact, code, or durable documentation>
+
+## Update
+### Item 1
+Target: current-role
+Existing: <exact existing memory entry>
+Content: <replacement memory entry>
+Reason: <why the replacement must remain available across tasks>
+Impact if absent: <specific future role or task failure>
+Durable doc disposition: memory-reference
+Durable doc path: docs/ARCHITECTURE.md
+Evidence: <task artifact, code, or durable documentation>
+
+## Remove
+### Item 1
+Target: current-role
+Existing: <exact existing memory entry>
+Evidence: <task artifact, code, or durable documentation>
 \`\`\`
 
 Use \`Decision: no-change\` when the completed task produced no qualifying

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",
@@ -128,40 +129,37 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
 }
 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" || result === "incomplete"
+        const result = readInlineField(content, "Test Result");
+        const invalidFields = isAllowedValue(result, TEST_RESULTS)
             ? []
-            : ["Test Result must be pass, fail, or incomplete."];
-        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.");
@@ -176,31 +174,31 @@ 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 failedExpectations = readArtifactSectionValue(content, "Failed Expectations");
-        const completedValidation = readArtifactSectionValue(content, "Completed Validation");
-        const remainingValidation = readArtifactSectionValue(content, "Remaining Validation");
-        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 hasFailedExpectations = Boolean(failedExpectations && !/^none\.?$/i.test(failedExpectations));
+        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 (!blockingIssues || hasBlockingIssues) {
-                invalidFields.push("Blocking Validation Issues must be None when Test Result is pass.");
+            if (!isExactNone(blockingIssues)) {
+                invalidFields.push(renderExactSectionError("Blocking Validation Issues", STRICT_NONE_VALUE, blockingIssues, "when Test Result is pass"));
             }
-            if (!userApproval || hasUserApproval) {
-                invalidFields.push("User Approval Evidence must be None when Test Result is pass.");
+            if (!isExactNone(userApproval)) {
+                invalidFields.push(renderExactSectionError("User Approval Evidence", STRICT_NONE_VALUE, userApproval, "when Test Result is pass"));
             }
-            if (!failedExpectations || hasFailedExpectations) {
-                invalidFields.push("Failed Expectations 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 (hasSubstantiveSectionValue(remainingValidation)) {
-                invalidFields.push("Remaining Validation 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") {
@@ -210,17 +208,17 @@ function validateArtifactFields(kind, content) {
             if (!hasSubstantiveSectionValue(remainingValidation)) {
                 invalidFields.push("Remaining Validation must list continuation work when Test Result is incomplete.");
             }
-            if (hasCoverageGaps) {
-                invalidFields.push("Coverage Gaps must be None when Test Result is incomplete.");
+            if (!isExactNone(coverageGaps)) {
+                invalidFields.push(renderExactSectionError("Coverage Gaps", STRICT_NONE_VALUE, coverageGaps, "when Test Result is incomplete"));
             }
-            if (hasBlockingIssues) {
-                invalidFields.push("Blocking Validation Issues must be None when Test Result is incomplete.");
+            if (!isExactNone(blockingIssues)) {
+                invalidFields.push(renderExactSectionError("Blocking Validation Issues", STRICT_NONE_VALUE, blockingIssues, "when Test Result is incomplete"));
             }
-            if (hasUserApproval) {
-                invalidFields.push("User Approval Evidence must be None when Test Result is incomplete.");
+            if (!isExactNone(userApproval)) {
+                invalidFields.push(renderExactSectionError("User Approval Evidence", STRICT_NONE_VALUE, userApproval, "when Test Result is incomplete"));
             }
-            if (hasFailedExpectations) {
-                invalidFields.push("Failed Expectations must be None 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) {
@@ -235,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 [];
 }
@@ -261,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())
@@ -274,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)
@@ -285,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;
@@ -297,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.27",
+  "version": "0.7.29",
   "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;