vibe-coding-master 0.7.16 → 0.7.17

package/README.md

@@ -228,6 +228,18 @@ such as a Dev Container or VM.
 Model and effort can be selected before start/resume/restart. Changes affect the
 next launched process, not a currently running Claude Code process.
 
+## Usage Analytics
+
+Open `Usage Analytics` in the sidebar `Task` section to inspect native Claude
+Code usage for the active task. The report shows task totals and breakdowns by
+role and model for input, output, cache-read, and cache-creation tokens plus
+estimated USD cost. It combines every restart and resumed Claude session for
+all seven roles. CCR/GPT usage is excluded.
+
+VCM retains only aggregate task data in
+`<task-worktree>/.ai/vcm/telemetry/usage.json`. The file is temporary runtime
+state and is removed with the task worktree when the task is closed.
+
 ### GPT Through Claude Code Router
 
 VCM can launch its normal Claude Code sessions with `GPT-5.6 Sol (CCR)` through

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

@@ -18,7 +18,7 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride) {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt) {
             const args = ["--agent", role];
             const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {
@@ -39,6 +39,9 @@ export function createClaudeAdapter(runner) {
             if (permissionMode !== "default") {
                 args.push("--permission-mode", permissionMode);
             }
+            if (appendSystemPrompt) {
+                args.push("--append-system-prompt", appendSystemPrompt);
+            }
             return {
                 command,
                 args,

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

@@ -10,6 +10,11 @@ export function registerSessionRoutes(app, deps) {
         const role = parseRole(request.params.role);
         return deps.sessionService.startRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
+    app.post("/api/tasks/:taskSlug/sessions/architect/restart-after-planning", async (request, reply) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const result = await deps.architectRestartService.schedule(project.repoRoot, request.params.taskSlug);
+        return reply.code(202).send(result);
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

package/dist/backend/api/usage-analytics-routes.js

@@ -0,0 +1,31 @@
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
+export function registerUsageAnalyticsRoutes(app, deps) {
+    app.post("/api/telemetry/v1/logs", async (request) => {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            return {};
+        }
+        const tasks = await deps.taskService.listTasks(project.repoRoot);
+        const activeTask = tasks.find((task) => task.cleanupStatus !== "cleaned");
+        if (!activeTask) {
+            return {};
+        }
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        await deps.usageAnalyticsService.ingest(getTaskRuntimeRepoRoot(activeTask), config.stateRoot, request.body);
+        return {};
+    });
+    app.get("/api/tasks/:taskSlug/usage-analytics", async (request) => {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: "Connect a repository before loading task usage analytics.",
+                statusCode: 409
+            });
+        }
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        return deps.usageAnalyticsService.getReport(getTaskRuntimeRepoRoot(task), config.stateRoot, task.taskSlug);
+    });
+}

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

@@ -7,6 +7,7 @@ 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 { renderArchitectScaffoldWorkerHarnessRules } from "../templates/harness/architect-scaffold-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";
@@ -27,6 +28,7 @@ import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
+import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
 import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
@@ -59,7 +61,8 @@ const AGENT_FRONTMATTER = {
         description: "User-facing VCM orchestration role for task clarification, role routing, handoffs, acceptance, and PR preparation."
     },
     architect: {
-        description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."
+        description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.",
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
@@ -81,6 +84,11 @@ const AGENT_FRONTMATTER = {
     "vcm-coder-worker": {
         description: "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.",
         model: "inherit"
+    },
+    "vcm-architect-scaffold-worker": {
+        description: "Foreground Architect worker for exact scaffold execution and scaffold validation.",
+        model: "opus",
+        effort: "xhigh"
     }
 };
 const MANAGED_FILES = [
@@ -195,6 +203,14 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "agent-coder-worker",
         content: renderCoderWorkerHarnessRules()
+    },
+    {
+        path: ".claude/agents/vcm-architect-scaffold-worker.md",
+        title: "VCM Architect Scaffold Worker Agent",
+        agentName: "vcm-architect-scaffold-worker",
+        commentStyle: "html",
+        category: "agent-architect-scaffold-worker",
+        content: renderArchitectScaffoldWorkerHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -284,6 +300,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Propose Memory Skill", "vcm-propose-memory", "Use only when VCM requests a role memory proposal during Task Harness Review.", renderVcmProposeMemorySkillRules())
     },
+    {
+        path: ".claude/skills/restart-architect/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("Restart Architect Skill", "restart-architect", "Use after Architect completes and commits architecture planning and scaffold work.", renderRestartArchitectSkillRules())
+    },
     {
         path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
@@ -302,6 +324,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderCheckScaffoldLedgerTool()
     },
+    {
+        path: ".ai/tools/request-architect-restart",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderRequestArchitectRestartTool()
+    },
     {
         path: ".ai/tools/run-long-check",
         category: "runtime-tool",
@@ -526,6 +554,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-gate-review/",
         ".claude/skills/vcm-report-harness-issue/",
         ".claude/skills/vcm-propose-memory/",
+        ".claude/skills/restart-architect/",
         ".ai/vcm/translations/",
         ".ai/vcm/gate-reviews/",
         ".ai/tools/",
@@ -586,6 +615,9 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     if (definition.memoryBlock) {
         nextContent = ensureVcmMemoryBlock(nextContent);
     }
+    if (definition.agentName === "architect") {
+        nextContent = ensureAgentTool(nextContent, "Agent");
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -627,10 +659,27 @@ function renderNewManagedFile(definition, block) {
         const frontmatter = AGENT_FRONTMATTER[definition.agentName];
         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}${suffix ? `\n\n${suffix}` : ""}\n`;
+        const effort = frontmatter.effort ? `\neffort: ${frontmatter.effort}` : "";
+        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}${effort}\n---\n\n# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
     }
     return `# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
 }
+function ensureAgentTool(content, requiredTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content.replace(/^(---\r?\n[\s\S]*?)(\r?\n---)/, `$1\ntools: ${requiredTool}$2`);
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    if (tools.includes(requiredTool)) {
+        return content;
+    }
+    const nextTools = [...tools, requiredTool].join(", ");
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

package/dist/backend/server.js

@@ -12,6 +12,7 @@ import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
+import { createArchitectRestartService } from "./services/architect-restart-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -42,6 +43,7 @@ import { createTaskWorkflowService } from "./services/task-workflow-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createUsageAnalyticsService } from "./services/usage-analytics-service.js";
 import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
@@ -57,6 +59,7 @@ import { registerRuntimeStateRoutes } from "./api/runtime-state-routes.js";
 import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
+import { registerUsageAnalyticsRoutes } from "./api/usage-analytics-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
 import { toVcmError } from "./errors.js";
 import { readVcmPackageVersion } from "./app-version.js";
@@ -132,7 +135,8 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         commandDispatcher: deps.commandDispatcher,
         translationService: deps.translationService,
-        roundService: deps.roundService
+        roundService: deps.roundService,
+        architectRestartService: deps.architectRestartService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -155,6 +159,11 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         translationService: deps.translationService
     });
+    registerUsageAnalyticsRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        usageAnalyticsService: deps.usageAnalyticsService
+    });
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
     registerTerminalWs(app, {
         runtime: deps.runtime,
@@ -264,12 +273,18 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         artifactService
     });
