vibe-coding-master 0.2.4 → 0.2.5

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

@@ -17,19 +17,26 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false) {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default") {
             const args = ["--agent", role];
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
+            args.push("--model", model);
             if (permissionMode === "bypassPermissions") {
                 args.push("--permission-mode", "bypassPermissions");
             }
             return {
                 command,
                 args,
-                display: `${command} ${args.join(" ")}`
+                display: [command, ...args].map(formatDisplayArg).join(" ")
             };
         }
     };
 }
+function formatDisplayArg(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/backend/api/claude-hook-routes.js

@@ -5,4 +5,11 @@ export function registerClaudeHookRoutes(app, deps) {
     app.post("/api/hooks/claude-code/stop", async (request) => {
         return deps.claudeHookService.handleStopHook(request.body);
     });
+    app.post("/api/hooks/claude-code/permission-request", async (request, reply) => {
+        const result = await deps.claudeHookService.handlePermissionRequestHook(request.body);
+        if (!result) {
+            return reply.code(204).send();
+        }
+        return result;
+    });
 }

package/dist/backend/server.js

@@ -180,7 +180,8 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         messageService,
         roundService,
-        translationService
+        translationService,
+        appSettings
     });
     return {
         appSettings,

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

@@ -1,6 +1,9 @@
 import path from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
+import { ROLE_NAMES } from "../../shared/constants.js";
+import { createDefaultLaunchTemplate } from "../../shared/types/app-settings.js";
+import { CLAUDE_MODEL_OPTIONS } from "../../shared/types/session.js";
 const MAX_RECENT_REPOSITORIES = 5;
 export function createAppSettingsService(deps) {
     const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "settings.json");
@@ -184,7 +187,9 @@ function normalizePreferences(input) {
         : candidate.roundCompletionAlerts;
     return {
         themeMode: normalizeThemeMode(candidate.themeMode),
-        flowPauseAlerts: rawFlowPauseAlerts !== false
+        flowPauseAlerts: rawFlowPauseAlerts !== false,
+        permissionRequestMode: normalizePermissionRequestMode(candidate.permissionRequestMode),
+        launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate)
     };
 }
 function normalizeThemeMode(input) {
@@ -193,6 +198,49 @@ function normalizeThemeMode(input) {
     }
     return "system";
 }
+function normalizePermissionRequestMode(input) {
+    if (input === "allowAll") {
+        return input;
+    }
+    return "off";
+}
+function normalizeLaunchTemplate(input) {
+    const defaults = createDefaultLaunchTemplate();
+    if (!isObject(input)) {
+        return defaults;
+    }
+    const rawRoles = isObject(input.roles) ? input.roles : {};
+    const roles = {};
+    for (const role of ROLE_NAMES) {
+        roles[role] = normalizeRoleLaunchTemplateEntry(rawRoles[role], defaults.roles[role]);
+    }
+    return {
+        version: 1,
+        roles,
+        autoOrchestration: input.autoOrchestration !== false,
+        translationEnabled: input.translationEnabled !== false
+    };
+}
+function normalizeRoleLaunchTemplateEntry(input, fallback) {
+    const candidate = isObject(input) ? input : {};
+    return {
+        permissionMode: normalizeClaudePermissionMode(candidate.permissionMode, fallback.permissionMode),
+        model: normalizeClaudeModel(candidate.model, fallback.model)
+    };
+}
+function normalizeClaudePermissionMode(input, fallback) {
+    if (input === "bypassPermissions" || input === "default") {
+        return input;
+    }
+    return fallback;
+}
+function normalizeClaudeModel(input, fallback) {
+    if (typeof input !== "string") {
+        return fallback;
+    }
+    const model = CLAUDE_MODEL_OPTIONS.find((option) => option.value === input);
+    return model?.value ?? fallback;
+}
 function normalizeTranslationConfig(input) {
     if (!input || typeof input !== "object") {
         return undefined;

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

@@ -86,6 +86,23 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        const scopedRouteDispatchInput = {
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug,
+            stoppedRole: input.role
+        };
+        const settleRouteDispatchInput = {
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug
+        };
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
             role: input.role,
@@ -99,7 +116,17 @@ export function createClaudeHookService(deps) {
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
             role: input.role,
-            eventName
+            eventName,
+            settleGuard: async () => {
+                const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
+                if (pending.length === 0) {
+                    return { action: "pause" };
+                }
+                const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
+                return retried.some((result) => result.delivered)
+                    ? { action: "continue", reason: "pending route message dispatched" }
+                    : { action: "pause" };
+            }
         });
         if (session) {
             await deps.translationService.recordConversationBoundary({
@@ -112,15 +139,7 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastStopAt ?? session.updatedAt
             });
         }
-        const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles({
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            handoffDir: context.task.handoffDir,
-            taskSlug: input.taskSlug,
-            stoppedRole: input.role
-        });
+        const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput);
         return {
             ok: true,
             eventName,
@@ -130,6 +149,36 @@ export function createClaudeHookService(deps) {
             dispatchedCount: dispatched.filter((result) => result.delivered).length
         };
     }
