vibe-coding-master 0.2.0 → 0.2.2

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

@@ -1,79 +1,331 @@
-import { ROLE_NAMES } from "../../shared/constants.js";
-export function createRoundService(deps = {}) {
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+const DEFAULT_SETTLE_MS = 10_000;
+const setGlobalTimeout = globalThis.setTimeout.bind(globalThis);
+const clearGlobalTimeout = globalThis.clearTimeout.bind(globalThis);
+export function createRoundService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
-    return {
-        getTaskRoundState(input) {
-            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions));
-            const state = evaluateTaskRoundState({
+    const id = deps.id ?? (() => `round_${randomUUID()}`);
+    const settleMs = deps.settleMs ?? DEFAULT_SETTLE_MS;
+    const setTimer = deps.setTimeout ?? setGlobalTimeout;
+    const clearTimer = deps.clearTimeout ?? clearGlobalTimeout;
+    const taskLocks = new Map();
+    const settleTimers = new Map();
+    async function load(input) {
+        const statePath = getRoundStatePath(input);
+        if (!(await deps.fs.pathExists(statePath))) {
+            return {
+                version: 1,
                 taskSlug: input.taskSlug,
-                pendingRouteCount: input.pendingRouteCount,
-                roleStates,
+                totalRoundCount: 0,
+                totalPromptSubmitCount: 0,
+                totalStopCount: 0,
+                totalCcActiveMs: 0,
                 updatedAt: now()
-            });
-            return {
-                ...state,
-                pendingRouteCount: input.pendingRouteCount
             };
+        }
+        return normalizeRoundFile(await deps.fs.readJson(statePath), input.taskSlug, now());
+    }
+    async function save(input, state) {
+        await deps.fs.writeJsonAtomic(getRoundStatePath(input), state);
+    }
+    async function settleIfNeeded(input, state, timestamp) {
+        const current = state.currentRound;
+        if (current?.status !== "settling" || !current.settleDeadlineAt) {
+            return state;
+        }
+        if (timestamp < current.settleDeadlineAt) {
+            return state;
+        }
+        const paused = {
+            ...current,
+            status: "paused",
+            pausedAt: current.settleDeadlineAt
+        };
+        const next = {
+            ...state,
+            currentRound: paused,
+            lastPausedRound: paused,
+            updatedAt: timestamp
+        };
+        await save(input, next);
+        return next;
+    }
+    async function settleIfStillCurrent(input, roundId, settleDeadlineAt) {
+        await withTaskLock(input, async () => {
+            const state = await load(input);
+            const current = state.currentRound;
+            if (current?.id !== roundId ||
+                current.status !== "settling" ||
+                current.settleDeadlineAt !== settleDeadlineAt) {
+                return;
+            }
+            await settleIfNeeded(input, state, settleDeadlineAt);
+        });
+    }
+    function clearSettleTimer(input) {
+        const key = getRoundStatePath(input);
+        const timer = settleTimers.get(key);
+        if (timer === undefined) {
+            return;
+        }
+        clearTimer(timer);
+        settleTimers.delete(key);
+    }
+    function clearSettleTimersForTask(taskSlug) {
+        for (const [key, timer] of settleTimers) {
+            if (!key.endsWith(path.join("rounds", `${taskSlug}.json`))) {
+                continue;
+            }
+            clearTimer(timer);
+            settleTimers.delete(key);
+        }
+    }
+    function scheduleSettleTimer(input, round, timestamp) {
+        if (round.status !== "settling" || !round.settleDeadlineAt) {
+            clearSettleTimer(input);
+            return;
+        }
+        clearSettleTimer(input);
+        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);
+        }, delayMs);
+        settleTimers.set(getRoundStatePath(input), timer);
+    }
+    async function withTaskLock(input, run) {
+        const key = getRoundStatePath(input);
+        const previous = taskLocks.get(key) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(run);
+        taskLocks.set(key, next);
+        try {
+            return await next;
+        }
+        finally {
+            if (taskLocks.get(key) === next) {
+                taskLocks.delete(key);
+            }
+        }
+    }
+    return {
+        async getTaskRoundState(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await settleIfNeeded(input, await load(input), timestamp);
+                return toTaskRoundState(state, timestamp);
+            });
+        },
+        async recordClaudeHookEvent(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const settled = await settleIfNeeded(input, await load(input), timestamp);
+                const current = settled.currentRound;
+                const shouldStartNewRound = input.eventName === "UserPromptSubmit" && (!current || current.status === "paused");
+                const next = applyRoundHookEvent({
+                    state: settled,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    eventName: input.eventName,
+                    timestamp,
+                    roundId: shouldStartNewRound ? id() : current?.id ?? "",
+                    settleMs
+                });
+                await save(input, next);
+                if (input.eventName === "UserPromptSubmit") {
+                    clearSettleTimer(input);
+                }
+                else if (next.currentRound) {
+                    scheduleSettleTimer(input, next.currentRound, timestamp);
+                }
+                return toTaskRoundState(next, timestamp);
+            });
         },
         stopSession() { },