+    const architectRestartService = createArchitectRestartService({
+        fs,
+        taskService,
+        sessionService
+    });
     const messageService = createMessageService({
         fs,
         runtime,
         sessionService,
         taskService,
-        taskWorkflowService
+        taskWorkflowService,
+        onRouteDelivered: ({ repoRoot, taskSlug, message }) => architectRestartService.recordRouteDelivered(repoRoot, taskSlug, message)
     });
     const taskLaunchService = createTaskLaunchService({
         projectService,
@@ -312,6 +327,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         appSettings
     });
+    const usageAnalyticsService = createUsageAnalyticsService({ fs });
     const gatewayChannels = createGatewayChannelRegistry([
         createWeixinIlinkChannel(),
         createLarkChannel()
@@ -331,7 +347,8 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         roundService,
         projectService,
-        taskWorkflowService
+        taskWorkflowService,
+        architectRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -368,7 +385,8 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),
-        translationWorkerService
+        translationWorkerService,
+        architectRestartService
     });
     const turnReconciler = createTurnReconcilerService({
         sessionService,
@@ -412,6 +430,7 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         taskCloseService,
         taskWorkflowService,
+        architectRestartService,
         sessionService,
         artifactService,
         harnessService,
@@ -431,7 +450,8 @@ export function createDefaultServerDeps(options = {}) {
         runtimeRecoveryService,
         terminalInterruptService,
         runtime,
-        diagnosticsService
+        diagnosticsService,
+        usageAnalyticsService
     };
 }
 export function getDefaultStaticDir() {

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

@@ -0,0 +1,136 @@
+import path from "node:path";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const ARCHITECT_ROLE = "architect";
+const PM_ROLE = "project-manager";
+const COMPLETE_PLAN_PATTERN = /^Planning Result:\s*complete\s*$/im;
+export const ARCHITECT_RESTORE_PROMPT = `This Architect session continues the current task after completed architecture planning.
+
+Before performing any assigned work, read:
+- .ai/vcm/handoffs/architecture-brief.md
+- .ai/vcm/handoffs/architecture-evidence.md
+- .ai/vcm/handoffs/architecture-plan.md
+- the current scaffold commit and worktree state
+- the latest Gate Review report when present
+
+Treat the current artifacts and worktree as the source of truth. Do not repeat the completed interview or planning work unless current evidence contradicts them.`;
+export function createArchitectRestartService(deps) {
+    const pendingByTask = new Map();
+    return {
+        async schedule(repoRoot, taskSlug) {
+            const session = await requireRunningArchitect(repoRoot, taskSlug);
+            await requireCompletePlan(repoRoot, taskSlug);
+            const key = taskKey(repoRoot, taskSlug);
+            const existing = pendingByTask.get(key);
+            if (existing?.sessionId === session.id) {
+                return { taskSlug, sessionId: session.id, status: "scheduled" };
+            }
+            pendingByTask.set(key, {
+                repoRoot,
+                taskSlug,
+                sessionId: session.id,
+                stopped: false,
+                executing: false
+            });
+            return { taskSlug, sessionId: session.id, status: "scheduled" };
+        },
+        async recordArchitectStop(repoRoot, taskSlug, sessionId) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending || pending.sessionId !== sessionId) {
+                return;
+            }
+            pending.stopped = true;
+            await tryRestart(pending);
+        },
+        async recordRouteDelivered(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.deliveredMessageId = message.id;
+            await tryRestart(pending);
+        },
+        async recordRouteAccepted(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.acceptedMessageId = message.id;
+            await tryRestart(pending);
+        },
+        clear(repoRoot, taskSlug) {
+            pendingByTask.delete(taskKey(repoRoot, taskSlug));
+        }
+    };
+    async function requireRunningArchitect(repoRoot, taskSlug) {
+        const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+        if (!session || session.status !== "running") {
+            throw new VcmError({
+                code: "ARCHITECT_SESSION_NOT_RUNNING",
+                message: "Architect session is not running.",
+                statusCode: 409
+            });
+        }
+        return session;
+    }
+    async function requireCompletePlan(repoRoot, taskSlug) {
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        const planPath = resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(task.handoffDir, "architecture-plan.md"));
+        if (!(await deps.fs.pathExists(planPath))) {
+            throw incompletePlanError("architecture-plan.md does not exist.");
+        }
+        const content = await deps.fs.readText(planPath);
+        if (!COMPLETE_PLAN_PATTERN.test(content)) {
+            throw incompletePlanError("architecture-plan.md is not marked complete.");
+        }
+    }
+    async function tryRestart(pending) {
+        if (pending.executing
+            || !pending.stopped
+            || !pending.deliveredMessageId
+            || pending.deliveredMessageId !== pending.acceptedMessageId) {
+            return;
+        }
+        const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
+        if (!session
+            || session.id !== pending.sessionId
+            || session.status !== "running"
+            || session.activityStatus !== "idle") {
+            return;
+        }
+        pending.executing = true;
+        try {
+            await requireCompletePlan(pending.repoRoot, pending.taskSlug);
+            await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
+                permissionMode: session.permissionMode,
+                model: session.model,
+                effort: session.effort,
+                appendSystemPrompt: ARCHITECT_RESTORE_PROMPT
+            });
+            pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
+        }
+        catch {
+            pending.executing = false;
+        }
+    }
+}
+function isArchitectToPm(message) {
+    return message.fromRole === ARCHITECT_ROLE && message.toRole === PM_ROLE;
+}
+function taskKey(repoRoot, taskSlug) {
+    return `${repoRoot}\0${taskSlug}`;
+}
+function incompletePlanError(reason) {
+    return new VcmError({
+        code: "ARCHITECT_PLAN_INCOMPLETE",
+        message: `Architect restart cannot be scheduled. ${reason}`,
+        statusCode: 409
+    });
+}

