vibe-coding-master 0.7.16 → 0.7.18

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

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { CCR_GPT_SESSION_MODEL, isCcrSessionModel } from "../../shared/types/session.js";
@@ -17,6 +18,7 @@ const PROJECT_TRANSLATOR_SCOPE = "__project__";
 const PROJECT_HARNESS_ENGINEER_SCOPE = "__project_harness_engineer__";
 const PROJECT_TOOL_CD_ENTER_DELAY_MS = 500;
 const CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+const CLAUDE_CODE_DISABLE_BACKGROUND_TASKS = "1";
 // Project tool sessions launch a Claude Code TUI inside a PTY. The PTY reports
 // "running" the instant it is spawned, which is earlier than the moment the TUI
 // can actually accept pasted input. These bounds drive a quiescence-based
@@ -80,9 +82,10 @@ export function createSessionService(deps) {
                 ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
                 : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt),
             cwd: taskRepoRoot
         };
+        const runtimeSessionToken = randomUUID();
         const runtimeSession = await deps.runtime.createSession({
             repoRoot,
             taskSlug,
@@ -96,8 +99,9 @@ export function createSessionService(deps) {
                 VCM_TASK_REPO_ROOT: taskRepoRoot,
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
-                VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+                VCM_SESSION_ID: claudeSessionId || undefined,
+                VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, role, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -105,6 +109,7 @@ export function createSessionService(deps) {
         const harnessRevision = await readCurrentHarnessRevision(repoRoot);
         const record = {
             id: runtimeSession.id,
+            runtimeSessionToken,
             claudeSessionId,
             transcriptPath,
             taskSlug,
@@ -207,6 +212,7 @@ export function createSessionService(deps) {
             ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
+        const runtimeSessionToken = randomUUID();
         const runtimeSession = await deps.runtime.createSession({
             repoRoot,
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
@@ -223,8 +229,9 @@ export function createSessionService(deps) {
                 // active task; VCM_TASK_REPO_ROOT remains the active worktree.
                 VCM_TASK_SLUG: PROJECT_TRANSLATOR_SCOPE,
                 VCM_ROLE: TRANSLATOR_ROLE,
-                VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+                VCM_SESSION_ID: claudeSessionId || undefined,
+                VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, TRANSLATOR_ROLE, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -232,6 +239,7 @@ export function createSessionService(deps) {
         const harnessRevision = await readCurrentHarnessRevision(repoRoot);
         const record = {
             id: runtimeSession.id,
+            runtimeSessionToken,
             claudeSessionId,
             transcriptPath,
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
@@ -320,6 +328,7 @@ export function createSessionService(deps) {
             ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
+        const runtimeSessionToken = randomUUID();
         const runtimeSession = await deps.runtime.createSession({
             repoRoot,
             taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE,
@@ -336,8 +345,9 @@ export function createSessionService(deps) {
                 // active task; VCM_TASK_REPO_ROOT remains the active worktree.
                 VCM_TASK_SLUG: PROJECT_HARNESS_ENGINEER_SCOPE,
                 VCM_ROLE: HARNESS_ENGINEER_ROLE,
-                VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+                VCM_SESSION_ID: claudeSessionId || undefined,
+                VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, HARNESS_ENGINEER_ROLE, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -345,6 +355,7 @@ export function createSessionService(deps) {
         const harnessRevision = await readCurrentHarnessRevision(repoRoot);
         const record = {
             id: runtimeSession.id,
+            runtimeSessionToken,
             claudeSessionId,
             transcriptPath,
             taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE,
@@ -515,6 +526,7 @@ export function createSessionService(deps) {
             ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
+        const runtimeSessionToken = randomUUID();
         const runtimeSession = await deps.runtime.createSession({
             repoRoot,
             taskSlug: normalizeProjectScopedRecordForPersistence(session).taskSlug,
@@ -528,14 +540,16 @@ export function createSessionService(deps) {
                 VCM_TASK_REPO_ROOT: targetCwd,
                 VCM_TASK_SLUG: normalizeProjectScopedRecordForPersistence(session).taskSlug,
                 VCM_ROLE: session.role,
-                VCM_SESSION_ID: session.claudeSessionId
-            }, modelEnvironment)
+                VCM_SESSION_ID: session.claudeSessionId,
+                VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, session.role, model))
         });
         if ((await waitForSessionInputReady(runtimeSession.id)) === "exited") {
             deps.registry.remove(runtimeSession.id);
             return markProjectToolRuntimeUnavailable(repoRoot, {
                 ...session,
                 id: runtimeSession.id,
+                runtimeSessionToken,
                 status: "crashed",
                 activityStatus: "idle",
                 command: startCommand.display,
@@ -553,6 +567,7 @@ export function createSessionService(deps) {
         const resumed = {
             ...session,
             id: runtimeSession.id,
+            runtimeSessionToken,
             status: runtimeSession.status,
             activityStatus: "idle",
             command: startCommand.display,
@@ -679,9 +694,9 @@ export function createSessionService(deps) {
         const view = toRoleSessionRecordView(record, deps.runtime);
         return view ? withHarnessRevisionView(repoRoot, view) : undefined;
     }
-    async function markTaskRoleActivityIdle(repoRoot, taskSlug, role) {
+    async function markTaskRoleActivityIdle(repoRoot, taskSlug, role, expectedSessionId) {
         const current = await getTaskRoleSessionView(repoRoot, taskSlug, role);
-        if (!current) {
+        if (!current || (expectedSessionId && current.id !== expectedSessionId)) {
             return undefined;
         }
         const timestamp = now();
@@ -794,7 +809,7 @@ export function createSessionService(deps) {
         },
         async recordProjectTranslatorHookEvent(repoRoot, input) {
             const current = await this.getProjectTranslatorSession(repoRoot);
-            if (!current) {
+            if (!current || !matchesRoleHookSession(current, input)) {
                 return undefined;
             }
             const timestamp = now();
@@ -920,7 +935,7 @@ export function createSessionService(deps) {
         },
         async recordProjectHarnessEngineerHookEvent(repoRoot, input) {
             const current = await this.getProjectHarnessEngineerSession(repoRoot);
-            if (!current) {
+            if (!current || !matchesRoleHookSession(current, input)) {
                 return undefined;
             }
             const timestamp = now();
@@ -1039,7 +1054,7 @@ export function createSessionService(deps) {
         },
         async recordRoleHookEvent(repoRoot, input) {
             const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
-            if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
+            if (!current || !matchesRoleHookSession(current, input)) {
                 return undefined;
             }
             const timestamp = now();
@@ -1071,7 +1086,9 @@ export function createSessionService(deps) {
                 eventName: input.eventName,
                 sessionId: input.claudeSessionId,
                 transcriptPath: input.transcriptPath,
-                cwd: input.cwd
+                cwd: input.cwd,
+                runtimeSessionId: input.runtimeSessionId,
+                runtimeSessionToken: input.runtimeSessionToken
             });
         },
         async markTerminalSessionActivityIdle(repoRoot, sessionId) {
@@ -1094,11 +1111,11 @@ export function createSessionService(deps) {
                     ? markProjectToolActivityIdle(repoRoot, current, persistHarnessEngineerSession)
                     : undefined;
             }
-            return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
+            return markTaskRoleActivityIdle(repoRoot, taskSlug, role, sessionId);
         },
-        async markRoleActivityRunning(repoRoot, taskSlug, role) {
+        async markRoleActivityRunning(repoRoot, taskSlug, role, expectedSessionId) {
             const current = await this.getRoleSession(repoRoot, taskSlug, role);
-            if (!current) {
+            if (!current || (expectedSessionId && current.id !== expectedSessionId)) {
                 return undefined;
             }
             const timestamp = now();
@@ -1154,7 +1171,18 @@ function toRoleSessionRecordView(record, runtime) {
         exitCode: runtimeSession.exitCode
     };
 }
-function matchesRoleHookSession(record, input) {
+export function matchesRoleHookSession(record, input) {
+    if (!record.claudeSessionId
+        && !record.transcriptPath
+        && input.eventName !== "UserPromptSubmit") {
+        return false;
+    }
+    if (input.runtimeSessionId) {
+        return record.id === input.runtimeSessionId;
+    }
+    if (record.runtimeSessionToken) {
+        return record.runtimeSessionToken === input.runtimeSessionToken;
+    }
     if (!record.claudeSessionId && !record.transcriptPath) {
         return input.eventName === "UserPromptSubmit";
     }
@@ -1164,9 +1192,6 @@ function matchesRoleHookSession(record, input) {
     if (input.transcriptPath && record.transcriptPath === input.transcriptPath) {
         return true;
     }
-    if (!input.sessionId && !input.transcriptPath) {
-        return true;
-    }
     return false;
 }
 function nextHookSessionIdentity(current, input) {
@@ -1208,7 +1233,7 @@ function isSessionMissingError(error) {
         error.code === "SESSION_MISSING";
 }
 function withoutRuntimeOnlySessionFields(session) {
-    const { pid: _pid, ...persisted } = session;
+    const { pid: _pid, runtimeSessionToken: _runtimeSessionToken, ...persisted } = session;
     return persisted;
 }
 function defaultIsProcessAlive(pid) {
@@ -1536,11 +1561,39 @@ function formatClaudeCdCommand(targetCwd) {
 function isExitedStatus(status) {
     return status === "exited" || status === "crashed" || status === "missing";
 }
-function withClaudeCodeRuntimeEnv(env, modelEnvironment = {}) {
+function withClaudeCodeRuntimeEnv(env, modelEnvironment = {}, telemetryEnvironment = {}) {
     return {
         ...env,
         ...modelEnvironment,
-        CLAUDE_CODE_DISABLE_AUTO_MEMORY
+        ...telemetryEnvironment,
+        CLAUDE_CODE_DISABLE_AUTO_MEMORY,
+        CLAUDE_CODE_DISABLE_BACKGROUND_TASKS
+    };
+}
+function buildUsageTelemetryEnvironment(apiUrl, role, model) {
+    const disabled = {
+        CLAUDE_CODE_ENABLE_TELEMETRY: undefined,
+        OTEL_LOGS_EXPORTER: "none",
+        OTEL_METRICS_EXPORTER: "none",
+        OTEL_TRACES_EXPORTER: "none",
+        OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: undefined,
+        OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: undefined,
+        OTEL_RESOURCE_ATTRIBUTES: undefined,
+        OTEL_LOG_USER_PROMPTS: "0",
+        OTEL_LOG_ASSISTANT_RESPONSES: "0",
+        OTEL_LOG_TOOL_DETAILS: "0",
+        OTEL_LOG_RAW_API_BODIES: "0"
+    };
+    if (!apiUrl || isCcrSessionModel(model)) {
+        return disabled;
+    }
+    return {
+        ...disabled,
+        CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+        OTEL_LOGS_EXPORTER: "otlp",
+        OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: "http/json",
+        OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${apiUrl.replace(/\/+$/, "")}/api/telemetry/v1/logs`,
+        OTEL_RESOURCE_ATTRIBUTES: `vcm.role=${role},vcm.launch_id=${randomUUID()}`
     };
 }
 function delay(ms) {

package/dist/backend/services/task-close-service.js

@@ -5,6 +5,7 @@ export function createTaskCloseService(deps) {
         async closeTask(repoRoot, taskSlug) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
+            deps.architectRestartService?.clear(repoRoot, taskSlug);
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);

package/dist/backend/services/terminal-interrupt-service.js

@@ -11,7 +11,10 @@ export function createTerminalInterruptService(deps) {
             if (!repoRoot) {
                 return;
             }
-            await deps.sessionService.markTerminalSessionActivityIdle(repoRoot, sessionId);
+            const session = await deps.sessionService.markTerminalSessionActivityIdle(repoRoot, sessionId);
+            if (!session) {
+                return;
+            }
             if (!isVcmRoleName(terminalSession.role)) {
                 return;
             }

package/dist/backend/services/turn-reconciler-service.js

@@ -96,6 +96,7 @@ function buildReconciledHook(taskSlug, role, session, eventName, evidence) {
             ...(session?.claudeSessionId ? { session_id: session.claudeSessionId } : {}),
             ...(session?.transcriptPath ? { transcript_path: session.transcriptPath } : {}),
             ...(session?.cwd ? { cwd: session.cwd } : {}),
+            ...(session?.id ? { vcm_runtime_session_id: session.id } : {}),
             vcm_reconciled: true,
             ...evidence
         }

package/dist/backend/services/usage-analytics-service.js

@@ -0,0 +1,346 @@
+import path from "node:path";
+import { ROLE_NAMES, isRoleName } from "../../shared/constants.js";
+const USAGE_FILE = path.join("telemetry", "usage.json");
+export function createUsageAnalyticsService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    const writeQueues = new Map();
+    return {
+        async ingest(taskRepoRoot, stateRoot, payload) {
+            const events = extractApiRequestEvents(payload);
+            if (events.length === 0) {
+                return;
+            }
+            const usagePath = getUsagePath(taskRepoRoot, stateRoot);
+            await enqueueWrite(writeQueues, usagePath, async () => {
+                const state = await loadState(deps.fs, usagePath);
+                const seen = new Set(state.seenEvents);
+                let changed = false;
+                for (const event of events) {
+                    if (seen.has(event.eventKey)) {
+                        continue;
+                    }
+                    seen.add(event.eventKey);
+                    state.seenEvents.push(event.eventKey);
+                    addEvent(state, event);
+                    changed = true;
+                }
+                if (!changed) {
+                    return;
+                }
+                state.updatedAt = now();
+                await deps.fs.writeJsonAtomic(usagePath, state);
+            });
+        },
+        async getReport(taskRepoRoot, stateRoot, taskSlug) {
+            const usagePath = getUsagePath(taskRepoRoot, stateRoot);
+            await writeQueues.get(usagePath);
+            if (!(await deps.fs.pathExists(usagePath))) {
+                return emptyReport(taskSlug);
+            }
+            const state = normalizeStoredState(await deps.fs.readJson(usagePath));
+            return toReport(taskSlug, state);
+        }
+    };
+}
+function extractApiRequestEvents(payload) {
+    if (!isObject(payload) || !Array.isArray(payload.resourceLogs)) {
+        return [];
+    }
+    const events = [];
+    for (const resourceLog of payload.resourceLogs) {
+        if (!isObject(resourceLog)) {
+            continue;
+        }
+        const resourceAttributes = readAttributes(isObject(resourceLog.resource) ? resourceLog.resource.attributes : undefined);
+        if (!Array.isArray(resourceLog.scopeLogs)) {
+            continue;
+        }
+        for (const scopeLog of resourceLog.scopeLogs) {
+            if (!isObject(scopeLog) || !Array.isArray(scopeLog.logRecords)) {
+                continue;
+            }
+            for (const logRecord of scopeLog.logRecords) {
+                if (!isObject(logRecord)) {
+                    continue;
+                }
+                const attributes = {
+                    ...resourceAttributes,
+                    ...readAttributes(logRecord.attributes)
+                };
+                if (readString(attributes["event.name"]) !== "api_request") {
+                    continue;
+                }
+                const roleValue = readString(attributes["vcm.role"]);
+                const launchId = readString(attributes["vcm.launch_id"]);
+                if (!roleValue || !isRoleName(roleValue) || !launchId) {
+                    continue;
+                }
+                const model = normalizeModel(readString(attributes.model));
+                if (isCcrModel(model)) {
+                    continue;
+                }
+                const sequence = readInteger(attributes["event.sequence"]);
+                const sessionId = readString(attributes["session.id"]) || launchId;
+                const requestId = readString(attributes.request_id);
+                const timestamp = readString(logRecord.timeUnixNano) || readString(logRecord.observedTimeUnixNano);
+                const fallbackIdentity = [sessionId, requestId, timestamp, model].join(":");
+                const eventKey = `${launchId}:${sequence ?? fallbackIdentity}`;
+                const costUsdMicros = readNonNegativeInteger(attributes.cost_usd_micros)
+                    ?? Math.round((readNonNegativeNumber(attributes.cost_usd) ?? 0) * 1_000_000);
+                events.push({
+                    eventKey,
+                    role: roleValue,
+                    model,
+                    sessionId,
+                    inputTokens: readNonNegativeInteger(attributes.input_tokens) ?? 0,
+                    outputTokens: readNonNegativeInteger(attributes.output_tokens) ?? 0,
+                    cacheReadTokens: readNonNegativeInteger(attributes.cache_read_tokens) ?? 0,
+                    cacheCreationTokens: readNonNegativeInteger(attributes.cache_creation_tokens) ?? 0,
+                    costUsdMicros
+                });
+            }
+        }
+    }
+    return events;
+}
+function addEvent(state, event) {
+    addTotals(state.totals, event);
+    state.byRole[event.role] ??= emptyStoredTotals();
+    addTotals(state.byRole[event.role], event);
+    state.byModel[event.model] ??= emptyStoredTotals();
+    addTotals(state.byModel[event.model], event);
+    addUnique(state.sessionsByRole, event.role, event.sessionId);
+    addUnique(state.sessionsByModel, event.model, event.sessionId);
+}
+function addTotals(target, event) {
+    target.inputTokens += event.inputTokens;
+    target.outputTokens += event.outputTokens;
+    target.cacheReadTokens += event.cacheReadTokens;
+    target.cacheCreationTokens += event.cacheCreationTokens;
+    target.costUsdMicros += event.costUsdMicros;
+    target.requestCount += 1;
+}
+function addUnique(target, key, value) {
+    const values = target[key] ?? [];
+    if (!values.includes(value)) {
+        values.push(value);
+    }
+    target[key] = values;
+}
+async function loadState(fs, usagePath) {
+    if (!(await fs.pathExists(usagePath))) {
+        return emptyStoredState();
+    }
+    return normalizeStoredState(await fs.readJson(usagePath));
+}
+function normalizeStoredState(input) {
+    return {
+        version: 1,
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : new Date(0).toISOString(),
+        seenEvents: Array.isArray(input.seenEvents) ? input.seenEvents.filter((value) => typeof value === "string") : [],
+        sessionsByRole: normalizeRoleStringLists(input.sessionsByRole),
+        sessionsByModel: normalizeStringLists(input.sessionsByModel),
+        totals: normalizeStoredTotals(input.totals),
+        byRole: normalizeRoleTotals(input.byRole),
+        byModel: normalizeModelTotals(input.byModel)
+    };
+}
+function normalizeRoleStringLists(input) {
+    if (!isObject(input)) {
+        return {};
+    }
+    const result = {};
+    for (const role of ROLE_NAMES) {
+        const values = input[role];
+        if (Array.isArray(values)) {
+            result[role] = values.filter((value) => typeof value === "string");
+        }
+    }
+    return result;
+}
+function normalizeStringLists(input) {
+    const result = {};
+    if (!isObject(input)) {
+        return result;
+    }
+    for (const [key, values] of Object.entries(input)) {
+        if (isSafeGroupKey(key) && Array.isArray(values)) {
+            result[key] = values.filter((value) => typeof value === "string");
+        }
+    }
+    return result;
+}
+function normalizeRoleTotals(input) {
+    if (!isObject(input)) {
+        return {};
+    }
+    const result = {};
+    for (const role of ROLE_NAMES) {
+        if (isObject(input[role])) {
+            result[role] = normalizeStoredTotals(input[role]);
+        }
+    }
+    return result;
+}
+function normalizeModelTotals(input) {
+    const result = {};
+    if (!isObject(input)) {
+        return result;
+    }
+    for (const [key, totals] of Object.entries(input)) {
+        if (isSafeGroupKey(key) && isObject(totals)) {
+            result[key] = normalizeStoredTotals(totals);
+        }
+    }
+    return result;
+}
+function normalizeStoredTotals(input) {
+    const value = isObject(input) ? input : {};
+    return {
+        inputTokens: readNonNegativeInteger(value.inputTokens) ?? 0,
+        outputTokens: readNonNegativeInteger(value.outputTokens) ?? 0,
+        cacheReadTokens: readNonNegativeInteger(value.cacheReadTokens) ?? 0,
+        cacheCreationTokens: readNonNegativeInteger(value.cacheCreationTokens) ?? 0,
+        costUsdMicros: readNonNegativeInteger(value.costUsdMicros) ?? 0,
+        requestCount: readNonNegativeInteger(value.requestCount) ?? 0
+    };
+}
+function toReport(taskSlug, state) {
+    const allSessions = new Set(Object.values(state.sessionsByRole).flatMap((values) => values ?? []));
+    const byRole = ROLE_NAMES.map((role) => ({
+        role,
+        ...toPublicTotals(state.byRole[role] ?? emptyStoredTotals(), state.sessionsByRole[role]?.length ?? 0)
+    }));
+    const byModel = Object.keys(state.byModel)
+        .sort((left, right) => left.localeCompare(right))
+        .map((model) => ({
+        model,
+        ...toPublicTotals(state.byModel[model], state.sessionsByModel[model]?.length ?? 0)
+    }));
+    return {
+        version: 1,
+        taskSlug,
+        updatedAt: state.updatedAt,
+        totals: toPublicTotals(state.totals, allSessions.size),
+        byRole,
+        byModel
+    };
+}
+function emptyReport(taskSlug) {
+    return {
+        version: 1,
+        taskSlug,
+        updatedAt: null,
+        totals: toPublicTotals(emptyStoredTotals(), 0),
+        byRole: ROLE_NAMES.map((role) => ({ role, ...toPublicTotals(emptyStoredTotals(), 0) })),
+        byModel: []
+    };
+}
+function toPublicTotals(totals, sessionCount) {
+    return {
+        inputTokens: totals.inputTokens,
+        outputTokens: totals.outputTokens,
+        cacheReadTokens: totals.cacheReadTokens,
+        cacheCreationTokens: totals.cacheCreationTokens,
+        costUsd: totals.costUsdMicros / 1_000_000,
+        requestCount: totals.requestCount,
+        sessionCount
+    };
+}
+function emptyStoredState() {
+    return {
+        version: 1,
+        updatedAt: new Date(0).toISOString(),
+        seenEvents: [],
+        sessionsByRole: {},
+        sessionsByModel: {},
+        totals: emptyStoredTotals(),
+        byRole: {},
+        byModel: {}
+    };
+}
+function emptyStoredTotals() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsdMicros: 0,
+        requestCount: 0
+    };
+}
+function getUsagePath(taskRepoRoot, stateRoot) {
+    return path.join(taskRepoRoot, stateRoot, USAGE_FILE);
+}
+async function enqueueWrite(queues, key, operation) {
+    const previous = queues.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(operation);
+    queues.set(key, current);
+    try {
+        await current;
+    }
+    finally {
+        if (queues.get(key) === current) {
+            queues.delete(key);
+        }
+    }
+}
+function readAttributes(input) {
+    const result = {};
+    if (!Array.isArray(input)) {
+        return result;
+    }
+    for (const entry of input) {
+        if (!isObject(entry) || typeof entry.key !== "string") {
+            continue;
+        }
+        result[entry.key] = readAnyValue(entry.value);
+    }
+    return result;
+}
+function readAnyValue(input) {
+    if (!isObject(input)) {
+        return input;
+    }
+    for (const key of ["stringValue", "intValue", "doubleValue", "boolValue"]) {
+        if (key in input) {
+            return input[key];
+        }
+    }
+    return undefined;
+}
+function readString(input) {
+    if (typeof input === "string") {
+        return input.trim() || undefined;
+    }
+    if (typeof input === "number" || typeof input === "bigint") {
+        return String(input);
+    }
+    return undefined;
+}
+function readInteger(input) {
+    const value = typeof input === "number" ? input : typeof input === "string" ? Number(input) : Number.NaN;
+    return Number.isSafeInteger(value) ? value : undefined;
+}
+function readNonNegativeInteger(input) {
+    const value = readInteger(input);
+    return value !== undefined && value >= 0 ? value : undefined;
+}
+function readNonNegativeNumber(input) {
+    const value = typeof input === "number" ? input : typeof input === "string" ? Number(input) : Number.NaN;
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function normalizeModel(input) {
+    const model = input?.slice(0, 200).trim();
+    return model && isSafeGroupKey(model) ? model : "unknown";
+}
+function isCcrModel(model) {
+    const normalized = model.toLowerCase();
+    return normalized.startsWith("gpt-") || normalized.startsWith("ccr:") || normalized.includes("codex api/");
+}
+function isSafeGroupKey(value) {
+    return value !== "__proto__" && value !== "prototype" && value !== "constructor";
+}
+function isObject(input) {
+    return typeof input === "object" && input !== null && !Array.isArray(input);
+}

package/dist/backend/templates/handoff.js

@@ -183,6 +183,10 @@ TBD
 
 ## Blocking Validation Issues
 
+TBD
+
+## User Approval Evidence
+
 TBD
 `;
 }