-        stopTask() { }
+        stopTask(taskSlug) {
+            clearSettleTimersForTask(taskSlug);
+        }
+    };
+}
+export function applyRoundHookEvent(input) {
+    if (input.eventName === "UserPromptSubmit") {
+        return applyPromptSubmitted(input);
+    }
+    return applyStop(input);
+}
+function applyPromptSubmitted(input) {
+    const current = input.state.currentRound;
+    const shouldStartNewRound = !current || current.status === "paused";
+    const totalRoundCount = shouldStartNewRound
+        ? input.state.totalRoundCount + 1
+        : input.state.totalRoundCount;
+    const nextRound = shouldStartNewRound
+        ? {
+            id: input.roundId,
+            sequence: totalRoundCount,
+            status: "active",
+            activeRole: input.role,
+            startedAt: input.timestamp,
+            lastPromptSubmittedAt: input.timestamp,
+            runningSince: input.timestamp,
+            ccActiveMs: 0,
+            promptSubmitCount: 1,
+            stopCount: 0,
+            roles: [input.role]
+        }
+        : {
+            ...current,
+            status: "active",
+            activeRole: input.role,
+            lastPromptSubmittedAt: input.timestamp,
+            settleDeadlineAt: undefined,
+            pausedAt: undefined,
+            runningSince: current.runningSince ?? input.timestamp,
+            promptSubmitCount: current.promptSubmitCount + 1,
+            roles: appendUniqueRole(current.roles, input.role)
+        };
+    return {
+        ...input.state,
+        taskSlug: input.taskSlug,
+        currentRound: nextRound,
+        totalRoundCount,
+        totalPromptSubmitCount: input.state.totalPromptSubmitCount + 1,
+        totalStopCount: input.state.totalStopCount,
+        totalCcActiveMs: input.state.totalCcActiveMs,
+        updatedAt: input.timestamp
     };
 }