package/dist/backend/services/claude-hook-service.js

@@ -227,6 +227,9 @@ export function createClaudeHookService(deps) {
             role: input.role,
             prompt: stringOrUndefined(input.event.prompt)
         });
+        if (submitted) {
+            await deps.architectRestartService?.recordRouteAccepted(context.project.repoRoot, context.taskSlug, submitted);
+        }
         return {
             ok: true,
             eventName,
@@ -437,6 +440,9 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
+        if (eventName === "Stop" && input.role === "architect" && session) {
+            await deps.architectRestartService?.recordArchitectStop(context.project.repoRoot, context.taskSlug, session.id);
+        }
         if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,

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

@@ -56,6 +56,7 @@ const CODE_DIFF_ANALYSIS_FIELDS = [
 const SOURCE_ARTIFACTS = {
     "architecture-plan": [
         ".ai/vcm/handoffs/architecture-brief.md",
+        ".ai/vcm/handoffs/architecture-evidence.md",
         ".ai/vcm/handoffs/architecture-plan.md"
     ],
     "validation-adequacy": [
@@ -228,6 +229,30 @@ export function createGateReviewService(deps) {
                     message: architectureBriefError
                 };
             }
+            const architectureEvidenceError = await readArchitectureEvidenceError(deps.fs, context.taskRepoRoot);
+            if (architectureEvidenceError) {
+                index = applyGateState(index, gate, {
+                    status: "failed",
+                    decision: undefined,
+                    error: architectureEvidenceError,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: now(),
+                    callbackStatus: "not_sent",
+                    callbackError: undefined
+                }, now(), true);
+                await saveIndex(deps.fs, context.taskRepoRoot, index);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message: architectureEvidenceError
+                };
+            }
         }
         const coreInput = await readCoreInputArtifact(deps.fs, context.taskRepoRoot, gate);
         if (coreInput && coreInput.status !== "ready") {
@@ -961,6 +986,21 @@ async function readArchitectureBriefError(fs, taskRepoRoot) {
     }
     return undefined;
 }
+async function readArchitectureEvidenceError(fs, taskRepoRoot) {
+    const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
+    const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
+    if (!await fs.pathExists(absolutePath)) {
+        return `${relativePath} is missing. Complete architecture evidence before requesting architecture-plan review.`;
+    }
+    const content = await fs.readText(absolutePath);
+    if (content.trim().length === 0) {
+        return `${relativePath} is empty. Complete architecture evidence before requesting architecture-plan review.`;
+    }
+    if (!/^\s*Architecture Evidence Status\s*:\s*complete\s*$/im.test(content)) {
+        return `${relativePath} is incomplete. Finish current-worktree evidence before requesting architecture-plan review.`;
+    }
+    return undefined;
+}
 async function commandStdout(runner, cwd, args) {
     const result = await runner.run("git", args, { cwd });
     return result.exitCode === 0 ? result.stdout : "";

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

@@ -4,6 +4,7 @@ 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 { renderArchitectScaffoldWorkerHarnessRules } from "../templates/harness/architect-scaffold-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";
@@ -24,6 +25,7 @@ import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
+import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
@@ -172,6 +174,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmProposeMemorySkillRules
     },
+    {
+        kind: "skill-restart-architect",
+        path: ".claude/skills/restart-architect/SKILL.md",
+        title: "Restart Architect Skill",
+        frontmatter: renderSkillFrontmatter("restart-architect", "Use after Architect completes and commits architecture planning and scaffold work."),
+        ownership: "whole-file",
+        renderRules: renderRestartArchitectSkillRules
+    },
     {
         kind: "agent-gate-reviewer",
         path: ".claude/agents/gate-reviewer.md",
@@ -202,6 +212,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("vcm-coder-worker", "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.", { model: "inherit" }),
         renderRules: renderCoderWorkerHarnessRules
     },
+    {
+        kind: "agent-architect-scaffold-worker",
+        path: ".claude/agents/vcm-architect-scaffold-worker.md",
+        title: "VCM Architect Scaffold Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-architect-scaffold-worker", "Foreground Architect worker for exact scaffold execution and scaffold validation.", { model: "opus", effort: "xhigh" }),
+        renderRules: renderArchitectScaffoldWorkerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",
@@ -223,6 +240,13 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderCheckScaffoldLedgerTool
     },
