vibe-coding-master 0.3.28 → 0.3.30

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

@@ -1,4 +1,4 @@
-import { isVcmRoleName } from "../../shared/constants.js";
+import { isGateReviewerRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -22,15 +22,62 @@ export function createClaudeHookService(deps) {
             });
         }
         const config = await deps.projectService.loadConfig(project.repoRoot);
-        const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
+        const taskSlug = await resolveHookTaskSlug(project.repoRoot, input);
+        const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return {
             project,
             config,
             task,
+            taskSlug,
             taskRepoRoot
         };
     }
+    async function getTranslatorHookContext() {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: "Connect a repository before accepting Translator hooks.",
+                statusCode: 409
+            });
+        }
+        return { project };
+    }
+    async function processTranslatorHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        const context = await getTranslatorHookContext();
+        const session = await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
+        };
+    }
+    async function resolveHookTaskSlug(repoRoot, input) {
+        if (!isGateReviewerRoleName(input.role)) {
+            return input.taskSlug;
+        }
+        const session = await deps.sessionService.getProjectGateReviewerSession(repoRoot);
+        if (session?.activeTaskSlug) {
+            return session.activeTaskSlug;
+        }
+        throw new VcmError({
+            code: "GATE_REVIEWER_TASK_UNBOUND",
+            message: "Gate Reviewer hook arrived without an active task binding.",
+            statusCode: 409,
+            hint: "Start or resume Gate Reviewer from the current task before submitting work."
+        });
+    }
     async function handleUserPromptSubmitHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         if (eventName !== "UserPromptSubmit") {
@@ -39,11 +86,11 @@ export function createClaudeHookService(deps) {
         const context = await getHookContext(input);
         deps.jobGuard?.notePromptSubmitted({
             repoRoot: context.project.repoRoot,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role
         });
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
@@ -54,7 +101,7 @@ export function createClaudeHookService(deps) {
             repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             eventName
         });
@@ -62,7 +109,7 @@ export function createClaudeHookService(deps) {
             await deps.translationService.recordConversationBoundary({
                 repoRoot: context.project.repoRoot,
                 taskRepoRoot: context.taskRepoRoot,
-                taskSlug: input.taskSlug,
+                taskSlug: context.taskSlug,
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "start",
@@ -75,14 +122,14 @@ export function createClaudeHookService(deps) {
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             handoffDir: context.task.handoffDir,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             prompt: stringOrUndefined(input.event.prompt)
         });
         return {
             ok: true,
             eventName,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             sessionUpdated: Boolean(session),
             dispatchedCount: 0,
@@ -95,11 +142,11 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
-        clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
+        clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
-                taskSlug: input.taskSlug,
+                taskSlug: context.taskSlug,
                 role: input.role,
                 taskRepoRoot: context.taskRepoRoot
             });
@@ -109,7 +156,7 @@ export function createClaudeHookService(deps) {
                 return {
                     ok: true,
                     eventName,
-                    taskSlug: input.taskSlug,
+                    taskSlug: context.taskSlug,
                     role: input.role,
                     sessionUpdated: false,
                     dispatchedCount: 0,
@@ -118,7 +165,7 @@ export function createClaudeHookService(deps) {
             }
         }
         return recordTurnEnd(input, context, eventName, {
-            dispatchRouteFiles: true,
+            dispatchRouteFiles: !isGateReviewerRoleName(input.role),
             notifyGateway: true,
             settleGuard: true
         });
@@ -133,9 +180,9 @@ export function createClaudeHookService(deps) {
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
         if (hasCompletionEvidence) {
-            clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
+            clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
             return recordTurnEnd(input, context, eventName, {
-                dispatchRouteFiles: true,
+                dispatchRouteFiles: !isGateReviewerRoleName(input.role),
                 notifyGateway: false,
                 settleGuard: true
             });
@@ -145,7 +192,7 @@ export function createClaudeHookService(deps) {
             return {
                 ok: true,
                 eventName,
-                taskSlug: input.taskSlug,
+                taskSlug: context.taskSlug,
                 role: input.role,
                 sessionUpdated: true,
                 dispatchedCount: 0
@@ -164,7 +211,7 @@ export function createClaudeHookService(deps) {
         }
         const context = await getHookContext(input);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
@@ -174,7 +221,7 @@ export function createClaudeHookService(deps) {
         return {
             ok: true,
             eventName,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             sessionUpdated: Boolean(session),
             dispatchedCount: 0
@@ -184,7 +231,7 @@ export function createClaudeHookService(deps) {
         const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
         const settleRouteDispatchInput = createRouteDispatchInput(input, context);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
@@ -195,7 +242,7 @@ export function createClaudeHookService(deps) {
             repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             ...(options.settleGuard
@@ -217,7 +264,7 @@ export function createClaudeHookService(deps) {
             await deps.translationService.recordConversationBoundary({
                 repoRoot: context.project.repoRoot,
                 taskRepoRoot: context.taskRepoRoot,
-                taskSlug: input.taskSlug,
+                taskSlug: context.taskSlug,
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "end",
@@ -227,7 +274,7 @@ export function createClaudeHookService(deps) {
         if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,
-                taskSlug: input.taskSlug,
+                taskSlug: context.taskSlug,
                 session
             }).catch(() => undefined);
         }
@@ -237,7 +284,7 @@ export function createClaudeHookService(deps) {
         return {
             ok: true,
             eventName,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             role: input.role,
             sessionUpdated: Boolean(session),
             dispatchedCount: dispatched.filter((result) => result.delivered).length
@@ -250,7 +297,7 @@ export function createClaudeHookService(deps) {
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             handoffDir: context.task.handoffDir,
-            taskSlug: input.taskSlug,
+            taskSlug: context.taskSlug,
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
@@ -258,18 +305,18 @@ export function createClaudeHookService(deps) {
         if (!deps.runtime) {
             return false;
         }
-        const key = stopFailureRecoveryKey(context.project.repoRoot, input.taskSlug, input.role);
+        const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
         const attempt = (stopFailureRecoveryAttempts.get(key) ?? 0) + 1;
         if (attempt > MAX_STOP_FAILURE_RECOVERY_ATTEMPTS) {
             return false;
         }
-        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, input.taskSlug, input.role);
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
         if (!session || session.status !== "running") {
             return false;
         }
         stopFailureRecoveryAttempts.set(key, attempt);
         await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt(attempt));
-        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, input.taskSlug, input.role);
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
         return true;
     }
     function clearStopFailureRecovery(repoRoot, taskSlug, role) {
@@ -290,6 +337,20 @@ export function createClaudeHookService(deps) {
     }
     async function handlePermissionRequestHook(input) {
         if (!isVcmRoleName(input.role)) {
+            if (isTranslatorToolRoleName(input.role)) {
+                const preferences = await deps.appSettings.getPreferences();
+                if (preferences.permissionRequestMode !== "allowAll") {
+                    return undefined;
+                }
+                return {
+                    hookSpecificOutput: {
+                        hookEventName: "PermissionRequest",
+                        decision: {
+                            behavior: "allow"
+                        }
+                    }
+                };
+            }
             throw new VcmError({
                 code: "HOOK_ROLE_INVALID",
                 message: `Unknown hook role: ${input.role}`,
@@ -320,6 +381,9 @@ export function createClaudeHookService(deps) {
     }
     return {
         async handleHook(input) {
+            if (isTranslatorToolRoleName(input.role)) {
+                return processTranslatorHook(input);
+            }
             const eventName = parseHookEvent(input.event.hook_event_name);
             if (eventName === "UserPromptSubmit") {
                 return handleUserPromptSubmitHook(input);
@@ -335,6 +399,9 @@ export function createClaudeHookService(deps) {
             return processStopHook(input, { allowBlock: false });
         },
         handleStopHook(input) {
+            if (isTranslatorToolRoleName(input.role)) {
+                return processTranslatorHook(input);
+            }
             return processStopHook(input, { allowBlock: true });
         },
         handlePermissionRequestHook

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

@@ -4,7 +4,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 { renderCodexCliConfigHarnessRules, renderCodexHooksHarnessRules, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderGateReviewerAgentRules, renderRequestGateReviewTool, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
+import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
 import { renderGitignoreHarnessRules } from "../templates/harness/gitignore.js";
 import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
@@ -25,6 +25,12 @@ export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
+const LEGACY_CODEX_HARNESS_PATHS = [
+    ".ai/codex",
+    ".ai/codex-translator",
+    ".claude/skills/vcm-codex-review-gate",
+    ".ai/tools/request-codex-review"
+];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
 const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
@@ -107,31 +113,11 @@ const HARNESS_FILES = [
         renderRules: renderGateReviewerAgentRules
     },
     {
-        kind: "codex-translator-agents",
-        path: ".ai/codex-translator/AGENTS.md",
-        title: "VCM Codex Translator",
-        renderRules: renderCodexTranslatorAgentsHarnessRules
-    },
-    {
-        kind: "codex-translator-config",
-        path: ".ai/codex-translator/config.toml",
-        title: "VCM Codex Translator Config",
-        ownership: "raw-file",
-        renderRules: renderCodexTranslatorConfigHarnessRules
-    },
-    {
-        kind: "codex-translator-cli-config",
-        path: ".ai/codex-translator/.codex/config.toml",
-        title: "VCM Codex Translator CLI Config",
-        ownership: "raw-file",
-        renderRules: renderCodexCliConfigHarnessRules
-    },
-    {
-        kind: "codex-translator-hooks",
-        path: ".ai/codex-translator/.codex/hooks.json",
-        title: "VCM Codex Translator Hooks",
-        ownership: "raw-file",
-        renderRules: () => renderCodexHooksHarnessRules("codex-translator")
+        kind: "agent-translator",
+        path: ".claude/agents/translator.md",
+        title: "Translator Agent",
+        frontmatter: renderAgentFrontmatter("translator", "VCM project translation tool role for conversation translation, file translation, bootstrap, and memory updates."),
+        renderRules: renderTranslatorAgentRules
     },
     {
         kind: "tool-request-gate-review",
@@ -175,7 +161,8 @@ export function createHarnessService(deps) {
     return {
         async getHarnessStatus(repoRoot) {
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
-            return renderHarnessStatus(analyses);
+            const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            return renderHarnessStatus(analyses, legacyChanges);
         },
         async applyHarness(repoRoot) {
             if (deps.runFixedInstaller) {
@@ -192,6 +179,8 @@ export function createHarnessService(deps) {
                     changedFiles.push(analysis.plannedChange);
                 }
             }
+            const legacyChanges = await removeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            changedFiles.push(...legacyChanges);
             return {
                 version: VCM_HARNESS_VERSION,
                 changedFiles,
@@ -489,11 +478,42 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             : currentContent.replace(managedBlockPattern, expectedBlock)
     };
 }
-function renderHarnessStatus(analyses) {
+async function analyzeLegacyCodexHarnessPaths(fs, repoRoot) {
+    const changes = [];
+    for (const relativePath of LEGACY_CODEX_HARNESS_PATHS) {
+        if (!await fs.pathExists(resolveHarnessPath(repoRoot, relativePath))) {
+            continue;
+        }
+        changes.push({
+            path: relativePath,
+            action: "delete",
+            reason: "Legacy Codex harness path is obsolete; VCM now uses Claude Code Gate Reviewer and Translator roles."
+        });
+    }
+    return changes;
+}
+async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
+    const changes = await analyzeLegacyCodexHarnessPaths(fs, repoRoot);
+    if (changes.length === 0) {
+        return [];
+    }
+    if (!fs.removePath) {
+        return [];
+    }
+    for (const change of changes) {
+        await fs.removePath(resolveHarnessPath(repoRoot, change.path), {
+            recursive: true,
+            force: true
+        });
+    }
+    return changes;
+}
+function renderHarnessStatus(analyses, legacyChanges = []) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
-        .filter((change) => Boolean(change));
+        .filter((change) => Boolean(change))
+        .concat(legacyChanges);
     // Derive `initialized`: the VCM harness is considered installed when at least one
     // VCM-exclusive marker is present (per analysis):
     //   - status.hasManagedBlock === true (a managed block already lives in the file), OR

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { VCM_ROLE_NAMES, isVcmRoleName } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -282,8 +282,8 @@ async function listRouteFiles(fs, input) {
     return routeFiles;
 }
 function parseRouteFileName(fileName) {
-    for (const fromRole of VCM_ROLE_NAMES) {
-        for (const toRole of VCM_ROLE_NAMES) {
+    for (const fromRole of CORE_VCM_ROLE_NAMES) {
+        for (const toRole of CORE_VCM_ROLE_NAMES) {
             if (fromRole === toRole) {
                 continue;
             }
@@ -371,14 +371,14 @@ function selectDispatchCandidates(routeFiles, stoppedRole) {
     });
 }
 function validateMessagePolicy(fromRole, toRole, type) {
-    if (!VCM_ROLE_NAMES.includes(toRole)) {
+    if (!CORE_VCM_ROLE_NAMES.some((role) => role === toRole)) {
         throw new VcmError({
             code: "MESSAGE_TARGET_UNKNOWN",
             message: `Unknown target role: ${toRole}`,
             statusCode: 400
         });
     }
-    if (!isVcmRoleName(String(fromRole))) {
+    if (!CORE_VCM_ROLE_NAMES.some((role) => role === fromRole)) {
         throw new VcmError({
             code: "MESSAGE_SENDER_UNKNOWN",
             message: `Unknown sender role: ${fromRole}`,
@@ -425,7 +425,7 @@ function getMessageDeliveryTime(message) {
 }
 async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
     const fromRole = message.fromRole;
-    if (!message.routePath || !isVcmRoleName(fromRole)) {
+    if (!message.routePath || !isCoreRouteRole(fromRole) || !isCoreRouteRole(message.toRole)) {
         return;
     }
     const absolutePath = resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, message.routePath);
@@ -440,6 +440,9 @@ async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
         await fs.writeText(absolutePath, "");
     }
 }
+function isCoreRouteRole(role) {
+    return CORE_VCM_ROLE_NAMES.some((candidate) => candidate === role);
+}
 function arraysEqual(left, right) {
     if (left.length !== right.length) {
         return false;

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 const DEFAULT_HANDOFF_ROOT = ".ai/vcm/handoffs";
 const DEFAULT_STATE_ROOT = ".ai/vcm";
@@ -179,7 +179,7 @@ export function buildDefaultProjectConfig(repoRoot) {
     return {
         version: 1,
         repoRoot,
-        defaultRoles: [...VCM_ROLE_NAMES],
+        defaultRoles: [...CORE_VCM_ROLE_NAMES],
         handoffRoot: DEFAULT_HANDOFF_ROOT,
         stateRoot: DEFAULT_STATE_ROOT,
         terminalBackend: "node-pty",