-export function evaluateTaskRoundState(input) {
-    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
-        roleState.status === "using_tools" ||
-        roleState.status === "waiting_user" ||
-        roleState.status === "abnormal");
-    if (activeRole) {
+function applyStop(input) {
+    const current = input.state.currentRound;
+    if (!current || current.status === "paused") {
         return {
+            ...input.state,
             taskSlug: input.taskSlug,
-            status: activeRole.status === "waiting_user" ? "waiting_user" : "active",
-            activeRole: activeRole.role,
-            roles: input.roleStates,
-            updatedAt: input.updatedAt
+            updatedAt: input.timestamp
         };
     }
-    const latestIdleRole = getLatestIdleRole(input.roleStates);
-    const hasPendingRoutes = input.pendingRouteCount > 0;
-    if (latestIdleRole?.lastAnswerEndedAt && !hasPendingRoutes) {
+    const activeDurationMs = current.runningSince
+        ? getDurationMs(current.runningSince, input.timestamp)
+        : 0;
+    const nextRound = {
+        ...current,
+        status: "settling",
+        activeRole: input.role,
+        lastStopAt: input.timestamp,
+        settleDeadlineAt: addMilliseconds(input.timestamp, input.settleMs),
+        runningSince: undefined,
+        ccActiveMs: current.ccActiveMs + activeDurationMs,
+        stopCount: current.stopCount + 1,
+        roles: appendUniqueRole(current.roles, input.role)
+    };
+    return {
+        ...input.state,
+        taskSlug: input.taskSlug,
+        currentRound: nextRound,
+        totalStopCount: input.state.totalStopCount + 1,
+        totalCcActiveMs: input.state.totalCcActiveMs + activeDurationMs,
+        updatedAt: input.timestamp
+    };
+}
+function toTaskRoundState(state, updatedAt) {
+    const current = state.currentRound;
+    if (!current) {
         return {
-            taskSlug: input.taskSlug,
-            status: "completed",
-            activeRole: latestIdleRole.role,
-            completionId: `direct:${latestIdleRole.role}:${latestIdleRole.lastAnswerEndedAt}`,
-            completedAt: latestIdleRole.lastAnswerEndedAt,
-            roles: input.roleStates,
-            updatedAt: input.updatedAt
+            taskSlug: state.taskSlug,
+            status: "idle",
+            promptSubmitCount: 0,
+            stopCount: 0,
+            totalRoundCount: state.totalRoundCount,
+            totalPromptSubmitCount: state.totalPromptSubmitCount,
+            totalStopCount: state.totalStopCount,
+            totalCcActiveMs: state.totalCcActiveMs,
+            currentRoundCcActiveMs: 0,
+            roles: [],
+            updatedAt
         };
     }
+    const activeDurationMs = current.runningSince
+        ? getDurationMs(current.runningSince, updatedAt)
+        : 0;
+    const currentRoundCcActiveMs = current.ccActiveMs + activeDurationMs;
     return {
-        taskSlug: input.taskSlug,
-        status: hasPendingRoutes ? "active" : "idle",
-        activeRole: latestIdleRole?.role,
-        roles: input.roleStates,
-        updatedAt: input.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,
+        lastStopAt: current.lastStopAt,
+        settleDeadlineAt: current.settleDeadlineAt,
+        pausedAt: current.pausedAt,
+        runningSince: current.runningSince,
+        roundSequence: current.sequence,
+        promptSubmitCount: current.promptSubmitCount,
+        stopCount: current.stopCount,
+        totalRoundCount: state.totalRoundCount,
+        totalPromptSubmitCount: state.totalPromptSubmitCount,
+        totalStopCount: state.totalStopCount,
+        totalCcActiveMs: state.totalCcActiveMs + activeDurationMs,
+        currentRoundCcActiveMs,
+        roles: current.roles,
+        updatedAt
     };
 }
-function toRoleTurnState(role, sessions) {
-    const session = sessions.find((candidate) => candidate.role === role && candidate.status === "running");
-    const activityStatus = session?.activityStatus ?? "idle";
+function normalizeRoundFile(input, taskSlug, updatedAt) {
     return {
-        role,
-        sessionId: session?.id,
-        status: session ? activityStatus === "running" ? "answering" : "idle" : "unknown",
-        pendingToolUseCount: 0,
-        lastActivityAt: session?.lastPromptSubmittedAt ?? session?.lastHookEventAt,
-        lastAnswerEndedAt: session?.lastStopAt,
-        reason: session
-            ? activityStatus === "running"
-                ? "Claude Code accepted a prompt and has not emitted Stop yet."
-                : "Claude Code emitted Stop or has not started a prompt in this process."
-            : undefined
+        version: 1,
+        taskSlug,
+        currentRound: normalizeRound(input.currentRound),
+        lastPausedRound: normalizeRound(input.lastPausedRound),
+        totalRoundCount: normalizeNumber(input.totalRoundCount),
+        totalPromptSubmitCount: normalizeNumber(input.totalPromptSubmitCount),
+        totalStopCount: normalizeNumber(input.totalStopCount),
+        totalCcActiveMs: normalizeNumber(input.totalCcActiveMs),
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : updatedAt
     };
 }
-function getLatestIdleRole(roleStates) {
-    return roleStates
-        .filter((roleState) => roleState.status === "idle" && roleState.lastAnswerEndedAt)
-        .sort((left, right) => (left.lastAnswerEndedAt ?? "").localeCompare(right.lastAnswerEndedAt ?? ""))
-        .at(-1);
+function normalizeRound(input) {
+    if (!input || typeof input.id !== "string") {
+        return undefined;
+    }
+    if (input.status !== "active" && input.status !== "settling" && input.status !== "paused") {
+        return undefined;
+    }
+    return {
+        id: input.id,
+        sequence: Number.isFinite(input.sequence) ? input.sequence : 1,
+        status: input.status,
+        activeRole: input.activeRole,
+        startedAt: input.startedAt,
+        lastPromptSubmittedAt: input.lastPromptSubmittedAt,
+        lastStopAt: input.lastStopAt,
+        settleDeadlineAt: input.settleDeadlineAt,
+        pausedAt: input.pausedAt,
+        runningSince: input.runningSince,
+        ccActiveMs: Number.isFinite(input.ccActiveMs) ? input.ccActiveMs : 0,
+        promptSubmitCount: Number.isFinite(input.promptSubmitCount) ? input.promptSubmitCount : 0,
+        stopCount: Number.isFinite(input.stopCount) ? input.stopCount : 0,
+        roles: Array.isArray(input.roles) ? input.roles : []
+    };
+}
+function appendUniqueRole(roles, role) {
+    return roles.includes(role) ? roles : [...roles, role];
+}
+function addMilliseconds(value, milliseconds) {
+    return new Date(new Date(value).getTime() + milliseconds).toISOString();
+}
+function getDurationMs(start, end) {
+    const startMs = Date.parse(start);
+    const endMs = Date.parse(end);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) {
+        return 0;
+    }
+    return Math.max(0, endMs - startMs);
+}
+function normalizeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function getRoundStatePath(input) {
+    return path.join(input.stateRepoRoot, input.stateRoot, "rounds", `${input.taskSlug}.json`);
 }

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

@@ -17,7 +17,7 @@ export function createSessionService(deps) {
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
-        const permissionMode = input.permissionMode ?? persisted?.permissionMode ?? "default";
+        const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
@@ -236,7 +236,13 @@ async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role)
         return undefined;
     }
     const current = await fs.readJson(sessionPath);
-    return current.roles[role]?.record;
+    const record = current.roles[role]?.record;
+    return record
+        ? {
+            ...record,
+            permissionMode: normalizeClaudePermissionMode(record.permissionMode)
+        }
+        : undefined;
 }
 async function persistTaskSession(fs, repoRoot, stateRoot, session) {
     const sessionPath = getTaskSessionPath(repoRoot, stateRoot, session.taskSlug);
@@ -279,3 +285,9 @@ function createEmptyTaskSessionRecord(taskSlug, updatedAt) {
 function getTaskSessionPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "sessions", `${taskSlug}.json`);
 }
+function normalizeClaudePermissionMode(value) {
+    if (value === "bypassPermissions" || value === "dangerously-skip-permissions") {
+        return "bypassPermissions";
+    }
+    return "default";
+}