vibe-coding-master 0.3.1 → 0.3.3

package/README.md

@@ -163,7 +163,7 @@ The recommended flow is:
 
 ```text
 project-manager
-  -> architect architecture plan and code scaffolding
+  -> architect architecture plan, Scaffold Manifest, and code scaffolding
   -> coder implementation and baseline unit checks
   -> reviewer independent validation
   -> architect docs sync / architecture drift check

package/dist/backend/adapters/claude-adapter.js

@@ -23,7 +23,10 @@ export function createClaudeAdapter(runner) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
             args.push("--model", model);
-            if (effort !== "default") {
+            if (effort === "ultracode") {
+                args.push("--settings", JSON.stringify({ ultracode: true }));
+            }
+            else if (effort !== "default") {
                 args.push("--effort", effort);
             }
             if (permissionMode === "bypassPermissions") {

package/dist/backend/api/round-routes.js

@@ -7,6 +7,7 @@ export function registerRoundRoutes(app, deps) {
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return deps.roundService.getSessionRoundState({
+            repoRoot: project.repoRoot,
             stateRepoRoot: taskRepoRoot,
             stateRoot: config.stateRoot,
             taskSlug: request.params.taskSlug

package/dist/backend/server.js

@@ -184,19 +184,22 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
+    const roundService = createRoundService({
+        fs,
+        sessionService,
+        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
+            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
+        }
+    });
     const codexReviewService = createCodexReviewService({
         fs,
         runner,
         runtime,
         projectService,
         taskService,
-        sessionService
-    });
-    const roundService = createRoundService({
-        fs,
-        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
-            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
-        }
+        appSettings,
+        sessionService,
+        roundService
     });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({

package/dist/backend/services/app-settings-service.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { createDefaultLaunchTemplate } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -129,6 +130,32 @@ export function createAppSettingsService(deps) {
             });
             return config;
         },
+        async getCodexReviewSettings() {
+            const settings = await loadSettings();
+            const requiredGates = normalizeCodexReviewGates(settings.codexReview?.requiredGates);
+            return {
+                enabled: requiredGates.length > 0,
+                requiredGates
+            };
+        },
+        async updateCodexReviewSettings(_repoRoot, _taskSlug, requiredGates) {
+            const current = await loadSettings();
+            const normalizedRequiredGates = normalizeCodexReviewGates(requiredGates);
+            const timestamp = new Date().toISOString();
+            const nextCodexReview = {
+                version: 1,
+                requiredGates: normalizedRequiredGates,
+                updatedAt: timestamp
+            };
+            await saveSettings({
+                ...current,
+                codexReview: normalizeCodexReviewSettingsState(nextCodexReview)
+            });
+            return {
+                enabled: normalizedRequiredGates.length > 0,
+                requiredGates: normalizedRequiredGates
+            };
+        },
         getSettingsPath() {
             return settingsPath;
         },
@@ -172,13 +199,41 @@ function normalizeProjectIndexFile(input) {
         projects
     };
 }
-function normalizeSettingsFile(input) {
+function normalizeCodexReviewSettingsState(input) {
+    if (!isObject(input)) {
+        return undefined;
+    }
     return {
+        version: 1,
+        requiredGates: normalizeCodexReviewGates(input.requiredGates),
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : new Date(0).toISOString()
+    };
+}
+function normalizeCodexReviewGates(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    const gates = [];
+    for (const value of input) {
+        if (!CODEX_REVIEW_GATES.includes(value) || gates.includes(value)) {
+            continue;
+        }
+        gates.push(value);
+    }
+    return CODEX_REVIEW_GATES.filter((gate) => gates.includes(gate));
+}
+function normalizeSettingsFile(input) {
+    const settings = {
         version: 1,
         preferences: normalizePreferences(input.preferences),
         translation: normalizeTranslationConfig(input.translation),
         recentRepositoryPaths: normalizeRecentRepositoryPaths(input.recentRepositoryPaths)
     };
+    const codexReview = normalizeCodexReviewSettingsState(input.codexReview);
+    if (codexReview) {
+        settings.codexReview = codexReview;
+    }
+    return settings;
 }
 function normalizePreferences(input) {
     const candidate = isObject(input) ? input : {};

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

@@ -4,7 +4,6 @@ import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { renderCodexConfigHarnessRules } from "../templates/harness/codex-review.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const CODEX_DIR = ".ai/codex";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
@@ -39,12 +38,13 @@ export function createCodexReviewService(deps) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const reviewSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
         return {
             repoRoot,
             taskSlug,
             taskRepoRoot,
             stateRoot: projectConfig.stateRoot,
-            config: await loadRuntimeConfig(deps.fs, taskRepoRoot)
+            config: loadRuntimeConfig(reviewSettings)
         };
     }
     async function requestReviewGateInternal(repoRoot, taskSlug, gate, options = {}) {
@@ -148,6 +148,7 @@ export function createCodexReviewService(deps) {
             return;
         }
         activeRuns.add(runKey);
+        let codexTurnStarted = false;
         try {
             const timestamp = now();
             await updateGateRecord(context, gate, {
@@ -169,13 +170,24 @@ export function createCodexReviewService(deps) {
                 });
             }
             const session = await ensureCodexReviewerSession(context);
-            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
             await submitTerminalInput(deps.runtime, session.id, prompt);
+            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+            await deps.roundService.recordRoleTurnEvent({
+                repoRoot: context.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.stateRoot,
+                taskSlug: context.taskSlug,
+                role: CODEX_REVIEWER_ROLE,
+                eventName: "UserPromptSubmit"
+            });
+            codexTurnStarted = true;
             const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), {
                 intervalMs: reportPollIntervalMs,
                 timeoutMs: reportTimeoutMs
             });
             const completedAt = now();
+            await recordCodexReviewerTurnStop(context, codexTurnStarted);
+            codexTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "completed",
                 decision: parsed.decision,
@@ -197,6 +209,8 @@ export function createCodexReviewService(deps) {
         catch (error) {
             const timestamp = now();
             const message = errorMessage(error);
+            await recordCodexReviewerTurnStop(context, codexTurnStarted);
+            codexTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "failed",
                 error: message,
@@ -215,6 +229,20 @@ export function createCodexReviewService(deps) {
             activeRuns.delete(runKey);
         }
     }
+    async function recordCodexReviewerTurnStop(context, shouldRecord) {
+        if (!shouldRecord) {
+            return;
+        }
+        await deps.sessionService.markRoleActivityIdle(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+        await deps.roundService.recordRoleTurnEvent({
+            repoRoot: context.repoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            taskSlug: context.taskSlug,
+            role: CODEX_REVIEWER_ROLE,
+            eventName: "Stop"
+        });
+    }
     async function ensureCodexReviewerSession(context) {
         const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
         if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
@@ -265,6 +293,14 @@ export function createCodexReviewService(deps) {
         try {
             await submitTerminalInput(deps.runtime, session.id, prompt);
             await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, "project-manager");
+            await deps.roundService.recordRoleTurnEvent({
+                repoRoot: context.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.stateRoot,
+                taskSlug: context.taskSlug,
+                role: "project-manager",
+                eventName: "UserPromptSubmit"
+            });
             await updateGateRecord(context, gate, {
                 callbackStatus: "sent",
                 callbackError: undefined,
@@ -285,8 +321,8 @@ export function createCodexReviewService(deps) {
             return loadIndex(deps.fs, context, now());
         },
         async updateSettings(repoRoot, taskSlug, input) {
-            const context = await getContext(repoRoot, taskSlug);
-            const requiredGates = new Set(context.config.enabled ? context.config.requiredGates : []);
+            const currentSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
+            const requiredGates = new Set(currentSettings.requiredGates);
             for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
                 if (!isCodexReviewGate(gate)) {
                     continue;
@@ -298,7 +334,7 @@ export function createCodexReviewService(deps) {
                     requiredGates.delete(gate);
                 }
             }
-            await writeRuntimeConfigSettings(deps.fs, context.taskRepoRoot, [...requiredGates]);
+            await deps.appSettings.updateCodexReviewSettings(repoRoot, taskSlug, [...requiredGates]);
             const nextContext = await getContext(repoRoot, taskSlug);
             const index = await loadIndex(deps.fs, nextContext, now());
             await saveIndex(deps.fs, nextContext.taskRepoRoot, {
@@ -372,75 +408,12 @@ export function createCodexReviewService(deps) {
 export function isCodexReviewGate(value) {
     return CODEX_REVIEW_GATES.includes(value);
 }
-async function loadRuntimeConfig(fs, taskRepoRoot) {
-    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
-    if (!(await fs.pathExists(configPath))) {
-        return {
-            enabled: false,
-            requiredGates: [],
-            command: "codex"
-        };
-    }
-    const content = await fs.readText(configPath);
-    const section = extractTomlSection(content, "vcm.codex_review");
-    const enabled = parseTomlBoolean(section, "enabled") ?? false;
-    const parsedGates = parseTomlStringArray(section, "required_gates").filter(isCodexReviewGate);
+function loadRuntimeConfig(reviewSettings) {
     return {
-        enabled,
-        requiredGates: parsedGates.length > 0 ? parsedGates : enabled ? [...CODEX_REVIEW_GATES] : [],
-        model: parseTomlString(content, "model"),
-        modelReasoningEffort: parseTomlString(content, "model_reasoning_effort"),
-        command: parseTomlString(section, "command") ?? "codex"
+        enabled: reviewSettings.enabled,
+        requiredGates: reviewSettings.requiredGates
     };
 }
-async function writeRuntimeConfigSettings(fs, taskRepoRoot, requiredGates) {
-    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
-    const current = await fs.pathExists(configPath)
-        ? await fs.readText(configPath)
-        : renderCodexConfigHarnessRules();
-    const section = renderCodexReviewSettingsSection(requiredGates);
-    const next = replaceTomlSection(current, "vcm.codex_review", section);
-    await fs.writeText(configPath, next);
-}
-function renderCodexReviewSettingsSection(requiredGates) {
-    if (requiredGates.length === 0) {
-        return [
-            "[vcm.codex_review]",
-            "enabled = false",
-            "required_gates = []"
-        ].join("\n");
-    }
-    const lines = [
-        "[vcm.codex_review]",
-        "enabled = true",
-        "required_gates = [",
-        ...CODEX_REVIEW_GATES
-            .filter((gate) => requiredGates.includes(gate))
-            .map((gate) => `  "${gate}",`),
-        "]"
-    ];
-    return lines.join("\n");
-}
-function replaceTomlSection(content, sectionName, nextSection) {
-    const lines = content.replace(/\s+$/g, "").split(/\r?\n/);
-    const header = `[${sectionName}]`;
-    const start = lines.findIndex((line) => line.trim() === header);
-    if (start < 0) {
-        return `${lines.join("\n").trimEnd()}\n\n${nextSection}\n`;
-    }
-    let end = lines.length;
-    for (let index = start + 1; index < lines.length; index += 1) {
-        if (/^\s*\[[^\]]+\]\s*$/.test(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    return [
-        ...lines.slice(0, start),
-        nextSection,
-        ...lines.slice(end)
-    ].join("\n").trimEnd() + "\n";
-}
 async function loadIndex(fs, context, timestamp) {
     const indexPath = getIndexPath(context.taskRepoRoot);
     const raw = await readJsonOrNull(fs, indexPath);
@@ -537,7 +510,7 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
             digest.update("<missing>");
         }
     }
-    if (gate === "final-diff") {
+    if (gate === "architecture-plan" || gate === "final-diff") {
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["status", "--porcelain=v1"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--binary"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--cached", "--binary"]));
@@ -684,41 +657,6 @@ async function readJsonOrNull(fs, targetPath) {
         return null;
     }
 }
-function extractTomlSection(content, sectionName) {
-    const lines = content.split(/\r?\n/);
-    const sectionHeader = `[${sectionName}]`;
-    const collected = [];
-    let inSection = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (/^\[[^\]]+\]$/.test(trimmed)) {
-            if (inSection) {
-                break;
-            }
-            inSection = trimmed === sectionHeader;
-            continue;
-        }
-        if (inSection) {
-            collected.push(line);
-        }
-    }
-    return collected.join("\n");
-}
-function parseTomlBoolean(section, key) {
-    const match = section.match(new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*(true|false)\\s*(?:#.*)?$`, "mi"));
-    return match ? match[1] === "true" : undefined;
-}
-function parseTomlString(content, key) {
-    const match = content.match(new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*"([^"]*)"\\s*(?:#.*)?$`, "mi"));
-    return match?.[1];
-}
-function parseTomlStringArray(section, key) {
-    const match = section.match(new RegExp(`${escapeRegex(key)}\\s*=\\s*\\[([\\s\\S]*?)\\]`, "m"));
-    if (!match) {
-        return [];
-    }
-    return [...match[1].matchAll(/"([^"]+)"/g)].map((candidate) => candidate[1]);
-}
 function matchField(content, field) {
     const match = content.match(new RegExp(`^\\s*${escapeRegex(field)}\\s*:\\s*(.+?)\\s*$`, "mi"));
     return match?.[1]?.trim();

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

@@ -39,6 +39,51 @@ export function createRoundService(deps) {
             status
         });
     }
