vibe-coding-master 0.6.17 → 0.6.19

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

@@ -6,6 +6,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
+import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -52,7 +53,8 @@ const AGENT_FRONTMATTER = {
         description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."
     },
     coder: {
-        description: "VCM implementation role for scoped code changes and focused tests."
+        description: "VCM implementation role for scoped code changes and focused tests.",
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
     },
     reviewer: {
         description: "VCM independent review role for acceptance, test adequacy, scope checks, and risk findings."
@@ -65,6 +67,10 @@ const AGENT_FRONTMATTER = {
     },
     "harness-engineer": {
         description: "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."
+    },
+    "vcm-coder-worker": {
+        description: "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.",
+        model: "inherit"
     }
 };
 const MANAGED_FILES = [
@@ -146,6 +152,14 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "agent-harness-engineer",
         content: renderHarnessEngineerHarnessRules()
+    },
+    {
+        path: ".claude/agents/vcm-coder-worker.md",
+        title: "VCM Coder Worker Agent",
+        agentName: "vcm-coder-worker",
+        commentStyle: "html",
+        category: "agent-coder-worker",
+        content: renderCoderWorkerHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -528,7 +542,9 @@ function renderManagedBlock(definition) {
 function renderNewManagedFile(definition, block) {
     if (definition.agentName) {
         const frontmatter = AGENT_FRONTMATTER[definition.agentName];
-        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---\n\n# ${definition.title}\n\n${block}\n`;
+        const tools = frontmatter.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
+        const model = frontmatter.model ? `\nmodel: ${frontmatter.model}` : "";
+        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}\n---\n\n# ${definition.title}\n\n${block}\n`;
     }
     return `# ${definition.title}\n\n${block}\n`;
 }

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

@@ -3,6 +3,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
+import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -135,6 +136,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("harness-engineer", "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."),
         renderRules: renderHarnessEngineerHarnessRules
     },
