vibe-coding-master 0.2.3 → 0.2.5

package/README.md

@@ -212,7 +212,7 @@ The same file stores recent repository paths. The translation API key is stored
 
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
-The same sidebar also has a `Flow pause alert` toggle. It is on by default and controls the local alert that fires when VCM detects that the current role flow has stopped advancing. Short flows use a weak reminder: the soft two-note chime plays 3 times, 1.4 seconds apart. Flows lasting 10 minutes or longer use a strong reminder: VCM shows an alert dialog and repeats the chime until the user confirms it. The alert sound reuses one browser audio context so repeated reminders remain reliable in stricter browsers such as Safari. The `Try alert` button always triggers the strong reminder for testing.
+The same sidebar also has a `Flow pause alert` toggle. It is on by default and controls the local alert that fires when VCM detects that the current role flow has stopped advancing. Short flows use a weak reminder: the soft two-note chime plays 3 times, 1.4 seconds apart. Flows lasting 10 minutes or longer use a strong reminder: VCM shows an alert dialog and repeats the chime until the user confirms it. The alert sound reuses one browser audio context so repeated reminders remain reliable in stricter browsers such as Safari. Safari users may still need to manually set `Safari > Website Settings > Auto-Play > Allow All Auto-Play`; Chrome is recommended for the most reliable alert sound behavior. The `Try alert` button always triggers the strong reminder for testing.
 
 Translation behavior:
 
@@ -263,6 +263,10 @@ CLAUDE.md
 Repo-local skills are installed as `.claude/skills/<skill-name>/SKILL.md` so
 Claude Code can register them.
 
+VCM roles must not start background jobs. The only allowed background job is
+`.ai/tools/run-long-check` when used through `vcm-long-running-validation`;
+`.ai/tools/watch-job` enforces a 60 minute maximum timeout.
+
 If a managed-block file already exists, VCM preserves user-authored content and only inserts or replaces the VCM block:
 
 ```md
@@ -380,7 +384,7 @@ When a `Stop` hook fires, VCM marks the round as settling for 10 seconds. If ano
 
 The normal path is timer-driven: `Stop` starts a backend settle timer, and `UserPromptSubmit` cancels it. Reading the round state also checks expired deadlines as a recovery fallback after process restarts, sleep, or missed timers.
 
-When `Flow pause alert` is enabled, the frontend polls the task round state and deduplicates each pause id. Flow duration is measured from the first `UserPromptSubmit` to the last `Stop`; the 10 second settle window is not counted. If the paused flow lasted less than 10 minutes, it plays the local chime 3 times at 1.4 second intervals. If the paused flow lasted 10 minutes or longer, it shows a modal `Flow paused` alert and repeats the local chime until the user clicks `Confirm`. A pause can mean normal completion, user decision needed, dispatch failure, or another workflow interruption; the point is to get the user to look with the right amount of urgency.
+When `Flow pause alert` is enabled, the frontend polls the task round state and deduplicates each paused round so the same paused state does not alert on every poll. Flow duration is measured from the first `UserPromptSubmit` to `pausedAt`, falling back to the last `Stop` when needed. If the paused flow lasted less than 10 minutes, it plays the local chime 3 times at 1.4 second intervals. If the paused flow lasted 10 minutes or longer, it shows a modal `Flow paused` alert and repeats the local chime until the user clicks `Confirm`. A pause can mean normal completion, user decision needed, dispatch failure, or another workflow interruption; the point is to get the user to look with the right amount of urgency.
 
 ## Resume Behavior
 

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);
             });
@@ -252,7 +274,6 @@ function toTaskRoundState(state, updatedAt) {
         taskSlug: state.taskSlug,
         status: current.status,
         roundId: current.id,
-        pauseId: current.status === "paused" ? `${current.id}:${current.pausedAt ?? current.lastStopAt ?? ""}` : undefined,
         activeRole: current.activeRole,
         startedAt: current.startedAt,
         lastPromptSubmittedAt: current.lastPromptSubmittedAt,
@@ -315,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/backend/templates/harness/claude-root.js

@@ -3,6 +3,16 @@ export function renderRootClaudeHarnessRules() {
 
 - Use the durable project docs below as role-relevant project truth.
 - Read module-local \`CLAUDE.md\` before editing a subdirectory if one exists.
+- Use \`vcm-long-running-validation\` for long-running validation. Follow the background job limits below.
+
+## VCM Background Jobs
+
+- Do not start background jobs.
+- The only allowed background job is \`.ai/tools/run-long-check\` when used through the \`vcm-long-running-validation\` skill.
+- \`vcm-long-running-validation\` has a hard maximum timeout of 60 minutes.
+- Do not run or suggest operations expected to exceed 60 minutes without user approval.
+- Design every single validation/build operation to complete within 60 minutes; split anything larger before running it.
+- Do not end the current turn only to wait for a long-running shell callback.
 
 ## VCM Durable Project Docs
 

package/dist/backend/templates/harness/vcm-long-running-validation-skill.js

@@ -1,9 +1,11 @@
 export function renderVcmLongRunningValidationSkillRules() {
     return `## Rule
 
-Do not end the current turn only to wait for a long-running shell callback.
+Do not start background jobs.
 
-Use a bounded file-backed job instead.
+The only allowed background job is \`.ai/tools/run-long-check\` when used through this skill.
+
+This skill has a hard maximum timeout of 60 minutes. Do not run or suggest operations expected to exceed 60 minutes without user approval.
 
 ## Protocol
 
@@ -34,12 +36,15 @@ Example:
 
 Timeout is not "unknown". It is a command result.
 
+\`watch-job\` rejects timeouts over 60 minutes.
+
 On timeout:
 
 - summarize the latest log tail
 - record the timeout in \`status.json\`
 - report whether the timed-out process was stopped
 - do not mark the command as passed
+- do not continue the job in the background
 
 \`watch-job\` should attempt to stop the timed-out command process group. If termination cannot be confirmed, say so in the summary.
 

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"
+    }
+];