+    async function findActiveRoleSession(input, timestamp) {
+        if (!input.repoRoot || !deps.sessionService) {
+            return undefined;
+        }
+        let sessions;
+        try {
+            sessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
+        }
+        catch {
+            return undefined;
+        }
+        const active = sessions
+            .filter((session) => session.status === "running" && session.activityStatus === "running")
+            .sort((left, right) => timestampMs(roleActivityTimestamp(right, timestamp)) - timestampMs(roleActivityTimestamp(left, timestamp)))[0];
+        if (!active) {
+            return undefined;
+        }
+        return {
+            role: active.role,
+            startedAt: roleActivityTimestamp(active, timestamp)
+        };
+    }
+    async function syncRoundFromActiveRoleSession(input, state, timestamp) {
+        const current = state.currentRound;
+        if (current?.status === "running" && current.activeTurnStartedAt) {
+            return undefined;
+        }
+        const active = await findActiveRoleSession(input, timestamp);
+        if (!active) {
+            return undefined;
+        }
+        const shouldStartNewRound = !current || current.status === "stopped";
+        const next = applyPromptSubmitted({
+            state,
+            taskSlug: input.taskSlug,
+            role: active.role,
+            timestamp: active.startedAt,
+            updatedAt: timestamp,
+            roundId: shouldStartNewRound ? id() : current.id
+        });
+        await save(input, next);
+        clearSettleTimer(input);
+        await updateSessionStatus(input, "running");
+        return next;
+    }
     async function settleIfNeeded(input, state, timestamp) {
         const current = state.currentRound;
         if (current?.status !== "running" ||
@@ -49,6 +94,10 @@ export function createRoundService(deps) {
         if (timestamp < current.settleDeadlineAt) {
             return state;
         }
+        const activeSessionState = await syncRoundFromActiveRoleSession(input, state, timestamp);
+        if (activeSessionState) {
+            return activeSessionState;
+        }
         const stopped = {
             ...current,
             status: "stopped",
@@ -76,6 +125,10 @@ export function createRoundService(deps) {
                 return;
             }
             const timestamp = maxIsoTimestamp(now(), settleDeadlineAt);
+            const activeSessionState = await syncRoundFromActiveRoleSession(input, state, timestamp);
+            if (activeSessionState) {
+                return;
+            }
             if (settleGuard) {
                 const decision = await runSettleGuard(settleGuard, {
                     ...input,
@@ -178,7 +231,10 @@ export function createRoundService(deps) {
         async getSessionRoundState(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
-                return toSessionRoundState(await load(input), timestamp);
+                const loaded = await load(input);
+                const synced = await syncRoundFromActiveRoleSession(input, loaded, timestamp);
+                const settled = synced ?? await settleIfNeeded(input, loaded, timestamp);
+                return toSessionRoundState(settled, timestamp);
             });
         },
         recordRoleTurnEvent,
@@ -198,7 +254,19 @@ export function applyRoundHookEvent(input) {
     return applyStop(input);
 }
 function applyPromptSubmitted(input) {
+    const updatedAt = input.updatedAt ?? input.timestamp;
     const current = input.state.currentRound;
+    if (current?.status === "running" && current.activeTurnStartedAt && current.activeRole === input.role) {
+        return {
+            ...input.state,
+            taskSlug: input.taskSlug,
+            currentRound: {
+                ...current,
+                roles: appendUniqueRole(current.roles, input.role)
+            },
+            updatedAt
+        };
+    }
     const shouldStartNewRound = !current || current.status === "stopped";
     const totalRoundCount = shouldStartNewRound
         ? input.state.totalRoundCount + 1
@@ -236,12 +304,12 @@ function applyPromptSubmitted(input) {
         totalTurnCount: input.state.totalTurnCount + 1,
         totalCompletedTurnCount: input.state.totalCompletedTurnCount,
         totalCcActiveMs: input.state.totalCcActiveMs,
-        updatedAt: input.timestamp
+        updatedAt
     };
 }
 function applyStop(input) {
     const current = input.state.currentRound;
-    if (!current || current.status === "stopped" || !current.activeTurnStartedAt) {
+    if (!current || current.status === "stopped" || !current.activeTurnStartedAt || current.activeRole !== input.role) {
         return {
             ...input.state,
             taskSlug: input.taskSlug,
@@ -389,6 +457,13 @@ function addMilliseconds(value, milliseconds) {
 function maxIsoTimestamp(left, right) {
     return Date.parse(left) >= Date.parse(right) ? left : right;
 }
+function roleActivityTimestamp(session, fallback) {
+    return session.lastTurnStartedAt ?? session.lastHookEventAt ?? session.updatedAt ?? fallback;
+}
+function timestampMs(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
 async function runSettleGuard(settleGuard, input) {
     try {
         return await settleGuard(input);

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

@@ -26,7 +26,9 @@ export function createSessionService(deps) {
         const model = isCodexReviewer
             ? normalizeCodexModel(input.model ?? persisted?.model)
             : normalizeClaudeModel(input.model ?? persisted?.model);
-        const effort = normalizeSessionEffort(input.effort ?? persisted?.effort);
+        const effort = isCodexReviewer
+            ? normalizeCodexEffort(input.effort ?? persisted?.effort)
+            : normalizeClaudeEffort(input.effort ?? persisted?.effort);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
@@ -225,6 +227,24 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
+        },
+        async markRoleActivityIdle(repoRoot, taskSlug, role) {
+            const current = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!current) {
+                return undefined;
+            }
+            const timestamp = now();
+            const updated = {
+                ...current,
+                activityStatus: "idle",
+                lastTurnEndedAt: timestamp,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            return updated;
         }
     };
 }
@@ -241,21 +261,15 @@ async function buildCodexReviewerStartCommand(fs, taskRepoRoot, launchMode, sele
     }
     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);
+    args.push("--cd", codexDir, "--add-dir", reviewDir, "--sandbox", "workspace-write", "--ask-for-approval", "never", "--dangerously-bypass-hook-trust", "--search");
+    if (selectedModel !== "default") {
+        args.push("--model", selectedModel);
     }
-    if (modelReasoningEffort && modelReasoningEffort !== "default") {
-        args.push("--config", `model_reasoning_effort="${modelReasoningEffort}"`);
+    if (selectedEffort !== "default") {
+        args.push("--config", `model_reasoning_effort="${selectedEffort}"`);
     }
     return {
         command: config.command,
@@ -268,17 +282,13 @@ 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"
+            command: "codex"
         };
     }
     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"
+        command: parseTomlString(content, "command") ?? parseTomlString(reviewSection, "command") ?? "codex"
     };
 }
 function matchesRoleHookSession(record, input) {
@@ -332,7 +342,9 @@ async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role)
             model: record.role === CODEX_REVIEWER_ROLE
                 ? normalizeCodexModel(record.model)
                 : normalizeClaudeModel(record.model),
-            effort: normalizeSessionEffort(record.effort)
+            effort: record.role === CODEX_REVIEWER_ROLE
+                ? normalizeCodexEffort(record.effort)
+                : normalizeClaudeEffort(record.effort)
         }
         : undefined;
 }
@@ -400,7 +412,18 @@ function normalizeCodexModel(value) {
     }
     return "gpt-5.5";
 }
-function normalizeSessionEffort(value) {
+function normalizeClaudeEffort(value) {
+    if (value === "low"
+        || value === "medium"
+        || value === "high"
+        || value === "xhigh"
+        || value === "max"
+        || value === "ultracode") {
+        return value;
+    }
+    return "default";
+}
+function normalizeCodexEffort(value) {
     if (value === "low"
         || value === "medium"
         || value === "high"

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