+    {
+        kind: "agent-coder-worker",
+        path: ".claude/agents/vcm-coder-worker.md",
+        title: "VCM Coder Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-coder-worker", "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.", { model: "inherit" }),
+        renderRules: renderCoderWorkerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",
@@ -161,7 +169,7 @@ const HARNESS_FILES = [
         kind: "agent-coder",
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests."),
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -1279,8 +1287,10 @@ function isVcmHookMatcher(value) {
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function renderAgentFrontmatter(name, description) {
-    return `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash, Edit, Write\n---`;
+function renderAgentFrontmatter(name, description, options = {}) {
+    const tools = options.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
+    const model = options.model ? `\nmodel: ${options.model}` : "";
+    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}\n---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;

package/dist/backend/services/job-guard-service.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 const ACTIVE_JOB_STATUSES = new Set(["queued", "starting", "running"]);
+const ACTIVE_CODER_WORKER_STATUSES = new Set(["planned", "running", "completed", "failed"]);
 const QUEUED_JOB_FRESH_MS = 120_000;
 export const MAX_CONSECUTIVE_STOP_BLOCKS = 3;
 export function createJobGuardService(deps = {}) {
@@ -73,19 +74,26 @@ export function createJobGuardService(deps = {}) {
         async evaluateStop(input) {
             const key = stateKey(input);
             const jobs = await findActiveJobs(input.taskRepoRoot);
-            if (jobs.length === 0) {
+            const coderWorkerTasks = input.role === "coder"
+                ? await findActiveCoderWorkerTasks(input.taskRepoRoot)
+                : [];
+            if (jobs.length === 0 && coderWorkerTasks.length === 0) {
                 blockStates.delete(key);
                 return { behavior: "allow" };
             }
-            const leaseMtimeMs = jobs.reduce((latest, job) => job.leaseMtimeMs !== undefined && (latest === undefined || job.leaseMtimeMs > latest)
+            const jobProgressMtimeMs = jobs.reduce((latest, job) => job.leaseMtimeMs !== undefined && (latest === undefined || job.leaseMtimeMs > latest)
                 ? job.leaseMtimeMs
                 : latest, undefined);
+            const workerProgressMtimeMs = coderWorkerTasks.reduce((latest, task) => task.stateMtimeMs !== undefined && (latest === undefined || task.stateMtimeMs > latest)
+                ? task.stateMtimeMs
+                : latest, undefined);
+            const progressMtimeMs = latestMtime(jobProgressMtimeMs, workerProgressMtimeMs);
             let state = blockStates.get(key) ?? { count: 0 };
-            const watcherProgressed = state.count > 0
-                && leaseMtimeMs !== undefined
-                && state.lastLeaseMtimeMs !== undefined
-                && leaseMtimeMs > state.lastLeaseMtimeMs;
-            if (watcherProgressed) {
+            const progressChanged = state.count > 0
+                && progressMtimeMs !== undefined
+                && state.lastProgressMtimeMs !== undefined
+                && progressMtimeMs > state.lastProgressMtimeMs;
+            if (progressChanged) {
                 state = { count: 0 };
             }
             if (state.count >= MAX_CONSECUTIVE_STOP_BLOCKS) {
@@ -94,24 +102,88 @@ export function createJobGuardService(deps = {}) {
                 blockStates.delete(key);
                 return { behavior: "allow" };
             }
-            blockStates.set(key, { count: state.count + 1, lastLeaseMtimeMs: leaseMtimeMs });
-            return { behavior: "block", reason: buildBlockReason(jobs) };
+            blockStates.set(key, { count: state.count + 1, lastProgressMtimeMs: progressMtimeMs });
+            return { behavior: "block", reason: buildBlockReason(jobs, coderWorkerTasks) };
         },
         notePromptSubmitted(input) {
             blockStates.delete(stateKey(input));
         }
     };
 }
+async function findActiveCoderWorkerTasks(taskRepoRoot) {
+    const tasksRoot = path.join(taskRepoRoot, ".ai/vcm/coder-workers/tasks");
+    let entries;
+    try {
+        entries = await fs.readdir(tasksRoot);
+    }
+    catch {
+        return [];
+    }
+    const tasks = [];
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith(".json")) {
+            continue;
+        }
+        const statePath = path.join(tasksRoot, entry);
+        let state;
+        try {
+            state = JSON.parse(await fs.readFile(statePath, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const status = typeof state.status === "string" ? state.status : "";
+        if (state.handled === true || !ACTIVE_CODER_WORKER_STATUSES.has(status)) {
+            continue;
+        }
+        let stateMtimeMs;
+        try {
+            stateMtimeMs = (await fs.stat(statePath)).mtimeMs;
+        }
+        catch {
+            stateMtimeMs = undefined;
+        }
+        tasks.push({
+            workerId: typeof state.workerId === "string" ? state.workerId : path.basename(entry, ".json"),
+            status,
+            reportPath: typeof state.reportPath === "string" ? state.reportPath : undefined,
+            error: typeof state.error === "string" ? state.error : undefined,
+            stateMtimeMs
+        });
+    }
+    return tasks;
+}
 function stateKey(input) {
     return `${input.repoRoot}::${input.taskSlug}::${input.role}`;
 }
-function buildBlockReason(jobs) {
+function buildBlockReason(jobs, coderWorkerTasks) {
+    if (jobs.length > 0 && coderWorkerTasks.length === 0) {
+        return buildValidationJobBlockReason(jobs);
+    }
+    if (jobs.length === 0) {
+        return buildCoderWorkerBlockReason(coderWorkerTasks);
+    }
+    return `${buildValidationJobBlockReason(jobs)}\n${buildCoderWorkerBlockReason(coderWorkerTasks)}`;
+}
+function buildValidationJobBlockReason(jobs) {
     const first = jobs[0];
     const listing = jobs.map((job) => `${job.jobId} (${job.status})`).join(", ");
     return `VCM: validation job ${listing} is still running. Do not end the turn while a validation job is running. `
         + `Run \`.ai/tools/watch-job ${first.jobId}\` again now and keep watching until it reports a terminal result `
         + `(success, failed, timeout, or orphaned), then record the result.`;
 }
+function buildCoderWorkerBlockReason(tasks) {
+    const listing = tasks.map((task) => `${task.workerId} (${task.status})`).join(", ");
+    const reports = tasks
+        .map((task) => task.reportPath)
+        .filter((reportPath) => Boolean(reportPath));
+    const reportHint = reports.length > 0 ? ` Review report(s): ${reports.join(", ")}.` : "";
+    return `VCM: coder worker task ${listing} is still unhandled. Do not end the Coder turn while worker tasks are unhandled. `
+        + `Wait for worker subagents, review reports and commits, resolve failed or incomplete workers, set \`handled: true\` in each worker state, and continue.${reportHint}`;
+}
+function latestMtime(...values) {
+    return values.reduce((latest, value) => value !== undefined && (latest === undefined || value > latest) ? value : latest, undefined);
+}
 function numberOrUndefined(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }

package/dist/backend/services/runtime-recovery-service.js

@@ -5,6 +5,7 @@ const TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_FEEDBACK_STATE_PATH = ".ai/vcm/harness-feedback/state.json";
+const CODER_WORKERS_RUNTIME_DIR = ".ai/vcm/coder-workers";
 const RECOVERABLE_FEEDBACK_STATES = new Set(["analyzing", "applying"]);
 export function createRuntimeRecoveryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
@@ -28,6 +29,7 @@ export function createRuntimeRecoveryService(deps) {
                     const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
+                    await cleanupCoderWorkers(taskRepoRoot, context);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }
@@ -230,6 +232,17 @@ export function createRuntimeRecoveryService(deps) {
         });
         context.changedPaths.add(relativePath);
     }
+    async function cleanupCoderWorkers(taskRepoRoot, context) {
+        const absolutePath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR);
+        if (!(await deps.fs.pathExists(absolutePath))) {
+            return;
+        }
+        if (!deps.fs.removePath) {
+            return;
+        }
+        await deps.fs.removePath(absolutePath, { recursive: true, force: true });
+        context.changedPaths.add(CODER_WORKERS_RUNTIME_DIR);
+    }
     async function recoverHarnessBootstrap(repoRoot, _timestamp, context) {
         const absolutePath = path.join(repoRoot, BOOTSTRAP_SESSION_PATH);
         const state = await readJsonIfExists(absolutePath);

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

@@ -8,7 +8,6 @@ import { createTranslationQueueRegistry } from "./translation-queue.js";
 const TRANSLATION_SOURCE_LANGUAGE = "auto";
 const TRANSLATION_INPUT_MODE = "review-before-send";
 const TRANSLATION_CONTEXT_ENABLED = false;
-const TRANSLATION_TIMEOUT_MS = 120000;
 const TRANSLATION_PROVIDER = "claude-code";
 const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
@@ -30,8 +29,7 @@ export function createTranslationService(deps) {
             targetLanguage: preferences.translationTargetLanguage,
             inputMode: TRANSLATION_INPUT_MODE,
             outputMode: preferences.translationOutputMode,
-            contextEnabled: TRANSLATION_CONTEXT_ENABLED,
-            requestTimeoutMs: TRANSLATION_TIMEOUT_MS
+            contextEnabled: TRANSLATION_CONTEXT_ENABLED
         };
     }
     function getState(sessionId) {
@@ -400,7 +398,7 @@ export function createTranslationService(deps) {
                 }
                 for (const { item, job } of jobs) {
                     try {
-                        const result = await waitForConversationResult(item.repoRoot, job, item.config.requestTimeoutMs);
+                        const result = await waitForConversationResult(item.repoRoot, job);
                         const completed = {
                             ...item.entry,
                             status: "translated",
@@ -1076,7 +1074,7 @@ export function createTranslationService(deps) {
         },
         async translateGatewayOutput(input) {
             const config = await loadConfig();
-            const reusable = await findReusableGatewayOutputTranslation(input, config);
+            const reusable = await findReusableGatewayOutputTranslation(input);
             if (reusable) {
                 return reusable.trim();
             }
@@ -1197,7 +1195,7 @@ export function createTranslationService(deps) {
         }
         return leftTime.localeCompare(rightTime);
     }
-    async function findReusableGatewayOutputTranslation(input, config) {
+    async function findReusableGatewayOutputTranslation(input) {
         const graceDeadline = Date.now() + (input.sourceEntryIds?.length ? GATEWAY_TRANSLATION_REUSE_GRACE_MS : 0);
         while (true) {
             const lookup = await lookupGatewayOutputTranslation(input);
@@ -1205,7 +1203,7 @@ export function createTranslationService(deps) {
                 return lookup.text;
             }
             if (lookup.kind === "active") {
-                return waitForReusableGatewayOutputTranslation(input, config);
+                return waitForReusableGatewayOutputTranslation(input);
             }
             if (!input.sourceEntryIds?.length || Date.now() >= graceDeadline) {
                 return undefined;
@@ -1213,9 +1211,8 @@ export function createTranslationService(deps) {
             await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
         }
     }
-    async function waitForReusableGatewayOutputTranslation(input, config) {
-        const deadline = Date.now() + config.requestTimeoutMs;
-        while (Date.now() <= deadline) {
+    async function waitForReusableGatewayOutputTranslation(input) {
+        while (true) {
             const lookup = await lookupGatewayOutputTranslation(input);
             if (lookup.kind === "translated") {
                 return lookup.text;
@@ -1225,11 +1222,6 @@ export function createTranslationService(deps) {
             }
             await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
         }
-        throw new VcmError({
-            code: "TRANSLATION_TIMEOUT",
-            message: "Gateway output translation timed out while waiting for the existing PM reply translation.",
-            statusCode: 504
-        });
     }
     async function lookupGatewayOutputTranslation(input) {
         const states = await getGatewayOutputCandidateStates(input);
@@ -1352,7 +1344,7 @@ export function createTranslationService(deps) {
     }
     async function translateText(input) {
         const job = await createConversationJob(input);
-        const result = await waitForConversationResult(input.repoRoot, job, input.config.requestTimeoutMs);
+        const result = await waitForConversationResult(input.repoRoot, job);
         return {
             text: result.translatedText
         };
@@ -1382,14 +1374,30 @@ export function createTranslationService(deps) {
             deferDispatch: input.deferDispatch
         });
     }
-    async function waitForConversationResult(repoRoot, job, timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        let lastError;
-        while (Date.now() <= deadline) {
+    async function waitForConversationResult(repoRoot, job) {
+        while (true) {
             const state = await deps.translationWorkerService.getState(repoRoot);
             const item = job.queueItemId
                 ? state.queue.items.find((candidate) => candidate.id === job.queueItemId)
                 : undefined;
+            if (!item) {
+                try {
+                    return await deps.translationWorkerService.validateConversationResult(repoRoot, {
+                        resultPath: job.resultPath,
+                        sourceHash: job.sourceHash,
+                        targetLanguage: job.targetLanguage
+                    });
+                }
+                catch (error) {
+                    throw new VcmError({
+                        code: "TRANSLATION_FAILED",
+                        message: error instanceof Error
+                            ? `translation queue item is unavailable: ${error.message}`
+                            : "translation queue item is unavailable.",
+                        statusCode: 502
+                    });
+                }
+            }
             if (item && ["failed", "cancelled", "interrupted", "skipped"].includes(item.status)) {
                 throw new VcmError({
                     code: "TRANSLATION_FAILED",
@@ -1398,7 +1406,7 @@ export function createTranslationService(deps) {
                 });
             }
             if (item && item.status !== "completed") {
-                await delay(Math.min(500, Math.max(25, timeoutMs)));
+                await delay(500);
                 continue;
             }
             try {
@@ -1409,18 +1417,12 @@ export function createTranslationService(deps) {
                 });
             }
             catch (error) {
-                lastError = error;
                 if (item?.status === "completed") {
                     throw error;
                 }
             }
-            await delay(Math.min(500, Math.max(25, timeoutMs)));
+            await delay(500);
         }
-        throw new VcmError({
-            code: "TRANSLATION_TIMEOUT",
-            message: lastError instanceof Error ? `translation timed out: ${lastError.message}` : "translation timed out.",
-            statusCode: 504
-        });
     }
 }
 function delay(ms) {

package/dist/backend/services/translation-worker-service.js

@@ -17,14 +17,6 @@ const CONVERSATION_BATCHES_DIR = `${CONVERSATION_RUNTIME_DIR}/batches`;
 const MEMORY_UPDATE_RUNTIME_DIR = `${TRANSLATIONS_RUNTIME_DIR}/memory-updates`;
 const DEFAULT_PROFILE = "default";
 const DEFAULT_CHUNK_SOURCE_TOKEN_TARGET = 80000;
-// In-flight conversation queue items normally finalize when the Translator
-// session's Stop/StopFailure hook reaches the backend. If that hook is lost
-// (session crash, backend restart/reconnect) a conversation item with no result
-// on disk would block the queue head forever. Treat such an item as stuck once it
-// has been in-flight past this bound and release it so later items can dispatch.
-// Kept comfortably above a normal short composer translation, so a genuinely
-// running conversation turn is never released mid-flight.
-const STALE_CONVERSATION_ITEM_MS = 90000;
 const BOOTSTRAP_DEFAULT_LIMIT = 12;
 const MEMORY_TOTAL_LIMIT_BYTES = 80 * 1024;
 const MEMORY_INITIALIZED_MIN_FILES = 2;
@@ -439,12 +431,22 @@ export function createTranslationWorkerService(deps) {
             await validateActiveQueueItem(repoRoot);
             return true;
         }
-        if (active.type === "conversation" && isStaleActiveItem(active)) {
+        if (await translatorSessionSettled(repoRoot)) {
             await validateActiveQueueItem(repoRoot);
             return true;
         }
         return false;
     }
+    async function reconcileActiveItemFromSessionState(repoRoot) {
+        const queue = await loadQueue(repoRoot);
+        const active = queue.activeItemId
+            ? queue.items.find((item) => item.id === queue.activeItemId)
+            : undefined;
+        if (!active || !["dispatching", "running"].includes(active.status)) {
+            return;
+        }
+        await reconcileStuckActiveItem(repoRoot, active);
+    }
     async function activeItemResultAvailable(repoRoot, item) {
         if (item.type === "conversation") {
             return conversationResultAvailable(repoRoot, item);
@@ -486,12 +488,12 @@ export function createTranslationWorkerService(deps) {
         }
         return deps.fs.readText(resultPath);
     }
-    function isStaleActiveItem(item) {
-        const updatedAtMs = Date.parse(item.updatedAt ?? "");
-        if (!Number.isFinite(updatedAtMs)) {
-            return true;
+    async function translatorSessionSettled(repoRoot) {
+        if (!deps.sessionService?.getProjectTranslatorSession) {
+            return false;
         }
-        return Date.now() - updatedAtMs >= STALE_CONVERSATION_ITEM_MS;
+        const session = await deps.sessionService.getProjectTranslatorSession(repoRoot);
+        return !session || session.status !== "running";
     }
     async function validateActiveQueueItem(repoRoot) {
         const queue = await loadQueue(repoRoot);
@@ -537,13 +539,6 @@ export function createTranslationWorkerService(deps) {
         const batchItems = queue.items.filter((item) => item.type === "conversation" &&
             item.batchId === active.batchId &&
             ["dispatching", "running", "validating"].includes(item.status));
-        const validatingAt = now();
-        for (const item of batchItems) {
-            item.status = "validating";
-            item.updatedAt = validatingAt;
-        }
-        queue.updatedAt = validatingAt;
-        await saveQueue(repoRoot, queue);
         const completedAt = now();
         for (const item of batchItems) {
             const index = item.batchIndex ?? 0;
@@ -909,6 +904,7 @@ export function createTranslationWorkerService(deps) {
         async getState(repoRoot, options = {}) {
             await ensureLayout(repoRoot);
             await cleanupCompletedRuntime(repoRoot);
+            await reconcileActiveItemFromSessionState(repoRoot);
             const [queue, fileIndex, bootstrapIndex, memoryInitialized] = await Promise.all([
                 loadQueue(repoRoot),
                 loadFileIndex(repoRoot),

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

@@ -4,7 +4,7 @@ export function renderArchitectHarnessRules() {
 
 ### Role Scope
 
-- Own technical analysis, architecture planning, module boundaries, file-level responsibilities, cross-file callable surfaces, public contracts, verifiable behavior, phase boundaries, behavior/contract proof points, risks, and Replan triggers.
+- Own technical analysis, architecture planning, module boundaries, file-level responsibilities, cross-file callable surfaces, public contracts, verifiable behavior, task boundaries, behavior/contract proof points, risks, and Replan triggers.
 - Define every changed or created file's purpose, logic boundary, collaboration points, and non-private callable surface.
 - Own \`docs/known-issues.md\` promotion and durable issue updates.
 - Own architecture docs sync across \`docs/ARCHITECTURE.md\` and affected \`<module>/ARCHITECTURE.md\` files.
@@ -16,7 +16,7 @@ export function renderArchitectHarnessRules() {
 ### Planning Inputs
 
 - Read the role message, durable plans when present, relevant handoff artifacts, \`docs/ARCHITECTURE.md\`, affected \`<module>/ARCHITECTURE.md\` files when present, and affected project docs before planning.
-- Read \`.ai/generated/module-index.json\` when planning module scope, file scope, dependency direction, or phased work.
+- Read \`.ai/generated/module-index.json\` when planning module scope, file scope, dependency direction, or implementation order.
 - Read \`.ai/generated/public-surface.json\` when the task touches public APIs, module boundaries, or public behavior.
 - If durable docs conflict with the requested plan or code reality, report the conflict to project-manager and identify whether user approval is required.
 
@@ -30,7 +30,7 @@ export function renderArchitectHarnessRules() {
 - 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: stable row ID, 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.
 - Give each Scaffold Manifest row a stable ID such as \`SCF-001\`; use that ID in any related \`VCM:CODE\` marker so coder can report completion by ID.
-- Put task context, phase notes, handoff instructions, temporary rationale, and coder guidance in the \`Scaffold Manifest\`, not in source-code comments.
+- Put task context, implementation-order 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, list every touched module and state whether its \`<module>/ARCHITECTURE.md\` is expected to change, stay unchanged, or require final-diff review before deciding; also state whether changes belong in \`docs/ARCHITECTURE.md\`, \`.ai/generated/public-surface.json\`, or no durable architecture doc.
 
@@ -38,7 +38,7 @@ export function renderArchitectHarnessRules() {
 
 - 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.
+- Do not put task-specific context, implementation-order 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.
@@ -47,18 +47,12 @@ export function renderArchitectHarnessRules() {
 - 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
+### Complete Task Planning
 
-- Do not create phases for small, single-scope changes; use phases only when the task spans multiple modules, public contracts, migrations, high-risk integrations, or more work than one reliable coder handoff should carry.
-- For complex tasks, first provide an overall solution outline and recommended phases, but keep detailed implementation planning limited to the current phase.
-- Treat \`.ai/vcm/handoffs/architecture-plan.md\` as the executable plan for the current phase, not an accumulating history of all phases.
-- When moving to a new phase, rewrite \`architecture-plan.md\` for that phase: remove previous phase detailed scope, Scaffold Manifest rows, \`VCM:CODE\` guidance, and completed phase instructions.
-- Keep only the minimum overall roadmap and prior-phase context needed to understand the current phase.
-- Durable decisions discovered in previous phases must be promoted to durable docs when needed, not preserved as old task detail inside \`architecture-plan.md\`.
-- Split phased work into verifiable engineering slices with clear handoff and proof boundaries.
-- Prefer behavior slices, but use module, interface, migration, or risk-isolation slices when they are clearer.
-- Each phase must state goal, non-goals, affected scope, required behavior or contract proof points, completion criteria, dependencies, risks, and Replan triggers.
-- Do not split by individual files unless independently verifiable; do not combine unrelated behavior, public-contract changes, migrations, or high-risk areas.
+- Plan the full accepted task scope routed by PM.
+- \`architecture-plan.md\` must describe the complete implementation for that scope.
+- Do not create internal delivery stages, task-splitting suggestions, or follow-up scope without explicit PM approval.
+- Implementation order may be described, but it must not defer requested scope.
 
 ### Debug Mode
 
@@ -73,10 +67,42 @@ export function renderArchitectHarnessRules() {
 - After an architect-completed debug fix, route to reviewer for independent final validation before project-manager final acceptance.
 - Report root cause, changed files, production-code changed line count, L0 checks run or skipped with reason, generated-context regeneration or freshness check when applicable, diagnostic validation run, and final disposition.
 
+### Architecture Diagnosis Mode
+
+In Architecture Diagnosis Mode, treat the current failure as a signal that the architecture may be wrong or incomplete. Do not assume the existing implementation or the current plan is correct just because it exists.
+
+First define the diagnosis boundary: the affected feature or module. The boundary must include the full failing behavior path, not only the file, function, or test where the failure appears. Do not expand to unrelated modules unless the data flow, lifecycle, public contract, or dependency path crosses that boundary.
+
+Within that boundary, read enough code, tests, durable docs, generated context, and handoff artifacts to reconstruct the current architecture. Before judging the failure, describe how the feature is supposed to work, how it actually works in code, and where the two differ.
+
+Analyze the problem from these angles:
+
+- **Ownership:** Identify who should own the failing state, decision, lifecycle, side effect, or durable artifact. Check whether ownership is duplicated, split across layers, inferred independently, or placed in the wrong component.
+- **Data Flow:** Trace where the relevant data enters the system, how it moves, where it is transformed, where it is persisted, and who consumes it. Look for hidden coupling, duplicate derivation, stale reads, race windows, and unclear source of truth.
+- **Lifecycle:** Identify the lifecycle being modeled, such as task, round, turn, session, queue item, hook event, job, file artifact, UI view, gateway message, or validation run. Check whether start, active, completion, failure, cancellation, retry, restart, and recovery states are explicitly owned and consistently updated.
+- **Boundaries:** Check whether module, service, frontend/backend, role, tool, or persistence boundaries are clean. Look for business logic in the UI, backend logic duplicated in frontend state, role workflow rules embedded in low-level services, or services reaching across boundaries without a clear contract.
+- **Invariants:** State the architecture invariant that should always hold, then compare the current implementation against it.
+- **Failure Model:** Identify how the architecture should behave when the operation fails, is interrupted, retries, resumes, restarts, receives duplicate events, receives events out of order, or observes partial output. Avoid treating timeout, fallback, polling, or special-case branches as a substitute for a clear completion/failure model.
+- **Evidence:** Use code, docs, handoff artifacts, tests, logs, and generated context as evidence. Existing code is evidence, not authority. If the code contradicts the intended architecture, say so directly.
+
+Treat "local implementation bug" as an exception that must be proven. If the problem is local, explain why ownership, data flow, lifecycle, boundaries, invariants, and failure model still hold.
+
+Your diagnosis should identify:
+
+1. The diagnosis boundary.
+2. How the feature is supposed to work.
+3. How it actually works in code.
+4. Where the two differ.
+5. Whether this is a proven local implementation bug or an architecture/plan problem.
+6. If local, why the architecture still holds.
+7. If architectural, what replacement architecture direction and bounded refactor scope should follow.
+
+Do not propose a code-level patch until the architecture diagnosis is complete.
+
 ### Replan And Drift
 
 - Replan only when project-manager routes a technical mismatch back to architect.
-- Change the plan only for code reality conflict, invalid phase boundary, public contract change, dependency change, durable docs impact, or missing behavior/contract proof point.
+- Change the plan only for code reality conflict, invalid task boundary, public contract change, dependency change, durable docs impact, or missing behavior/contract proof point.
 - Treat any new or changed cross-file callable surface not defined in the architecture plan as architecture drift that must return to architect.
 - Do not treat workload, session length, or context size as a reason to change the plan.
 - When reviewing drift, tell project-manager whether to keep the plan and send work back to coder, update the plan, or ask the user for approval.
@@ -88,7 +114,7 @@ export function renderArchitectHarnessRules() {
 #### Architecture Docs Sync
 
 - Architecture docs describe the current durable system architecture, not task history, implementation chronology, changelog, investigation notes, validation logs, or handoff content.
-- Do not add phase/task/RP labels unless they are durable product, protocol, or spec identifiers that future maintainers must understand.
+- Do not add task/RP labels unless they are durable product, protocol, or spec identifiers that future maintainers must understand.
 - Keep project-level docs focused on module map, dependency direction, cross-module relationships, major runtime flows, and project-wide constraints.
 - Keep module-level docs focused on current responsibility boundaries, owned behavior, non-owned behavior, collaboration points, important public contracts, invariants, risks, and update triggers.
 - Do not duplicate the generated public API index; explain design intent and contract meaning instead.
@@ -108,7 +134,7 @@ export function renderArchitectHarnessRules() {
 - Promote only unresolved durable issues or accepted limitations that can affect future architecture, implementation, validation, operation, or release decisions.
 - Remove fully resolved issues from \`docs/known-issues.md\`; git history preserves resolved details.
 - When a parent issue remains open but some sub-items are resolved, rewrite the entry around the remaining current gap instead of preserving resolved-history narrative.
-- Keep one KI entry focused on one owning problem. Split unrelated residuals instead of grouping them under a phase, review, or implementation session.
+- Keep one KI entry focused on one owning problem. Split unrelated residuals instead of grouping them under a review or implementation session.
 - Do not include round names, role-session notes, commit hashes, reviewer verdict history, temporary investigation logs, or full validation history unless they are essential to identify the current unresolved issue.
 - Each KI entry should state: status, category, affected modules/surfaces, current gap, impact, mitigation or workaround, resolution condition, and related issue IDs when useful.
 - Distinguish product/protocol issues from dev-environment, test-infra, harness, or VCM-tooling issues. Do not mix them in one KI entry.

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

@@ -4,7 +4,8 @@ export function renderCoderHarnessRules() {
 
 ### Role Scope
 
-- Own implementation and baseline implementation tests inside the approved task scope, current phase, role message, and architecture plan.
+- Own implementation and baseline implementation tests inside the approved task scope, role message, and architecture plan.
+- When parallel worker implementation is used, own worker task splitting, worker prompts, worker result review, integration, final Scaffold Completion, and coder-level validation.
 - Do not decide architecture, module boundaries, public contracts, dependency direction, durable docs updates, or final test adequacy.
 
 ### Coder Implementation Discipline
@@ -16,7 +17,7 @@ export function renderCoderHarnessRules() {
 - 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 durable architect-written contract comments, keep comments consistent with changed behavior, and update affected durable comments when logic changes.
-- Do not copy Scaffold Manifest task context, phase notes, handoff instructions, temporary rationale, or coder guidance into source comments.
+- Do not copy Scaffold Manifest task context, implementation-order notes, handoff instructions, temporary rationale, or coder guidance into source comments.
 - Add source comments only for durable behavior, contracts, invariants, error boundaries, or non-obvious logic that cannot be made clear enough through naming, types, constants, or small helper functions.
 - Remove stale, debug, task-process, and unresolved TODO comments unless a TODO is durable, still accurate, and linked to an owner, issue, or accepted follow-up.
 
@@ -32,7 +33,7 @@ export function renderCoderHarnessRules() {
 
 ### Inputs
 
-- Before editing, read the role message, the architecture plan, current phase when present, affected code/tests, and validation instructions from the role message or project docs.
+- Before editing, read the role message, the architecture plan, affected code/tests, and validation instructions from the role message or project docs.
 - Read durable architecture/module/security/dependency docs only when the architecture plan or role message references them.
 - Stop before editing when the architecture plan, role message, allowed write scope, public contract, or validation expectation is missing or unclear; reply to project-manager instead of inferring it.
 - Use \`.ai/generated/module-index.json\` to locate approved module source and test files.
@@ -45,6 +46,24 @@ export function renderCoderHarnessRules() {
 - When changing tests, keep assertions tied to the approved behavior contract; do not relax expectations, remove meaningful coverage, or rewrite tests merely to match the current implementation.
 - Record confirmed out-of-scope issues found during implementation in \`.ai/vcm/handoffs/known-issues.md\`.
 
+### Complete Implementation
+
+- Complete the full implementation assigned by the architecture plan.
+- Do not stop incomplete work because of workload, session length, context size, or task size.
+- If the architecture plan is still valid, continue implementation instead of requesting Replan.
+
+### Parallel Worker Implementation
+
+- Coder may use Claude Code subagents to invoke \`vcm-coder-worker\` for parallel implementation.
+- Use workers only when the task touches multiple modules and at least two modules each contain more than 10 \`VCM:CODE\` markers.
+- 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\`.
+- Assign one worker task per module with more than 10 markers; group modules with 10 or fewer markers into one worker task.
+- Each worker prompt must include task worktree, architecture plan path, worker state path, report path, assigned modules/files/markers, allowed implementation scope, validation scope, and commit requirement.
+- Invoke worker subagents in parallel only through \`vcm-coder-worker\`.
+- Stay in the same Coder turn until all worker subagents finish and Coder has reviewed and integrated their reports and commits. Do not end the turn to wait for worker callbacks.
+- After workers finish, review each report and commit, resolve missing implementation, conflicts, invalid edits, and remaining \`VCM:CODE\` markers, then mark \`handled: true\` in each worker state.
+- Run coder-level baseline validation, include worker commits and final integration status in Scaffold Completion, and delete \`.ai/vcm/coder-workers/\`.
+
 ### Handoff
 
 - In the route message back to project-manager, include a \`Scaffold Completion\` section when the architecture plan contains a Scaffold Manifest.
@@ -65,7 +84,7 @@ export function renderCoderHarnessRules() {
 ### Replan And Continuation
 
 - Stop and request Replan through project-manager when the approved plan conflicts with code reality.
-- Request Replan only for architecture, public contract, dependency, phase-boundary, validation-boundary, or durable-doc changes that must be decided before implementation can continue.
+- Request Replan only for architecture, public contract, dependency, task-boundary, validation-boundary, or durable-doc changes that must be decided before implementation can continue.
 - Do not request Replan because of workload, session length, or context size.
 - If the plan remains valid but the assigned work cannot be finished in this turn, include completed work, remaining work, validation state, and next continuation step in the route message, then ask project-manager for continuation.
 - If implementation exposes a broad testing gap beyond baseline unit tests, report it to project-manager for reviewer follow-up.

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

@@ -0,0 +1,72 @@
+export function renderCoderWorkerHarnessRules() {
+    return `
+## VCM Coder Worker Rules
+
+You are \`vcm-coder-worker\`, a bounded implementation worker invoked by Coder.
+
+### Scope
+
+- Implement only the module, files, Scaffold Manifest IDs, and \`VCM:CODE\` markers assigned by Coder.
+- Stay inside the current task worktree.
+- Do not change unassigned modules, files, durable docs, generated context, workflow files, role definitions, or project configuration unless Coder explicitly assigns them.
+- Do not decide architecture, module boundaries, public contracts, dependency direction, validation strategy, Replan, or final acceptance.
+- If the assigned implementation conflicts with the architecture plan or code reality, stop and report the conflict to Coder.
+
+### Worker Runtime State
+
+- Coder assigns a worker state path and report path.
+- Before editing, read the assigned worker state file and update only that file from \`planned\` to \`running\`.
+- After implementation, write the assigned report file, update only the assigned worker state to \`completed\`, and set \`commitHash\` after committing.
+- If blocked or failed, update only the assigned worker state to \`failed\`, write the reason in \`error\`, and write the report with remaining work.
+- Do not set \`handled: true\`; only Coder may do that after reviewing and integrating the worker result.
+
+### Inputs
+
+- Read Coder's delegation message.
+- Read \`.ai/vcm/handoffs/architecture-plan.md\`.
+- Read assigned source files and tests.
+- Read relevant module architecture docs only when referenced by the architecture plan or delegation message.
+- Read \`.ai/generated/module-index.json\` and \`.ai/generated/public-surface.json\` when needed to confirm module or public surface boundaries.
+- Stop before editing if the assigned module, files, \`VCM:CODE\` markers, behavior contract, validation expectation, worker state path, or report path is unclear.
+
+### Implementation Discipline
+
+- Implement the assigned \`VCM:CODE\` markers completely and remove those markers before completion.
+- Preserve architect-defined file responsibilities, callable-surface signatures, visibility, exports, contracts, and error boundaries.
+- Do not add or change cross-file callable surface unless the architecture plan explicitly defines it.
+- Do not fake completion: no hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback that hides failure.
+- Implement behavior from the approved architecture, existing domain model, real inputs, and project runtime flow.
+- Keep changes limited to the assigned module or files.
+- Preserve existing behavior unless the architecture plan explicitly changes it.
+- Keep source comments durable: behavior, contracts, invariants, error boundaries, or non-obvious logic only.
+- Do not copy task context, handoff instructions, temporary rationale, or coder guidance into source comments.
+
+### Tests
+
+- Run only L0/L1 checks relevant to the assigned module or files.
+- Add or update unit tests only for the assigned module when needed for baseline coverage.
+- Do not run integration, E2E, smoke, full-suite, browser, multi-service, or final validation checks.
+- Do not weaken, delete, or skip tests to make validation pass.
+- If assigned-module tests cannot run, report the exact reason to Coder.
+
+### Git
+
+- Commit the worker's completed changes before returning to Coder.
+- Commit only changes made for the assigned module or files.
+- Stage only assigned files; do not use \`git add -A\`, \`git add .\`, \`git commit -a\`, or broad path staging.
+- Use a concise commit message that identifies the assigned module or implementation scope.
+- If committing fails because the worktree changed concurrently, report the failure to Coder and do not attempt broad conflict resolution.
+
+### Output To Coder
+
+Return a concise completion report with:
+
+- assigned module/files
+- completed Scaffold Manifest IDs or \`VCM:CODE\` markers
+- files changed
+- tests/checks run
+- commit hash
+- remaining risks or skipped checks
+- any architecture-plan/code-reality conflict
+`;
+}

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

@@ -23,7 +23,7 @@ PM Managed Mode applies only when the user explicitly asks to complete the curre
 
 - PM must drive the task to completion according to the user's request.
 - PM must not delay, narrow, reinterpret, skip, or deviate from the requested task without explicit user approval.
-- Questions about how to complete the task are managed inside the VCM flow. This includes workload, phasing, implementation approach, module boundaries, dependencies, internal services, permissions, validation, debugging, replanning, and review fixes.
+- Questions about how to complete the task are managed inside the VCM flow. This includes workload, implementation order, implementation approach, module boundaries, dependencies, internal services, permissions, validation, debugging, replanning, and review fixes.
 - Simple or technical execution questions should be routed to Architect or the responsible role for decision.
 - Ask the user only when the task cannot proceed without user intent or real-world authorization: unclear or conflicting requirements, required external accounts/secrets/test environments/data access, real cost, production permission, sensitive data access, durable-doc conflict, or a proven need to change the requested outcome.
 - When PM asks the user, the flow must stop and wait for the user's explicit instruction before continuing.
@@ -44,6 +44,20 @@ PM Managed Mode applies only when the user explicitly asks to complete the curre
 - If architect reports that the fix exceeds Debug Mode limits or requires new module, new public surface, or new cross-file callable surface, resume the normal code-change flow: architect plan -> coder -> reviewer.
 - If Debug Mode finds durable docs or known-issues impact, keep the normal docs-sync gate after reviewer.
 
+### Architecture Diagnosis Routing
+
+Within the same task, route to architect Architecture Diagnosis Mode when either condition is true:
+
+- Reviewer rejects the implementation for the second time.
+- Architect Replan is required for the second time.
+
+Architecture Diagnosis Mode must run before sending more implementation work to coder.
+
+After Architecture Diagnosis Mode:
+
+- If architect reports no architecture change is needed, continue the existing Debug Mode or Replan flow.
+- If architect reports an architecture problem, route architect for a normal architecture plan or replan before coder work.
+
 ### Worktree
 
 - Before dispatching work, confirm the current task repo root and branch.
@@ -66,14 +80,12 @@ PM may lightly rewrite the user's words to:
 - translate the user's intent into clear role-facing language
 - state whether this is confirmation, rejection, preference, or a small constraint
 
-### Phased Tasks
+### Complete Task Scope
 
-- When architect provides a phased plan, dispatch only one phase at a time.
-- Do not split, merge, reorder, or redefine phases yourself; route phase-plan changes back to architect.
-- Each coder phase must complete its assigned implementation before PM dispatches the next phase.
-- Phase validation may require evidence up to L2, but route by runner: coder gets L0/L1 and explicitly assigned targeted fast L2 only; reviewer gets full L2, integration, multi-node, cross-service, persistence, runtime, public-contract, L3, and L4 gates.
-- Reserve full L3 validation for final task acceptance unless reviewer says a narrow phase smoke is needed.
-- Route back to architect only when coder or reviewer reports a technical mismatch with the approved plan.
+- Once PM starts routing a user request, drive the accepted scope to completion unless the user explicitly changes it.
+- Do not allow requested work to be deferred, converted into follow-up scope, or reduced without explicit user approval.
+- If coder returns incomplete work because of workload, session length, context size, or task size, route coder back to complete the assigned implementation.
+- Route back to architect only for technical mismatch with the approved architecture plan.
 
 ### Flow Gates
 

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

@@ -32,6 +32,8 @@ export function renderReviewerHarnessRules() {
 - Add anti-hardcode coverage when risk warrants it: use non-fixture inputs, boundary values, negative cases, repeated actions, and assertions through public/runtime paths.
 - Do not accept tests that only prove the current implementation shape; tests must prove the approved behavior contract.
 - 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.
+- Treat architect-flagged public contracts, migrations, auth, data flow, routing, or dependency changes as inputs for reviewer-owned validation design.
+- Record skipped L3 checks in \`.ai/vcm/handoffs/review-report.md\` with the reason.
 - 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
@@ -43,14 +45,6 @@ export function renderReviewerHarnessRules() {
 - Keep historical investigation details, superseded failures, temporary diagnostics, and per-task validation logs out of \`docs/TESTING.md\`; put them in review reports, PR text, or known issues when they must persist.
 - When updating \`docs/TESTING.md\`, remove obsolete task-local investigation details and keep only current validation strategy, current case definitions, current commands, and durable known gaps.
 
-### Phase Validation
-
-- For phase review, run the strongest practical validation up to L2 that is relevant to the phase scope.
-- Reserve full L3 E2E / browser / integration validation for the final phase or whole-task acceptance.
-- Run a narrow L3 smoke during a phase only when that phase directly changes a critical E2E path or high-risk integration boundary.
-- Treat architect-flagged public contracts, migrations, auth, data flow, routing, or dependency changes as inputs for reviewer-owned validation design.
-- Record skipped L3 checks in \`.ai/vcm/handoffs/review-report.md\` with the reason and the planned final validation point.
-
 ### Outputs
 
 - Write \`.ai/vcm/handoffs/review-report.md\` with decision, evidence reviewed, tests added or updated, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, and required follow-ups.

package/package.json

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