+    async function handlePermissionRequestHook(input) {
+        if (!isRoleName(input.role)) {
+            throw new VcmError({
+                code: "HOOK_ROLE_INVALID",
+                message: `Unknown hook role: ${input.role}`,
+                statusCode: 400
+            });
+        }
+        const eventName = input.event.hook_event_name;
+        if (eventName !== "PermissionRequest") {
+            throw new VcmError({
+                code: "HOOK_EVENT_UNSUPPORTED",
+                message: `Unsupported Claude Code permission hook event: ${String(eventName)}`,
+                statusCode: 400,
+                hint: "Use this endpoint for Claude Code PermissionRequest hooks only."
+            });
+        }
+        const preferences = await deps.appSettings.getPreferences();
+        if (preferences.permissionRequestMode !== "allowAll") {
+            return undefined;
+        }
+        return {
+            hookSpecificOutput: {
+                hookEventName: "PermissionRequest",
+                decision: {
+                    behavior: "allow"
+                }
+            }
+        };
+    }
     return {
         async handleHook(input) {
             const eventName = parseHookEvent(input.event.hook_event_name);
@@ -138,7 +187,8 @@ export function createClaudeHookService(deps) {
             }
             return handleStopHook(input);
         },
-        handleStopHook
+        handleStopHook,
+        handlePermissionRequestHook
     };
 }
 function parseHookEvent(value) {

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

@@ -26,7 +26,8 @@ const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
 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_HOOK_EVENTS = ["UserPromptSubmit", "Stop"];
+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'`;
+const VCM_HOOK_EVENTS = ["UserPromptSubmit", "Stop", "PermissionRequest"];
 const HARNESS_FILES = [
     {
         kind: "root-claude",
@@ -397,7 +398,7 @@ async function analyzeClaudeSettingsFile(fs, repoRoot) {
                 path: CLAUDE_SETTINGS_PATH,
                 action,
                 reason: exists
-                    ? "Claude Code hook settings do not contain the VCM UserPromptSubmit/Stop hook bridge."
+                    ? "Claude Code hook settings do not contain the VCM hook bridge."
                     : "Claude Code hook settings are missing; VCM will create them."
             },
         nextContent: action === "ok" ? undefined : nextContent
@@ -432,7 +433,7 @@ function withVcmClaudeHooks(settings) {
             : [];
         hooks[eventName] = [
             ...existingMatchers.filter((entry) => !isVcmHookMatcher(entry)),
-            createVcmHookMatcher()
+            createVcmHookMatcher(eventName)
         ];
     }
     return {
@@ -440,12 +441,12 @@ function withVcmClaudeHooks(settings) {
         hooks
     };
 }
-function createVcmHookMatcher() {
+function createVcmHookMatcher(eventName) {
     return {
         hooks: [
             {
                 type: "command",
-                command: VCM_HOOK_COMMAND,
+                command: eventName === "PermissionRequest" ? VCM_PERMISSION_REQUEST_HOOK_COMMAND : VCM_HOOK_COMMAND,
                 timeout: 5
             }
         ]

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

@@ -51,7 +51,7 @@ export function createRoundService(deps) {
         await save(input, next);
         return next;
     }
-    async function settleIfStillCurrent(input, roundId, settleDeadlineAt) {
+    async function settleIfStillCurrent(input, roundId, settleDeadlineAt, settleGuard) {
         await withTaskLock(input, async () => {
             const state = await load(input);
             const current = state.currentRound;
@@ -60,7 +60,30 @@ export function createRoundService(deps) {
                 current.settleDeadlineAt !== settleDeadlineAt) {
                 return;
             }
-            await settleIfNeeded(input, state, settleDeadlineAt);
+            const timestamp = maxIsoTimestamp(now(), settleDeadlineAt);
+            if (settleGuard) {
+                const decision = await runSettleGuard(settleGuard, {
+                    ...input,
+                    role: current.activeRole,
+                    roundId,
+                    settleDeadlineAt
+                });
+                if (decision.action === "continue") {
+                    const nextRound = {
+                        ...current,
+                        settleDeadlineAt: addMilliseconds(timestamp, settleMs)
+                    };
+                    const next = {
+                        ...state,
+                        currentRound: nextRound,
+                        updatedAt: timestamp
+                    };
+                    await save(input, next);
+                    scheduleSettleTimer(input, nextRound, timestamp, settleGuard);
+                    return;
+                }
+            }
+            await settleIfNeeded(input, state, timestamp);
         });
     }
     function clearSettleTimer(input) {
@@ -81,7 +104,7 @@ export function createRoundService(deps) {
             settleTimers.delete(key);
         }
     }
-    function scheduleSettleTimer(input, round, timestamp) {
+    function scheduleSettleTimer(input, round, timestamp, settleGuard) {
         if (round.status !== "settling" || !round.settleDeadlineAt) {
             clearSettleTimer(input);
             return;
@@ -90,7 +113,7 @@ export function createRoundService(deps) {
         const delayMs = Math.max(0, new Date(round.settleDeadlineAt).getTime() - new Date(timestamp).getTime());
         const timer = setTimer(() => {
             settleTimers.delete(getRoundStatePath(input));
-            void settleIfStillCurrent(input, round.id, round.settleDeadlineAt ?? "").catch(() => undefined);
+            void settleIfStillCurrent(input, round.id, round.settleDeadlineAt ?? "", settleGuard).catch(() => undefined);
         }, delayMs);
         settleTimers.set(getRoundStatePath(input), timer);
     }
@@ -112,8 +135,7 @@ export function createRoundService(deps) {
         async getTaskRoundState(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
-                const state = await settleIfNeeded(input, await load(input), timestamp);
-                return toTaskRoundState(state, timestamp);
+                return toTaskRoundState(await load(input), timestamp);
             });
         },
         async recordClaudeHookEvent(input) {
@@ -136,7 +158,7 @@ export function createRoundService(deps) {
                     clearSettleTimer(input);
                 }
                 else if (next.currentRound) {
-                    scheduleSettleTimer(input, next.currentRound, timestamp);
+                    scheduleSettleTimer(input, next.currentRound, timestamp, input.settleGuard);
                 }
                 return toTaskRoundState(next, timestamp);
             });
@@ -314,6 +336,17 @@ function appendUniqueRole(roles, role) {
 function addMilliseconds(value, milliseconds) {
     return new Date(new Date(value).getTime() + milliseconds).toISOString();
 }
+function maxIsoTimestamp(left, right) {
+    return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+async function runSettleGuard(settleGuard, input) {
+    try {
+        return await settleGuard(input);
+    }
+    catch {
+        return { action: "pause" };
+    }
+}
 function getDurationMs(start, end) {
     const startMs = Date.parse(start);
     const endMs = Date.parse(end);

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

@@ -18,6 +18,7 @@ export function createSessionService(deps) {
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
+        const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
@@ -32,7 +33,7 @@ export function createSessionService(deps) {
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
             : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
-        const startCommand = deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume");
+        const startCommand = deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model);
         const runtimeSession = await deps.runtime.createSession({
             taskSlug,
             role,
@@ -61,6 +62,7 @@ export function createSessionService(deps) {
             activityStatus: "idle",
             command: startCommand.display,
             permissionMode,
+            model,
             cwd: taskRepoRoot,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
@@ -240,7 +242,8 @@ async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role)
     return record
         ? {
             ...record,
-            permissionMode: normalizeClaudePermissionMode(record.permissionMode)
+            permissionMode: normalizeClaudePermissionMode(record.permissionMode),
+            model: normalizeClaudeModel(record.model)
         }
         : undefined;
 }
@@ -291,3 +294,14 @@ function normalizeClaudePermissionMode(value) {
     }
     return "default";
 }
+function normalizeClaudeModel(value) {
+    if (value === "best"
+        || value === "fable"
+        || value === "opus"
+        || value === "opus[1m]"
+        || value === "claude-opus-4-8"
+        || value === "claude-opus-4-8[1m]") {
+        return value;
+    }
+    return "default";
+}

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

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

package/dist/shared/types/session.js

@@ -1 +1,37 @@
-export {};
+export const CLAUDE_MODEL_OPTIONS = [
+    {
+        value: "default",
+        label: "Default",
+        description: "Account default"
+    },
+    {
+        value: "best",
+        label: "Best",
+        description: "Fable 5 or latest Opus"
+    },
+    {
+        value: "fable",
+        label: "Fable 5",
+        description: "1M context, v2.1.170+"
+    },
+    {
+        value: "opus",
+        label: "Opus",
+        description: "latest Opus"
+    },
+    {
+        value: "opus[1m]",
+        label: "Opus 1M",
+        description: "Force 1M context"
+    },
+    {
+        value: "claude-opus-4-8",
+        label: "Opus 4.8",
+        description: "Current Opus"
+    },
+    {
+        value: "claude-opus-4-8[1m]",
+        label: "Opus 4.8 1M",
+        description: "Opus 4.8 + 1M context"
+    }
+];