vibe-coding-master 0.3.2 → 0.3.4

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

@@ -23,7 +23,10 @@ export function createClaudeAdapter(runner) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
             args.push("--model", model);
-            if (effort !== "default") {
+            if (effort === "ultracode") {
+                args.push("--settings", JSON.stringify({ ultracode: true }));
+            }
+            else if (effort !== "default") {
                 args.push("--effort", effort);
             }
             if (permissionMode === "bypassPermissions") {

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

@@ -7,6 +7,7 @@ export function registerRoundRoutes(app, deps) {
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return deps.roundService.getSessionRoundState({
+            repoRoot: project.repoRoot,
             stateRepoRoot: taskRepoRoot,
             stateRoot: config.stateRoot,
             taskSlug: request.params.taskSlug

package/dist/backend/runtime/node-pty-runtime.js

@@ -33,16 +33,22 @@ export function createNodePtyTerminalRuntime(deps) {
             startedAt: now(),
             exitCode: null
         };
+        const logWriter = createTerminalLogWriter(deps.fs, input.logPath, deps.onLogWriteError ?? defaultLogWriteErrorHandler);
         const entry = {
             input,
             session,
             process: child,
-            listeners: new Set()
+            listeners: new Set(),
+            logWriter,
+            disposed: false
         };
         entries.set(session.id, entry);
         child.onData((data) => {
+            if (entry.disposed) {
+                return;
+            }
             entry.session.lastOutputAt = now();
-            void deps.fs.appendText(input.logPath, data);
+            entry.logWriter.append(data);
             emit(entry, {
                 sessionId: session.id,
                 taskSlug: input.taskSlug,
@@ -52,8 +58,13 @@ export function createNodePtyTerminalRuntime(deps) {
             });
         });
         child.onExit(({ exitCode }) => {
+            if (entry.disposed) {
+                return;
+            }
+            entry.disposed = true;
             entry.session.status = exitCode === 0 ? "exited" : "crashed";
             entry.session.exitCode = exitCode;
+            void entry.logWriter.close();
             emit(entry, {
                 sessionId: session.id,
                 taskSlug: input.taskSlug,
@@ -102,12 +113,16 @@ export function createNodePtyTerminalRuntime(deps) {
         },
         async stop(sessionId) {
             const entry = getEntry(entries, sessionId);
+            entry.disposed = true;
             entry.session.status = "exited";
             entry.process.kill();
+            await entry.logWriter.close();
         },
         async restart(sessionId) {
             const entry = getEntry(entries, sessionId);
+            entry.disposed = true;
             entry.process.kill();
+            await entry.logWriter.close();
             return create(entry.input, sessionId);
         },
         subscribe(sessionId, listener, options = {}) {
@@ -139,12 +154,40 @@ export function createNodePtyTerminalRuntime(deps) {
         }
     };
 }
+export function createTerminalLogWriter(fs, logPath, onError) {
+    let closed = false;
+    let pending = Promise.resolve();
+    return {
+        append(data) {
+            if (closed || !data) {
+                return;
+            }
+            pending = pending
+                .then(() => fs.appendText(logPath, data))
+                .catch((error) => {
+                try {
+                    onError(error, logPath);
+                }
+                catch {
+                    // Logging must never break terminal output delivery or future log writes.
+                }
+            });
+        },
+        async close() {
+            closed = true;
+            await pending.catch(() => undefined);
+        }
+    };
+}
 async function readTerminalReplayText(fs, logPath) {
     const data = fs.readTextTail
         ? await fs.readTextTail(logPath, TERMINAL_REPLAY_TAIL_LIMIT_BYTES)
         : tailTerminalReplay(await fs.readText(logPath));
     return tailTerminalReplay(data);
 }
+function defaultLogWriteErrorHandler(error, logPath) {
+    console.warn(`[VCM] Failed to append terminal log: ${logPath}`, error);
+}
 export function tailTerminalReplay(data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT_BYTES) {
     if (limitBytes <= 0 || Buffer.byteLength(data, "utf8") <= limitBytes) {
         return data;

package/dist/backend/server.js

@@ -184,19 +184,22 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
+    const roundService = createRoundService({
+        fs,
+        sessionService,
+        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
+            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
+        }
+    });
     const codexReviewService = createCodexReviewService({
         fs,
         runner,
         runtime,
         projectService,
         taskService,
-        sessionService
-    });
-    const roundService = createRoundService({
-        fs,
-        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
-            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
-        }
+        appSettings,
+        sessionService,
+        roundService
     });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({

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

@@ -2,6 +2,7 @@ import path from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { createDefaultLaunchTemplate } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -129,6 +130,32 @@ export function createAppSettingsService(deps) {
             });
             return config;
         },
+        async getCodexReviewSettings() {
+            const settings = await loadSettings();
+            const requiredGates = normalizeCodexReviewGates(settings.codexReview?.requiredGates);
+            return {
+                enabled: requiredGates.length > 0,
+                requiredGates
+            };
+        },
+        async updateCodexReviewSettings(_repoRoot, _taskSlug, requiredGates) {
+            const current = await loadSettings();
+            const normalizedRequiredGates = normalizeCodexReviewGates(requiredGates);
+            const timestamp = new Date().toISOString();
+            const nextCodexReview = {
+                version: 1,
+                requiredGates: normalizedRequiredGates,
+                updatedAt: timestamp
+            };
+            await saveSettings({
+                ...current,
+                codexReview: normalizeCodexReviewSettingsState(nextCodexReview)
+            });
+            return {
+                enabled: normalizedRequiredGates.length > 0,
+                requiredGates: normalizedRequiredGates
+            };
+        },
         getSettingsPath() {
             return settingsPath;
         },
@@ -172,13 +199,41 @@ function normalizeProjectIndexFile(input) {
         projects
     };
 }
-function normalizeSettingsFile(input) {
+function normalizeCodexReviewSettingsState(input) {
+    if (!isObject(input)) {
+        return undefined;
+    }
     return {
+        version: 1,
+        requiredGates: normalizeCodexReviewGates(input.requiredGates),
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : new Date(0).toISOString()
+    };
+}
+function normalizeCodexReviewGates(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    const gates = [];
+    for (const value of input) {
+        if (!CODEX_REVIEW_GATES.includes(value) || gates.includes(value)) {
+            continue;
+        }
+        gates.push(value);
+    }
+    return CODEX_REVIEW_GATES.filter((gate) => gates.includes(gate));
+}
+function normalizeSettingsFile(input) {
+    const settings = {
         version: 1,
         preferences: normalizePreferences(input.preferences),
         translation: normalizeTranslationConfig(input.translation),
         recentRepositoryPaths: normalizeRecentRepositoryPaths(input.recentRepositoryPaths)
     };
+    const codexReview = normalizeCodexReviewSettingsState(input.codexReview);
+    if (codexReview) {
+        settings.codexReview = codexReview;
+    }
+    return settings;
 }
 function normalizePreferences(input) {
     const candidate = isObject(input) ? input : {};

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

@@ -4,7 +4,6 @@ import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { renderCodexConfigHarnessRules } from "../templates/harness/codex-review.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const CODEX_DIR = ".ai/codex";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
@@ -39,12 +38,13 @@ export function createCodexReviewService(deps) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const reviewSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
         return {
             repoRoot,
             taskSlug,
             taskRepoRoot,
             stateRoot: projectConfig.stateRoot,
-            config: await loadRuntimeConfig(deps.fs, taskRepoRoot)
+            config: loadRuntimeConfig(reviewSettings)
         };
     }
     async function requestReviewGateInternal(repoRoot, taskSlug, gate, options = {}) {
@@ -148,6 +148,7 @@ export function createCodexReviewService(deps) {
             return;
         }
         activeRuns.add(runKey);
+        let codexTurnStarted = false;
         try {
             const timestamp = now();
             await updateGateRecord(context, gate, {
@@ -169,13 +170,24 @@ export function createCodexReviewService(deps) {
                 });
             }
             const session = await ensureCodexReviewerSession(context);
-            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
             await submitTerminalInput(deps.runtime, session.id, prompt);
+            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+            await deps.roundService.recordRoleTurnEvent({
+                repoRoot: context.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.stateRoot,
+                taskSlug: context.taskSlug,
+                role: CODEX_REVIEWER_ROLE,
+                eventName: "UserPromptSubmit"
+            });
+            codexTurnStarted = true;
             const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), {
                 intervalMs: reportPollIntervalMs,
                 timeoutMs: reportTimeoutMs
             });
             const completedAt = now();
+            await recordCodexReviewerTurnStop(context, codexTurnStarted);
+            codexTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "completed",
                 decision: parsed.decision,
@@ -197,6 +209,8 @@ export function createCodexReviewService(deps) {
         catch (error) {
             const timestamp = now();
             const message = errorMessage(error);
+            await recordCodexReviewerTurnStop(context, codexTurnStarted);
+            codexTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "failed",
                 error: message,
@@ -215,6 +229,20 @@ export function createCodexReviewService(deps) {
             activeRuns.delete(runKey);
         }
     }
+    async function recordCodexReviewerTurnStop(context, shouldRecord) {
+        if (!shouldRecord) {
+            return;
+        }
+        await deps.sessionService.markRoleActivityIdle(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+        await deps.roundService.recordRoleTurnEvent({
+            repoRoot: context.repoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            taskSlug: context.taskSlug,
+            role: CODEX_REVIEWER_ROLE,
+            eventName: "Stop"
+        });
+    }
     async function ensureCodexReviewerSession(context) {
         const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
         if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
@@ -265,6 +293,14 @@ export function createCodexReviewService(deps) {
         try {
             await submitTerminalInput(deps.runtime, session.id, prompt);
             await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, "project-manager");
+            await deps.roundService.recordRoleTurnEvent({
+                repoRoot: context.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.stateRoot,
+                taskSlug: context.taskSlug,
+                role: "project-manager",
+                eventName: "UserPromptSubmit"
+            });
             await updateGateRecord(context, gate, {
                 callbackStatus: "sent",
                 callbackError: undefined,
@@ -285,8 +321,8 @@ export function createCodexReviewService(deps) {
             return loadIndex(deps.fs, context, now());
         },
         async updateSettings(repoRoot, taskSlug, input) {
-            const context = await getContext(repoRoot, taskSlug);
-            const requiredGates = new Set(context.config.enabled ? context.config.requiredGates : []);
+            const currentSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
+            const requiredGates = new Set(currentSettings.requiredGates);
             for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
                 if (!isCodexReviewGate(gate)) {
                     continue;
@@ -298,7 +334,7 @@ export function createCodexReviewService(deps) {
                     requiredGates.delete(gate);
                 }
             }
-            await writeRuntimeConfigSettings(deps.fs, context.taskRepoRoot, [...requiredGates]);
+            await deps.appSettings.updateCodexReviewSettings(repoRoot, taskSlug, [...requiredGates]);
             const nextContext = await getContext(repoRoot, taskSlug);
             const index = await loadIndex(deps.fs, nextContext, now());
             await saveIndex(deps.fs, nextContext.taskRepoRoot, {
@@ -372,75 +408,12 @@ export function createCodexReviewService(deps) {
 export function isCodexReviewGate(value) {
     return CODEX_REVIEW_GATES.includes(value);
 }
-async function loadRuntimeConfig(fs, taskRepoRoot) {
-    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
-    if (!(await fs.pathExists(configPath))) {
-        return {
-            enabled: false,
-            requiredGates: [],
-            command: "codex"
-        };
-    }
-    const content = await fs.readText(configPath);
-    const section = extractTomlSection(content, "vcm.codex_review");
-    const enabled = parseTomlBoolean(section, "enabled") ?? false;
-    const parsedGates = parseTomlStringArray(section, "required_gates").filter(isCodexReviewGate);
+function loadRuntimeConfig(reviewSettings) {
     return {
-        enabled,
-        requiredGates: parsedGates.length > 0 ? parsedGates : enabled ? [...CODEX_REVIEW_GATES] : [],
-        model: parseTomlString(content, "model"),
-        modelReasoningEffort: parseTomlString(content, "model_reasoning_effort"),
-        command: parseTomlString(section, "command") ?? "codex"
+        enabled: reviewSettings.enabled,
+        requiredGates: reviewSettings.requiredGates
     };
 }
-async function writeRuntimeConfigSettings(fs, taskRepoRoot, requiredGates) {
-    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
-    const current = await fs.pathExists(configPath)
-        ? await fs.readText(configPath)
-        : renderCodexConfigHarnessRules();
-    const section = renderCodexReviewSettingsSection(requiredGates);
-    const next = replaceTomlSection(current, "vcm.codex_review", section);
-    await fs.writeText(configPath, next);
-}
-function renderCodexReviewSettingsSection(requiredGates) {
-    if (requiredGates.length === 0) {
-        return [
-            "[vcm.codex_review]",
-            "enabled = false",
-            "required_gates = []"
-        ].join("\n");
-    }
-    const lines = [
-        "[vcm.codex_review]",
-        "enabled = true",
-        "required_gates = [",
-        ...CODEX_REVIEW_GATES
-            .filter((gate) => requiredGates.includes(gate))
-            .map((gate) => `  "${gate}",`),
-        "]"
-    ];
-    return lines.join("\n");
-}
-function replaceTomlSection(content, sectionName, nextSection) {
-    const lines = content.replace(/\s+$/g, "").split(/\r?\n/);
-    const header = `[${sectionName}]`;
-    const start = lines.findIndex((line) => line.trim() === header);
-    if (start < 0) {
-        return `${lines.join("\n").trimEnd()}\n\n${nextSection}\n`;
-    }
-    let end = lines.length;
-    for (let index = start + 1; index < lines.length; index += 1) {
-        if (/^\s*\[[^\]]+\]\s*$/.test(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    return [
-        ...lines.slice(0, start),
-        nextSection,
-        ...lines.slice(end)
-    ].join("\n").trimEnd() + "\n";
-}
 async function loadIndex(fs, context, timestamp) {
     const indexPath = getIndexPath(context.taskRepoRoot);
     const raw = await readJsonOrNull(fs, indexPath);
@@ -684,41 +657,6 @@ async function readJsonOrNull(fs, targetPath) {
         return null;
     }
 }
-function extractTomlSection(content, sectionName) {
-    const lines = content.split(/\r?\n/);
-    const sectionHeader = `[${sectionName}]`;
-    const collected = [];
-    let inSection = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (/^\[[^\]]+\]$/.test(trimmed)) {
-            if (inSection) {
-                break;
-            }
-            inSection = trimmed === sectionHeader;
-            continue;
-        }
-        if (inSection) {
-            collected.push(line);
-        }
-    }
-    return collected.join("\n");
-}
-function parseTomlBoolean(section, key) {
-    const match = section.match(new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*(true|false)\\s*(?:#.*)?$`, "mi"));
-    return match ? match[1] === "true" : undefined;
-}
-function parseTomlString(content, key) {
-    const match = content.match(new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*"([^"]*)"\\s*(?:#.*)?$`, "mi"));
-    return match?.[1];
-}
-function parseTomlStringArray(section, key) {
-    const match = section.match(new RegExp(`${escapeRegex(key)}\\s*=\\s*\\[([\\s\\S]*?)\\]`, "m"));
-    if (!match) {
-        return [];
-    }
-    return [...match[1].matchAll(/"([^"]+)"/g)].map((candidate) => candidate[1]);
-}
 function matchField(content, field) {
     const match = content.match(new RegExp(`^\\s*${escapeRegex(field)}\\s*:\\s*(.+?)\\s*$`, "mi"));
     return match?.[1]?.trim();

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

@@ -39,6 +39,51 @@ export function createRoundService(deps) {
             status
         });
     }
+    async function findActiveRoleSession(input, timestamp) {
+        if (!input.repoRoot || !deps.sessionService) {
+            return undefined;
+        }
+        let sessions;
+        try {
+            sessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
+        }
+        catch {
+            return undefined;
+        }
+        const active = sessions
+            .filter((session) => session.status === "running" && session.activityStatus === "running")
+            .sort((left, right) => timestampMs(roleActivityTimestamp(right, timestamp)) - timestampMs(roleActivityTimestamp(left, timestamp)))[0];
+        if (!active) {
+            return undefined;
+        }
+        return {
+            role: active.role,
+            startedAt: roleActivityTimestamp(active, timestamp)
+        };
+    }
+    async function syncRoundFromActiveRoleSession(input, state, timestamp) {
+        const current = state.currentRound;
+        if (current?.status === "running" && current.activeTurnStartedAt) {
+            return undefined;
+        }
+        const active = await findActiveRoleSession(input, timestamp);
+        if (!active) {
+            return undefined;
+        }
+        const shouldStartNewRound = !current || current.status === "stopped";
+        const next = applyPromptSubmitted({
+            state,
+            taskSlug: input.taskSlug,
+            role: active.role,
+            timestamp: active.startedAt,
+            updatedAt: timestamp,
+            roundId: shouldStartNewRound ? id() : current.id
+        });
+        await save(input, next);
+        clearSettleTimer(input);
+        await updateSessionStatus(input, "running");
+        return next;
+    }
     async function settleIfNeeded(input, state, timestamp) {
         const current = state.currentRound;
         if (current?.status !== "running" ||
@@ -49,6 +94,10 @@ export function createRoundService(deps) {
         if (timestamp < current.settleDeadlineAt) {
             return state;
         }
+        const activeSessionState = await syncRoundFromActiveRoleSession(input, state, timestamp);
+        if (activeSessionState) {
+            return activeSessionState;
+        }
         const stopped = {
             ...current,
             status: "stopped",
@@ -76,6 +125,10 @@ export function createRoundService(deps) {
                 return;
             }
             const timestamp = maxIsoTimestamp(now(), settleDeadlineAt);
+            const activeSessionState = await syncRoundFromActiveRoleSession(input, state, timestamp);
+            if (activeSessionState) {
+                return;
+            }
             if (settleGuard) {
                 const decision = await runSettleGuard(settleGuard, {
                     ...input,
@@ -178,7 +231,10 @@ export function createRoundService(deps) {
         async getSessionRoundState(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
-                return toSessionRoundState(await load(input), timestamp);
+                const loaded = await load(input);
+                const synced = await syncRoundFromActiveRoleSession(input, loaded, timestamp);
+                const settled = synced ?? await settleIfNeeded(input, loaded, timestamp);
+                return toSessionRoundState(settled, timestamp);
             });
         },
         recordRoleTurnEvent,
@@ -198,7 +254,19 @@ export function applyRoundHookEvent(input) {
     return applyStop(input);
 }
 function applyPromptSubmitted(input) {
+    const updatedAt = input.updatedAt ?? input.timestamp;
     const current = input.state.currentRound;
+    if (current?.status === "running" && current.activeTurnStartedAt && current.activeRole === input.role) {
+        return {
+            ...input.state,
+            taskSlug: input.taskSlug,
+            currentRound: {
+                ...current,
+                roles: appendUniqueRole(current.roles, input.role)
+            },
+            updatedAt
+        };
+    }
     const shouldStartNewRound = !current || current.status === "stopped";
     const totalRoundCount = shouldStartNewRound
         ? input.state.totalRoundCount + 1
@@ -236,12 +304,12 @@ function applyPromptSubmitted(input) {
         totalTurnCount: input.state.totalTurnCount + 1,
         totalCompletedTurnCount: input.state.totalCompletedTurnCount,
         totalCcActiveMs: input.state.totalCcActiveMs,
-        updatedAt: input.timestamp
+        updatedAt
     };
 }
 function applyStop(input) {
     const current = input.state.currentRound;
-    if (!current || current.status === "stopped" || !current.activeTurnStartedAt) {
+    if (!current || current.status === "stopped" || !current.activeTurnStartedAt || current.activeRole !== input.role) {
         return {
             ...input.state,
             taskSlug: input.taskSlug,
@@ -389,6 +457,13 @@ function addMilliseconds(value, milliseconds) {
 function maxIsoTimestamp(left, right) {
     return Date.parse(left) >= Date.parse(right) ? left : right;
 }
+function roleActivityTimestamp(session, fallback) {
+    return session.lastTurnStartedAt ?? session.lastHookEventAt ?? session.updatedAt ?? fallback;
+}
+function timestampMs(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
 async function runSettleGuard(settleGuard, input) {
     try {
         return await settleGuard(input);