vibe-coding-master 0.3.0 → 0.3.2

package/dist/backend/services/session-service.js

@@ -5,6 +5,10 @@ import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const CODEX_REVIEWER_ROLE = "codex-reviewer";
+const CODEX_DIR = ".ai/codex";
+const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
+const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
@@ -17,29 +21,38 @@ export function createSessionService(deps) {
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
+        const isCodexReviewer = role === CODEX_REVIEWER_ROLE;
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
-        const model = normalizeClaudeModel(input.model ?? persisted?.model);
+        const model = isCodexReviewer
+            ? normalizeCodexModel(input.model ?? persisted?.model)
+            : normalizeClaudeModel(input.model ?? persisted?.model);
+        const effort = normalizeSessionEffort(input.effort ?? persisted?.effort);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
         if (!claudeSessionId) {
             throw new VcmError({
                 code: "CLAUDE_SESSION_MISSING",
-                message: `${role} does not have a Claude session id to resume.`,
+                message: `${role} does not have a session id to resume.`,
                 statusCode: 409,
                 hint: "Start the role once before using Resume."
             });
         }
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
-            : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
-        const startCommand = deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model);
+            : isCodexReviewer ? undefined : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
+        const startCommand = isCodexReviewer
+            ? await buildCodexReviewerStartCommand(deps.fs, taskRepoRoot, launchMode, model, effort)
+            : {
+                ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
+                cwd: taskRepoRoot
+            };
         const runtimeSession = await deps.runtime.createSession({
             taskSlug,
             role,
             command: startCommand.command,
             args: startCommand.args,
-            cwd: taskRepoRoot,
+            cwd: startCommand.cwd,
             env: {
                 VCM_API_URL: deps.apiUrl,
                 VCM_TASK_REPO_ROOT: taskRepoRoot,
@@ -63,7 +76,8 @@ export function createSessionService(deps) {
             command: startCommand.display,
             permissionMode,
             model,
-            cwd: taskRepoRoot,
+            effort,
+            cwd: startCommand.cwd,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             logPath: paths.roleLogPaths[role],
@@ -159,15 +173,18 @@ export function createSessionService(deps) {
             }
             return sessions;
         },
-        async recordClaudeHookEvent(repoRoot, input) {
+        async recordRoleHookEvent(repoRoot, input) {
             const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
-            if (!current || !matchesClaudeHookSession(current, input)) {
+            if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
                 return undefined;
             }
             const timestamp = now();
             const isStop = input.eventName === "Stop";
             const updated = {
                 ...current,
+                claudeSessionId: input.sessionId ?? current.claudeSessionId,
+                transcriptPath: input.transcriptPath ?? current.transcriptPath,
+                cwd: input.cwd ?? current.cwd,
                 activityStatus: isStop ? "idle" : "running",
                 lastHookEventAt: timestamp,
                 lastTurnEndedAt: isStop ? timestamp : current.lastTurnEndedAt,
@@ -180,6 +197,16 @@ export function createSessionService(deps) {
             await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
+        recordClaudeHookEvent(repoRoot, input) {
+            return this.recordRoleHookEvent(repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName: input.eventName,
+                sessionId: input.claudeSessionId,
+                transcriptPath: input.transcriptPath,
+                cwd: input.cwd
+            });
+        },
         async markRoleActivityRunning(repoRoot, taskSlug, role) {
             const current = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!current) {
@@ -201,14 +228,67 @@ export function createSessionService(deps) {
         }
     };
 }
-function matchesClaudeHookSession(record, input) {
-    if (input.claudeSessionId && record.claudeSessionId === input.claudeSessionId) {
+async function buildCodexReviewerStartCommand(fs, taskRepoRoot, launchMode, selectedModel, selectedEffort) {
+    const codexDir = resolveRepoPath(taskRepoRoot, CODEX_DIR);
+    const reviewDir = resolveRepoPath(taskRepoRoot, CODEX_REVIEW_DIR);
+    if (!(await fs.pathExists(codexDir))) {
+        throw new VcmError({
+            code: "CODEX_REVIEW_CONFIG_MISSING",
+            message: `${CODEX_DIR} does not exist.`,
+            statusCode: 409,
+            hint: "Apply the VCM harness before starting Codex Reviewer."
+        });
+    }
+    await fs.ensureDir(reviewDir);
+    const config = await loadCodexSessionConfig(fs, taskRepoRoot);
+    const model = selectedModel === "default"
+        ? config.model
+        : selectedModel;
+    const modelReasoningEffort = selectedEffort === "default"
+        ? config.modelReasoningEffort
+        : selectedEffort;
+    const args = launchMode === "resume"
+        ? ["resume", "--last"]
+        : [];
+    args.push("--cd", codexDir, "--add-dir", reviewDir, "--sandbox", "workspace-write", "--ask-for-approval", "never", "--dangerously-bypass-hook-trust");
+    if (model && model !== "default") {
+        args.push("--model", model);
+    }
+    if (modelReasoningEffort && modelReasoningEffort !== "default") {
+        args.push("--config", `model_reasoning_effort="${modelReasoningEffort}"`);
+    }
+    return {
+        command: config.command,
+        args,
+        cwd: taskRepoRoot,
+        display: [config.command, ...args].map(formatDisplayArg).join(" ")
+    };
+}
+async function loadCodexSessionConfig(fs, taskRepoRoot) {
+    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
+    if (!(await fs.pathExists(configPath))) {
+        return {
+            command: "codex",
+            model: "gpt-5.5",
+            modelReasoningEffort: "xhigh"
+        };
+    }
+    const content = await fs.readText(configPath);
+    const reviewSection = extractTomlSection(content, "vcm.codex_review");
+    return {
+        command: parseTomlString(reviewSection, "command") ?? "codex",
+        model: parseTomlString(content, "model") ?? "gpt-5.5",
+        modelReasoningEffort: parseTomlString(content, "model_reasoning_effort") ?? "xhigh"
+    };
+}
+function matchesRoleHookSession(record, input) {
+    if (input.sessionId && record.claudeSessionId === input.sessionId) {
         return true;
     }
     if (input.transcriptPath && record.transcriptPath === input.transcriptPath) {
         return true;
     }
-    if (!input.claudeSessionId && !input.transcriptPath) {
+    if (!input.sessionId && !input.transcriptPath) {
         return true;
     }
     return false;
@@ -249,7 +329,10 @@ async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role)
                 ? legacy.lastStopAt
                 : undefined),
             permissionMode: normalizeClaudePermissionMode(record.permissionMode),
-            model: normalizeClaudeModel(record.model)
+            model: record.role === CODEX_REVIEWER_ROLE
+                ? normalizeCodexModel(record.model)
+                : normalizeClaudeModel(record.model),
+            effort: normalizeSessionEffort(record.effort)
         }
         : undefined;
 }
@@ -311,3 +394,49 @@ function normalizeClaudeModel(value) {
     }
     return "default";
 }
+function normalizeCodexModel(value) {
+    if (value === "default" || value === "gpt-5.5") {
+        return value;
+    }
+    return "gpt-5.5";
+}
+function normalizeSessionEffort(value) {
+    if (value === "low"
+        || value === "medium"
+        || value === "high"
+        || value === "xhigh"
+        || value === "max") {
+        return value;
+    }
+    return "default";
+}
+function extractTomlSection(content, sectionName) {
+    const lines = content.split(/\r?\n/);
+    const header = `[${sectionName}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0) {
+        return "";
+    }
+    const section = [];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (/^\s*\[[^\]]+\]\s*$/.test(line)) {
+            break;
+        }
+        section.push(line);
+    }
+    return section.join("\n");
+}
+function parseTomlString(content, key) {
+    const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, "m");
+    return pattern.exec(content)?.[1];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatDisplayArg(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/backend/templates/handoff.js

@@ -9,6 +9,16 @@ TBD
 
 TBD
 
+## Scaffold Manifest
+
+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.
+
+| File | Action | Task Context | Durable Code Comment Needed | Coder Work | Allowed Freedom | VCM:CODE | Proof Point | Replan Trigger |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+
 ## Implementation Plan
 
 TBD

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

@@ -21,24 +21,28 @@ export function renderArchitectHarnessRules() {
 
 ### Architecture Plan
 
-- Before coder work starts, write \`.ai/vcm/handoffs/architecture-plan.md\` and materialize the plan in code scaffolding.
+- Before coder work starts, write \`.ai/vcm/handoffs/architecture-plan.md\`, choose the minimum necessary code scaffolding, and include a Scaffold Manifest for task-specific context and coder guidance.
 
 #### Plan Document
 
 - Define the expected implementation scope: affected modules, changed or created files, each file's responsibility, why it is in scope, and user-visible behavior changes.
 - Define every non-private callable surface intended for use outside its file: visibility, signature shape, responsibility, expected callers, behavior contract, side effects, and error boundaries.
+- Include a \`Scaffold Manifest\` for task-specific file context: file action, why the file is in scope, coder work, allowed implementation freedom, expected \`VCM:CODE\` placeholders, durable code comment needs, proof points, and Replan triggers.
+- Put task context, phase notes, handoff instructions, temporary rationale, and coder guidance in the \`Scaffold Manifest\`, not in source-code comments.
 - Cover architecture docs impact, known risks, and Replan triggers.
 - For docs impact, state whether changes belong in \`docs/ARCHITECTURE.md\`, affected \`<module>/ARCHITECTURE.md\`, \`.ai/generated/public-surface.json\`, or no durable architecture doc.
 
 #### Code Scaffolding
 
-- Create or update module/file scaffolding so file responsibilities, logic boundaries, collaborators, and non-goals are documented in code.
-- When changing an existing file, update only the affected in-code scaffold: responsibility, boundary, collaborators, non-goals, or callable surfaces; do not rewrite unrelated file comments.
+- Create or update only the minimum module/file scaffolding needed to make boundaries, callable surfaces, and placeholders unambiguous.
+- Source-code comments must describe durable behavior, contracts, invariants, error boundaries, or non-obvious logic that should remain useful after the task is complete.
+- Do not put task-specific context, phase notes, handoff instructions, temporary plan rationale, or coder guidance in source-code comments.
+- When changing an existing file, update only affected durable comments or callable surfaces; do not rewrite unrelated file comments.
 - Define every new or changed non-private callable surface directly in code with its signature shape and contract comment.
 - When changing an existing non-private callable surface, update its signature and contract comment in code before coder work starts; leave \`VCM:CODE\` only where implementation must change.
 - Non-private callable surface includes any function, method, type, trait, enum, constant, re-export, or similar symbol that another file can call or depend on.
 - Mark incomplete implementation bodies with \`VCM:CODE\`; coder must implement them and remove the markers before handoff.
-- Architect scaffolding may include modules, files, signatures, type shapes, comments, and placeholder bodies, but not real business implementation beyond minimal scaffold code.
+- Architect scaffolding may include modules, files, signatures, type shapes, durable comments, and placeholder bodies, but not real business implementation beyond minimal scaffold code.
 - Coder may add private implementation helpers, but must not add or change cross-file callable surface without architect replan.
 
 ### Phase Planning

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

@@ -27,7 +27,7 @@ export function renderRootClaudeHarnessRules() {
 ## VCM Task Flow
 
 - Code changes use the full route: \`project-manager -> architect -> coder -> reviewer -> architect docs sync -> project-manager final acceptance\`.
-- Before code changes, architect must write an architecture plan and code scaffolding that cover file responsibilities, cross-file callable surfaces, user-visible behavior, docs impact, risks, and Replan triggers.
+- Before code changes, architect must write an architecture plan with a Scaffold Manifest and minimum necessary code scaffolding that cover file responsibilities, cross-file callable surfaces, user-visible behavior, docs impact, risks, and Replan triggers.
 - Docs-only changes may use: \`project-manager -> architect -> project-manager final acceptance\`.
 - Test-only or validation-only work may use: \`project-manager -> reviewer -> project-manager final acceptance\`.
 - If a docs/test/validation-only task reveals required code, architecture, public contract, dependency, durable-doc, or test-strategy changes, route back through the full code-change flow.

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

@@ -14,7 +14,7 @@ export function renderCoderHarnessRules() {
 - Do not fake completion: no hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback that hides failure.
 - Keep the diff inside approved scope: no unrelated rewrites, drive-by refactors, renamed symbols, moved files, or formatting churn.
 - Preserve existing behavior unless the architecture plan explicitly changes it; keep existing call sites and shared code paths working.
-- Maintain code documentation: preserve architect-written comments, add comments for non-obvious implementation logic, remove stale/debug/TODO comments, and keep code and comments consistent.
+- Maintain code documentation: preserve durable architect-written contract comments, do not copy Scaffold Manifest task context into source comments, add comments only for non-obvious durable logic, remove stale/debug/TODO/task-process comments, and keep code and comments consistent.
 
 ### General Coding Standards
 

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

@@ -31,10 +31,12 @@ Check that the plan:
 - matches the user request and approved scope
 - names affected modules/files, file responsibilities, and user-visible changes
 - defines new or changed non-private callable surfaces: visibility, signature shape, callers, contract, side effects, and error boundaries
+- includes a Scaffold Manifest that carries task-specific context, coder guidance, allowed freedom, expected \`VCM:CODE\`, durable code comment needs, proof points, and Replan triggers
 - preserves dependency direction and avoids unapproved dependencies
 - states docs/generated-context impact or explains why none is needed
 - names risks, proof points, phase boundaries when needed, and Replan triggers
 - uses \`VCM:CODE\` for incomplete implementation and leaves no coder ambiguity
+- keeps task-specific context, phase notes, handoff instructions, and coder guidance out of source-code comments
 - does not take over reviewer-owned validation strategy or test adequacy
 
 ### Validation Adequacy
@@ -56,6 +58,7 @@ Check that the final diff:
 - stays inside the approved plan, phase, and user constraints
 - introduces no unapproved modules, dependencies, public contracts, cross-file callable surfaces, or durable-doc changes
 - removes all \`VCM:CODE\` markers
+- leaves no task-specific process comments in source or test code, such as role handoff notes, phase notes, current-task rationale, or coder instructions
 - contains no fake completion: hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback hiding failure
 - preserves existing behavior unless the plan changes it
 - keeps changed functions focused and meaningfully named
@@ -96,12 +99,8 @@ approval_policy = "never"
 default_permissions = "vcm_codex_reviewer"
 
 [vcm.codex_review]
-enabled = true
-required_gates = [
-  "architecture-plan",
-  "validation-adequacy",
-  "final-diff",
-]
+enabled = false
+required_gates = []
 
 [permissions.vcm_codex_reviewer.workspace_roots]
 "../.." = true
@@ -118,6 +117,41 @@ required_gates = [
 [permissions.vcm_codex_reviewer.network]
 enabled = false`;
 }
+export function renderCodexCliConfigHarnessRules() {
+    return `[features]
+hooks = true`;
+}
+export function renderCodexHooksHarnessRules() {
+    const eventScript = "let s=\"\";process.stdin.setEncoding(\"utf8\");process.stdin.on(\"data\",d=>s+=d);process.stdin.on(\"end\",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});";
+    const userPromptCommand = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'${eventScript}'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/codex-reviewer" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
+    const stopCommand = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then printf "{}"; exit 0; fi; node -e '"'"'${eventScript}'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/codex-reviewer/stop" -H "content-type: application/json" --data-binary @- || printf "{}"'`;
+    return JSON.stringify({
+        hooks: {
+            UserPromptSubmit: [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: userPromptCommand,
+                            timeout: 5
+                        }
+                    ]
+                }
+            ],
+            Stop: [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: stopCommand,
+                            timeout: 10
+                        }
+                    ]
+                }
+            ]
+        }
+    }, null, 2);
+}
 export function renderCodexArchitecturePlanPrompt() {
     return `# Codex Gate: architecture-plan
 
@@ -130,6 +164,7 @@ Review whether the architecture plan is ready for coder implementation.
 - \`../../.claude/agents/coder.md\`
 - \`../../.claude/agents/reviewer.md\`
 - \`../../.ai/vcm/handoffs/architecture-plan.md\`
+- current git status and scaffold diff from \`../..\`
 - \`../../.ai/generated/module-index.json\`
 - \`../../.ai/generated/public-surface.json\`
 

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

@@ -23,6 +23,7 @@ export function renderReviewerHarnessRules() {
 - Record failed commands, observed behavior, expected behavior, reproduction steps, skipped checks, and coverage gaps.
 - If validation fails or expected behavior is unclear, report the evidence to project-manager; architect owns diagnosis and next-step routing.
 - Add or modify tests, fixtures, or test helpers needed for validation confidence.
+- If task-specific process comments appear in changed code while reviewing behavior, report them as a maintainability gap; task context belongs in handoff artifacts, not durable code comments.
 - 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.
 
 ### Testing Documentation

package/dist/shared/constants.js

@@ -1,6 +1,6 @@
 export const DEFAULT_BACKEND_PORT = 4173;
 export const DEFAULT_FRONTEND_PORT = 5173;
-export const ROLE_DEFINITIONS = [
+export const VCM_ROLE_DEFINITIONS = [
     {
         name: "project-manager",
         label: "Project Manager",
@@ -26,6 +26,17 @@ export const ROLE_DEFINITIONS = [
         dispatchable: true
     }
 ];
+export const CODEX_REVIEWER_ROLE_DEFINITION = {
+    name: "codex-reviewer",
+    label: "Codex Reviewer",
+    commandAgent: "codex-reviewer",
+    dispatchable: false
+};
+export const ROLE_DEFINITIONS = [
+    ...VCM_ROLE_DEFINITIONS,
+    CODEX_REVIEWER_ROLE_DEFINITION
+];
+export const VCM_ROLE_NAMES = VCM_ROLE_DEFINITIONS.map((role) => role.name);
 export const ROLE_NAMES = ROLE_DEFINITIONS.map((role) => role.name);
 export const DISPATCHABLE_ROLES = ROLE_DEFINITIONS
     .filter((role) => role.dispatchable)
@@ -33,6 +44,9 @@ export const DISPATCHABLE_ROLES = ROLE_DEFINITIONS
 export function isRoleName(value) {
     return ROLE_NAMES.includes(value);
 }
+export function isVcmRoleName(value) {
+    return VCM_ROLE_NAMES.includes(value);
+}
 export function isDispatchableRole(value) {
     return DISPATCHABLE_ROLES.includes(value);
 }

package/dist/shared/types/app-settings.js

@@ -1,12 +1,13 @@
-import { ROLE_NAMES } from "../constants.js";
+import { VCM_ROLE_NAMES } from "../constants.js";
 export const THEME_MODES = ["system", "light", "dark"];
 export const PERMISSION_REQUEST_MODES = ["off", "allowAll"];
 export function createDefaultLaunchTemplate() {
     const roles = {};
-    for (const role of ROLE_NAMES) {
+    for (const role of VCM_ROLE_NAMES) {
         roles[role] = {
             permissionMode: "default",
-            model: "default"
+            model: "default",
+            effort: "default"
         };
     }
     return {

package/dist/shared/types/codex-hook.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/types/session.js

@@ -35,3 +35,47 @@ export const CLAUDE_MODEL_OPTIONS = [
         description: "Opus 4.8 + 1M context"
     }
 ];
+export const CODEX_MODEL_OPTIONS = [
+    {
+        value: "gpt-5.5",
+        label: "GPT-5.5",
+        description: "Strong Codex reviewer default"
+    },
+    {
+        value: "default",
+        label: "Default",
+        description: "Codex account default"
+    }
+];
+export const SESSION_EFFORT_OPTIONS = [
+    {
+        value: "default",
+        label: "Default",
+        description: "CLI or project default"
+    },
+    {
+        value: "low",
+        label: "Low",
+        description: "Fastest reasoning"
+    },
+    {
+        value: "medium",
+        label: "Medium",
+        description: "Balanced reasoning"
+    },
+    {
+        value: "high",
+        label: "High",
+        description: "Deeper reasoning"
+    },
+    {
+        value: "xhigh",
+        label: "XHigh",
+        description: "Extra high reasoning"
+    },
+    {
+        value: "max",
+        label: "Max",
+        description: "Maximum reasoning"
+    }
+];

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

@@ -2,6 +2,7 @@ const REQUIRED_HEADINGS = {
     "architecture-plan": [
         "Context",
         "Architecture Decision",
+        "Scaffold Manifest",
         "Implementation Plan",
         "Risks",
         "Stop Conditions"