+    {
+        kind: "tool-request-architect-restart",
+        path: ".ai/tools/request-architect-restart",
+        title: "Request Architect Restart Tool",
+        ownership: "raw-file",
+        renderRules: renderRequestArchitectRestartTool
+    },
     {
         kind: "agent-project-manager",
         path: ".claude/agents/project-manager.md",
@@ -237,7 +261,7 @@ const HARNESS_FILES = [
         title: "Architect Agent",
         memoryBlock: true,
         blankLineBeforeEnd: true,
-        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -1192,6 +1216,9 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
+        const nextContent = definition.kind === "agent-architect"
+            ? ensureAgentTool(insertedContent, "Agent")
+            : insertedContent;
         return {
             definition,
             status: {
@@ -1206,13 +1233,16 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
                 action: "insert",
                 reason: "File exists but does not contain VCM managed rules."
             },
-            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(insertedContent) : insertedContent
+            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(nextContent) : nextContent
         };
     }
     const managedVersion = match[1] ? Number(match[1]) : undefined;
     const currentBlock = match[0];
     const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
-    const nextContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
+    const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
+    const nextContent = definition.kind === "agent-architect"
+        ? ensureAgentTool(memoryUpdatedContent, "Agent")
+        : memoryUpdatedContent;
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1323,6 +1353,22 @@ function renderNewHarnessFile(definition, block, contentAfterBlock = definition.
     const suffix = contentAfterBlock?.trim();
     return `${frontmatter}# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
 }
+function ensureAgentTool(content, requiredTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content.replace(/^(---\r?\n[\s\S]*?)(\r?\n---)/, `$1\ntools: ${requiredTool}$2`);
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    if (tools.includes(requiredTool)) {
+        return content;
+    }
+    const nextTools = [...tools, requiredTool].join(", ");
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
+}
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {
@@ -1454,7 +1500,8 @@ function isPlainObject(value) {
 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---`;
+    const effort = options.effort ? `\neffort: ${options.effort}` : "";
+    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}${effort}\n---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;