specrails-desktop 2.55.0 → 2.56.0

package/server/dist/{rails-router.js → modules/delivery/runtime/rails-router.js}

@@ -6,56 +6,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prDeliveryRevisionAllowed = prDeliveryRevisionAllowed;
 exports.createRailsRouter = createRailsRouter;
 const pr_follow_up_1 = require("./pr-follow-up");
-const agent_runtime_settings_1 = require("./agent-runtime-settings");
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const path_1 = __importDefault(require("path"));
 const express_1 = require("express");
 const rails_store_1 = require("./rails-store");
-const queue_manager_1 = require("./queue-manager");
-const provider_selection_1 = require("./provider-selection");
-const feature_flags_1 = require("./feature-flags");
-const file_provenance_1 = require("./file-provenance");
-const file_story_1 = require("./file-story");
-const loops_store_1 = require("./loops-store");
-const loop_runs_store_1 = require("./loop-runs-store");
-const registry_1 = require("./providers/registry");
-const providers_1 = require("./providers");
-const loop_role_engines_1 = require("./loop-role-engines");
-const runtime_1 = require("./providers/runtime");
-const agent_defaults_1 = require("./agent-defaults");
-const profile_manager_1 = require("./profile-manager");
-const spec_models_1 = require("./spec-models");
-const workspace_resolution_1 = require("./workspace-resolution");
-const loop_factory_1 = require("./loop-factory");
-const loop_constants_1 = require("./loop-constants");
-const loop_command_catalog_1 = require("./loop-command-catalog");
-const loop_graph_1 = require("./loop-graph");
+const queue_manager_1 = require("../../execution/runtime/queue-manager");
+const provider_selection_1 = require("../../../provider-selection");
+const feature_flags_1 = require("../../../feature-flags");
+const file_provenance_1 = require("../../code/runtime/file-provenance");
+const file_story_1 = require("../../code/runtime/file-story");
+const loops_store_1 = require("../../loops/runtime/loops-store");
+const loop_runs_store_1 = require("../../loops/runtime/loop-runs-store");
+const registry_1 = require("../../../providers/registry");
+const providers_1 = require("../../../providers");
+const loop_role_engines_1 = require("../../loops/runtime/loop-role-engines");
+const runtime_1 = require("../../../providers/runtime");
+const agent_defaults_1 = require("../../agents/runtime/agent-defaults");
+const profile_manager_1 = require("../../agents/runtime/profile-manager");
+const spec_models_1 = require("../../specs/runtime/spec-models");
+const workspace_resolution_1 = require("../../../workspace-resolution");
+const loop_factory_1 = require("../../loops/runtime/loop-factory");
+const loop_constants_1 = require("../../loops/runtime/loop-constants");
+const loop_command_catalog_1 = require("../../loops/runtime/loop-command-catalog");
+const loop_graph_1 = require("../../loops/runtime/loop-graph");
 const rail_isolation_1 = require("./rail-isolation");
 const rail_pr_store_1 = require("./rail-pr-store");
-const loop_effect_1 = require("./loop-effect");
+const loop_effect_1 = require("../../loops/runtime/loop-effect");
 const review_packet_1 = require("./review-packet");
 const delivery_evidence_1 = require("./delivery-evidence");
-const accept_ladder_1 = require("./accept-ladder");
+const accept_ladder_1 = require("../../execution/runtime/accept-ladder");
 const rail_pr_decision_1 = require("./rail-pr-decision");
 const active_pr_continuation_1 = require("./active-pr-continuation");
 const rail_isolated_launch_1 = require("./rail-isolated-launch");
-const worktree_manager_1 = require("./worktree-manager");
-const integration_branch_1 = require("./integration-branch");
+const worktree_manager_1 = require("../../../worktree-manager");
+const integration_branch_1 = require("../../../integration-branch");
 const rail_worktree_release_1 = require("./rail-worktree-release");
-const project_git_1 = require("./project-git");
+const project_git_1 = require("../../../project-git");
 const pr_publisher_1 = require("./pr-publisher");
-const project_repositories_1 = require("./project-repositories");
+const project_repositories_1 = require("../../../project-repositories");
 const multi_repo_checkout_1 = require("./multi-repo-checkout");
 const multi_repo_bases_1 = require("./multi-repo-bases");
 const multi_repo_execution_1 = require("./multi-repo-execution");
 const multi_repo_execution_store_1 = require("./multi-repo-execution-store");
-const ids_1 = require("./ids");
-const repo_lock_1 = require("./repo-lock");
-const agent_chat_registry_1 = require("./agent-chat-registry");
-const mission_run_notify_1 = require("./mission-run-notify");
-const agent_runtime_controls_router_1 = require("./agent-runtime-controls-router");
-const ticket_store_1 = require("./ticket-store");
-const spec_addenda_1 = require("./spec-addenda");
-const process_admission_1 = require("./process-admission");
+const ids_1 = require("../../../ids");
+const repo_lock_1 = require("../../../repo-lock");
+const agent_chat_registry_1 = require("../../missions/runtime/agent-chat-registry");
+const mission_run_notify_1 = require("../../missions/runtime/mission-run-notify");
+const agent_runtime_controls_router_1 = require("../../agent-runtime/runtime/agent-runtime-controls-router");
+const ticket_store_1 = require("../../specs/runtime/ticket-store");
+const spec_addenda_1 = require("../../specs/runtime/spec-addenda");
+const process_admission_1 = require("../../../process-admission");
 const VALID_MODES = new Set(['implement', 'batch-implement', 'freestyle', 'loop']);
 function prDeliveryContinuesTickets(delivery, ticketIds) {
     if (delivery.decision !== 'pr_draft' && delivery.decision !== 'pr_ready')
@@ -562,18 +562,7 @@ function createRailsRouter() {
                 res.status(404).json({ error: 'Factory loop not found' });
                 return;
             }
-            // The revision loop is meaningless without a revision to apply: its prompt
-            // consumes {{const:REVISION_REQUEST}}, and an unresolved constant renders
-            // as an EMPTY string (loop-constants), so naming it directly would spawn a
-            // run whose central instruction is silently blank. It is reachable by id
-            // (fork/preview resolve it), so the launch door has to refuse it.
-            if (loopId === loop_factory_1.FACTORY_REVISION_LOOP_ID && !revisionOfDeliveryId) {
-                res.status(400).json({
-                    error: 'revision_loop_requires_revision',
-                    detail: 'factory:revision only runs as a revision — pass revisionOfDeliveryId and revisionNote instead of naming the loop',
-                });
-                return;
-            }
+            loopId = (0, loop_factory_1.getFactoryLoop)(loopId).id; // canonicalize saved legacy aliases
             mode = fmode;
         }
         if (!VALID_MODES.has(mode)) {
@@ -589,16 +578,10 @@ function createRailsRouter() {
         if ((0, feature_flags_1.isLoopsEnabled)() && (typeof loopId !== 'string' || !loopId) && mode !== 'loop') {
             loopId = (0, loop_factory_1.factoryLoopForMode)(mode)?.id;
         }
-        // A revision must run the Architect-LESS revision loop, whatever the rail's
-        // stored mode is. Without this every one-sentence tweak would re-run the
-        // full implement pipeline — the exact cost the feature exists to avoid.
-        // An explicit loopId is respected (a caller naming a loop means it).
-        if (revisionOfDeliveryId && (0, feature_flags_1.isLoopsEnabled)() && (typeof loopId !== 'string' || !loopId || (0, loop_factory_1.isFactoryLoopId)(loopId))) {
-            const revisionLoop = (0, loop_factory_1.getFactoryLoop)(loop_factory_1.FACTORY_REVISION_LOOP_ID);
-            if (revisionLoop) {
-                loopId = revisionLoop.id;
-                mode = revisionLoop.mode;
-            }
+        // Delivery continuation always uses Quick SDD; the old Revision loop is retired.
+        if (revisionOfDeliveryId && (0, feature_flags_1.isLoopsEnabled)()) {
+            loopId = 'factory:sdd-quick-openspec';
+            mode = 'loop';
         }
         if (mode === 'loop' && !(0, feature_flags_1.isLoopsEnabled)()) {
             res.status(403).json({ error: 'Loops are disabled on this server' });
@@ -635,6 +618,13 @@ function createRailsRouter() {
             res.status(400).json({ error: 'Rail has no tickets assigned' });
             return;
         }
+        // The durable delta chooses Quick SDD regardless of stale rail/agent defaults.
+        // Revision is a delivery-continuation mechanism, not the implementation loop.
+        const launchAddenda = (0, spec_addenda_1.planSpecAddendaAt)((0, spec_addenda_1.ticketStorePathForProject)(c.project), rail.ticketIds);
+        if (launchAddenda.length && (0, feature_flags_1.isLoopsEnabled)()) {
+            loopId = 'factory:sdd-quick-openspec';
+            mode = 'loop';
+        }
         let repositoryIds;
         const primaryRepository = (0, project_repositories_1.getProjectRepositories)(c.project).find((repository) => repository.isPrimary);
         try {
@@ -954,13 +944,19 @@ function createRailsRouter() {
                         }
                     }
                     const pendingSnapshot = pending ? (0, rail_pr_store_1.toPrDeliverySnapshot)(pending) : null;
-                    // A revision is the ONE launch allowed to proceed against an
-                    // undecided delivery, and only on the exact terms below: the caller
-                    // names that delivery AND covers its full ticket set. Anything else
-                    // would silently append work to branches the user has not judged.
+                    if (revisionOfDeliveryId && !pendingSnapshot) {
+                        res.status(409).json({ error: 'invalid_revision_target', detail: 'The delivery is no longer active; refresh before continuing.' });
+                        return;
+                    }
+                    // Continue only the exact active generation and its full spec set.
+                    // Explicit change requests name it; open addenda on the same rail
+                    // identify it implicitly. Both use the existing supersession contract.
                     const revisionsEnabled = (0, feature_flags_1.areDeliveryRevisionsEnabled)();
-                    const revisionOfPending = Boolean(revisionsEnabled && pendingSnapshot && revisionOfDeliveryId
-                        && prDeliveryRevisionAllowed(pendingSnapshot, revisionOfDeliveryId, rail.ticketIds));
+                    const addendumContinuation = Boolean(launchAddenda.length && pendingSnapshot && pendingSnapshot.decision !== 'building'
+                        && !revisionOfDeliveryId
+                        && prDeliveryRevisionAllowed(pendingSnapshot, pendingSnapshot.id, rail.ticketIds));
+                    const revisionOfPending = Boolean(revisionsEnabled && pendingSnapshot && (addendumContinuation || (revisionOfDeliveryId
+                        && prDeliveryRevisionAllowed(pendingSnapshot, revisionOfDeliveryId, rail.ticketIds))));
                     if (revisionsEnabled && pendingSnapshot && revisionOfDeliveryId && !revisionOfPending) {
                         res.status(409).json({
                             error: 'invalid_revision_target',
@@ -977,14 +973,17 @@ function createRailsRouter() {
                         revisionRequest = {
                             ofDeliveryId: pendingSnapshot.id,
                             decision: pendingSnapshot.decision,
-                            note: revisionNote,
+                            note: addendumContinuation
+                                ? `Implement the attached spec addenda only: ${launchAddenda.flatMap((entry) => entry.addenda.map((a) => `#${entry.ticketId} [${a.id}] ${a.title}`)).join('; ')}. Their complete frozen bodies are in SPEC ADDENDA; preserve existing behavior outside that scope.`
+                                : revisionNote,
                         };
                     }
                     // Explicit target vs an undecided continuable delivery: the slot's
                     // active generation owns its PR. A DIFFERENT explicit target would
                     // append to the undecided branches → 409; the SAME PR is redundant
                     // (the continuation contract below already drives it) and is dropped.
-                    if (pendingSnapshot && typeof targetPrNumber === 'number' && pendingSnapshot.prNumber !== targetPrNumber) {
+                    if (pendingSnapshot && typeof targetPrNumber === 'number' && pendingSnapshot.prNumber !== targetPrNumber
+                        && !pendingSnapshot.repositoryDeliveries?.some((delivery) => delivery.prNumber === targetPrNumber)) {
                         res.status(409).json({ error: 'pr_decision_pending', prDeliveryId: pendingSnapshot.id });
                         return;
                     }
@@ -1067,7 +1066,7 @@ function createRailsRouter() {
                                 originConversationId: originConversationId ?? null,
                                 ...(baseBranch ? { baseBranch } : {}),
                                 ...(continuablePrDelivery?.executionManifest && !revisionRequest ? { repositoryContinuation: { deliveryId: continuablePrDelivery.id, decision: continuablePrDelivery.decision } } : {}),
-                                ...(continuablePrDelivery && !continuablePrDelivery.executionManifest ? {
+                                ...(continuablePrDelivery && !continuablePrDelivery.executionManifest && prDeliveryContinuesTickets(continuablePrDelivery, rail.ticketIds) ? {
                                     requiredPrContinuation: {
                                         deliveryId: continuablePrDelivery.id,
                                         decision: continuablePrDelivery.decision,
@@ -1089,7 +1088,7 @@ function createRailsRouter() {
                                 ...(revisionRequest ? { revision: revisionRequest } : {}),
                                 ...(followUp ? { followUp } : {}),
                             });
-                            res.status(202).json({ loopRunIds: ids, railIndex, mode, isolated: true, ...(followUp ? { followUp: { id: followUp.id, version: followUp.version, hash: followUp.hash } } : {}) });
+                            res.status(202).json({ loopRunIds: ids, railIndex, mode, loopId, prDeliveryId: (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex)?.id ?? null, isolated: true, ...(followUp ? { followUp: { id: followUp.id, version: followUp.version, hash: followUp.hash } } : {}) });
                             return;
                         }
                         catch (err) {
@@ -1770,4 +1769,4 @@ function createRailsRouter() {
     });
     return router;
 }
-const agent_runtime_controls_router_2 = require("./agent-runtime-controls-router");
+const agent_runtime_controls_router_2 = require("../../agent-runtime/runtime/agent-runtime-controls-router");

package/server/dist/{review-packet.js → modules/delivery/runtime/review-packet.js}

@@ -35,12 +35,12 @@ exports.packetHasUnsourcedNumericClaim = packetHasUnsourcedNumericClaim;
  * FILES changed, which is all the diff can actually prove.
  */
 const pr_follow_up_1 = require("./pr-follow-up");
-const spec_addenda_core_1 = require("./spec-addenda-core");
+const spec_addenda_core_1 = require("../../specs/runtime/spec-addenda-core");
 const delivery_evidence_1 = require("./delivery-evidence");
 const rail_pr_store_1 = require("./rail-pr-store");
 const pr_body_1 = require("./pr-body");
-const ai_invocations_1 = require("./ai-invocations");
-const project_repository_provenance_1 = require("./project-repository-provenance");
+const ai_invocations_1 = require("../../accounting/runtime/ai-invocations");
+const project_repository_provenance_1 = require("../../../project-repository-provenance");
 const TEST_FILE_RE = /(\.test\.|\.spec\.|(^|\/)__tests__\/)/;
 function churnForRuns(db, runIds, repository) {
     const ids = [...new Set(runIds.filter((id) => typeof id === 'string' && id.length > 0))];

package/server/dist/modules/execution/adapters/budget-storage.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueueBudgetStorage = createQueueBudgetStorage;
+function createQueueBudgetStorage(db) {
+    return {
+        project(projectId, dayStart) {
+            const row = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.daily_budget_usd'`).get();
+            if (!row || !projectId)
+                return null;
+            const budget = parseFloat(row.value);
+            if (!(budget > 0))
+                return null;
+            const spend = db.prepare(`SELECT COALESCE(SUM(total_cost_usd), 0) as total FROM ai_invocations
+             WHERE project_id = ? AND total_cost_usd IS NOT NULL AND started_at >= ?`).get(projectId, dayStart());
+            return { budget, totalSpend: spend.total };
+        },
+        pause() {
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('paused', 'true')`).run();
+        },
+    };
+}

package/server/dist/modules/execution/adapters/usage-reader.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDurableUsageReader = createDurableUsageReader;
+const runtime_1 = require("../../../providers/runtime");
+const result_event_1 = require("../../accounting/runtime/result-event");
+/** Project-bound SQLite/provider adapter; never starts a transaction or buffers all events. */
+function createDurableUsageReader(db, jobId, adapter) {
+    return {
+        events(mode, afterSeq) {
+            if (mode === 'results')
+                return db.prepare(`
+        SELECT seq, event_type, payload FROM events
+         WHERE job_id = ? AND source = 'stdout' AND event_type = 'result'
+         ORDER BY seq, id
+      `).iterate(jobId);
+            if (mode === 'tail')
+                return db.prepare(`
+        SELECT seq, event_type, payload FROM events
+         WHERE job_id = ? AND source = 'stdout' AND event_type != 'log' AND seq > ?
+         ORDER BY seq, id
+      `).iterate(jobId, afterSeq);
+            return db.prepare(`
+        SELECT seq, event_type, payload FROM events
+         WHERE job_id = ? AND source = 'stdout' AND event_type != 'log'
+         ORDER BY seq, id
+      `).iterate(jobId);
+        },
+        parse: payload => (0, runtime_1.parseStreamEvents)(adapter, payload),
+        normalize: (event, fallbackModel) => (0, result_event_1.finaliseInvocationResult)(adapter, [event], { fallbackModel }),
+        messageId(event) {
+            const raw = event.kind === 'other' ? event.raw : null;
+            const message = raw && typeof raw.message === 'object' && raw.message
+                ? raw.message : null;
+            return event.messageId ?? (message && typeof message.id === 'string' ? message.id : undefined);
+        },
+        malformedEvent: error => console.warn(`[queue-manager] ignored malformed durable event for ${jobId}:`, error),
+    };
+}

package/server/dist/modules/execution/application/enforce-budget.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceDailyBudgets = enforceDailyBudgets;
+/** Project admission is evaluated first; storage failures abort later effects. */
+function enforceDailyBudgets(ports) {
+    const enforce = (scope, snapshot) => {
+        if (snapshot?.budget != null && snapshot.budget > 0 && snapshot.totalSpend >= snapshot.budget) {
+            ports.exceeded(scope, { ...snapshot, budget: snapshot.budget });
+        }
+    };
+    enforce('project', ports.project());
+    if (ports.desktop)
+        enforce('desktop', ports.desktop());
+}

package/server/dist/modules/execution/application/record-job-invocations.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordJobInvocations = recordJobInvocations;
+const distribute_int_1 = require("../../../util/distribute-int");
+/** Preserve total integer usage and stable replay references across ticket attribution. */
+function recordJobInvocations(projectId, params, ports) {
+    const { jobId, provider, status, startedAt, finishedAt, ticketIds, estimated, result } = params;
+    // Single-ticket / no-ticket: one row, plain jobId (byte-compatible).
+    if (ticketIds.length <= 1) {
+        ports.write({
+            id: ports.newId(),
+            project_id: projectId,
+            provider,
+            surface: 'job',
+            surface_ref_id: jobId,
+            ticket_id: ticketIds[0] ?? null,
+            conversation_id: params.conversationId ?? null,
+            status,
+            started_at: startedAt,
+            finished_at: finishedAt,
+            total_cost_usd_estimated: estimated,
+            ...result,
+        });
+        return [jobId];
+    }
+    // Multi-ticket: split across one row per ticket. Cost & duration split evenly
+    // as floats; token & turn totals via largest-remainder (sum exactly to total).
+    const n = ticketIds.length;
+    const evenSplit = (v) => v === undefined ? undefined : v / n;
+    const tokensIn = (0, distribute_int_1.distributeIntEvenly)(result.tokens_in, n);
+    const tokensOut = (0, distribute_int_1.distributeIntEvenly)(result.tokens_out, n);
+    const cacheRead = (0, distribute_int_1.distributeIntEvenly)(result.tokens_cache_read, n);
+    const cacheCreate = (0, distribute_int_1.distributeIntEvenly)(result.tokens_cache_create, n);
+    const numTurns = (0, distribute_int_1.distributeIntEvenly)(result.num_turns, n);
+    const refIds = [];
+    ticketIds.forEach((ticketId, i) => {
+        const refId = `${jobId}#t${ticketId}`;
+        refIds.push(refId);
+        ports.write({
+            id: ports.newId(),
+            project_id: projectId,
+            provider,
+            surface: 'job',
+            surface_ref_id: refId,
+            ticket_id: ticketId,
+            conversation_id: params.conversationId ?? null,
+            status,
+            started_at: startedAt,
+            finished_at: finishedAt,
+            total_cost_usd_estimated: estimated,
+            tokens_in: tokensIn[i],
+            tokens_out: tokensOut[i],
+            tokens_cache_read: cacheRead[i],
+            tokens_cache_create: cacheCreate[i],
+            total_cost_usd: evenSplit(result.total_cost_usd),
+            num_turns: numTurns[i],
+            model: result.model,
+            session_id: result.session_id,
+            duration_ms: evenSplit(result.duration_ms),
+            duration_api_ms: evenSplit(result.duration_api_ms),
+        });
+    });
+    return refIds;
+}

package/server/dist/modules/execution/application/recover-job-usage.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverJobUsage = recoverJobUsage;
+const usage_1 = require("../domain/usage");
+/** Rebuild usage from ordered durable evidence without loading a transcript into memory. */
+function recoverJobUsage(ports, fallbackModel, interactive) {
+    const parse = (row) => {
+        try {
+            return ports.parse(row.payload);
+        }
+        catch (error) {
+            ports.malformedEvent(error);
+            return [];
+        }
+    };
+    const makeUsageAccumulator = () => {
+        const totals = {
+            tokens_in: 0,
+            tokens_out: 0,
+            tokens_cache_read: 0,
+            tokens_cache_create: 0,
+            total_cost_usd: 0,
+            num_turns: 0,
+            duration_ms: 0,
+            duration_api_ms: 0,
+        };
+        let model = fallbackModel ?? undefined;
+        let sessionId;
+        let estimated = false;
+        const snapshots = new Map();
+        const MAX_SNAPSHOT_KEYS = 4_096;
+        const add = (event, seq) => {
+            const finalised = ports.normalize(event, model);
+            const result = (0, usage_1.sanitizeRecoveredResult)(finalised.result);
+            const messageId = ports.messageId(event);
+            const stableId = messageId ? `message:${messageId}` : `${event.kind}:${seq}`;
+            const previous = snapshots.get(stableId) ?? {};
+            const addDelta = (key) => {
+                const current = result[key];
+                if (typeof current !== 'number')
+                    return;
+                const prior = previous[key];
+                totals[key] += Math.max(0, current - (typeof prior === 'number' ? prior : 0));
+            };
+            addDelta('tokens_in');
+            addDelta('tokens_out');
+            addDelta('tokens_cache_read');
+            addDelta('tokens_cache_create');
+            addDelta('total_cost_usd');
+            addDelta('num_turns');
+            addDelta('duration_ms');
+            addDelta('duration_api_ms');
+            model = result.model ?? model;
+            sessionId = result.session_id ?? sessionId;
+            estimated = estimated || finalised.estimated;
+            if (!snapshots.has(stableId) && snapshots.size >= MAX_SNAPSHOT_KEYS) {
+                snapshots.delete(snapshots.keys().next().value);
+            }
+            // Frames for one provider message are contiguous; retain a bounded LRU
+            // of recent snapshots for retransmission/delta dedupe without letting a
+            // malicious transcript allocate one map entry per event forever.
+            snapshots.delete(stableId);
+            snapshots.set(stableId, { ...previous, ...result });
+        };
+        const result = () => {
+            const hasUsage = Object.values(totals).some((value) => value > 0);
+            return {
+                result: hasUsage ? { ...totals, model, session_id: sessionId } : {},
+                estimated,
+            };
+        };
+        return { add, result };
+    };
+    if (!interactive) {
+        const accumulator = makeUsageAccumulator();
+        let lastValidResult = null;
+        const events = ports.events('all');
+        for (const row of events) {
+            for (const event of parse(row)) {
+                if (event.kind === 'result') {
+                    const finalised = ports.normalize(event, fallbackModel ?? undefined);
+                    lastValidResult = {
+                        ...finalised,
+                        result: (0, usage_1.sanitizeRecoveredResult)(finalised.result),
+                    };
+                }
+                else {
+                    accumulator.add(event, row.seq);
+                }
+            }
+        }
+        const fallback = accumulator.result();
+        if (lastValidResult) {
+            const result = { ...fallback.result };
+            for (const [key, value] of Object.entries(lastValidResult.result)) {
+                // Provider normalisers intentionally retain optional keys with an
+                // undefined value. Only concrete terminal fields are authoritative;
+                // an omitted field must not erase recoverable assistant evidence.
+                if (value !== undefined) {
+                    result[key] = value;
+                }
+            }
+            return {
+                result,
+                // A native terminal cost is authoritative. When the terminal frame
+                // omits cost, preserve whether the assistant-frame backfill was an
+                // estimate instead of silently relabelling it as exact.
+                estimated: result.total_cost_usd === lastValidResult.result.total_cost_usd &&
+                    lastValidResult.result.total_cost_usd !== undefined
+                    ? lastValidResult.estimated
+                    : (lastValidResult.estimated || fallback.estimated),
+                authoritative: true,
+            };
+        }
+        return { ...fallback, authoritative: false };
+    }
+    const totals = {
+        tokens_in: 0,
+        tokens_out: 0,
+        tokens_cache_read: 0,
+        tokens_cache_create: 0,
+        total_cost_usd: 0,
+        num_turns: 0,
+        duration_ms: 0,
+        duration_api_ms: 0,
+    };
+    let model = fallbackModel ?? undefined;
+    let sessionId;
+    let baselineCost = 0;
+    let baselineTurns = 0;
+    let estimated = false;
+    let lastResultSeq = -1;
+    const resultRows = ports.events('results');
+    for (const row of resultRows) {
+        for (const event of parse(row)) {
+            if (event.kind !== 'result')
+                continue;
+            const finalised = ports.normalize(event, model);
+            const result = (0, usage_1.sanitizeRecoveredResult)(finalised.result);
+            totals.tokens_in += result.tokens_in ?? 0;
+            totals.tokens_out += result.tokens_out ?? 0;
+            totals.tokens_cache_read += result.tokens_cache_read ?? 0;
+            totals.tokens_cache_create += result.tokens_cache_create ?? 0;
+            const cumulativeCost = result.total_cost_usd ?? baselineCost;
+            totals.total_cost_usd += Math.max(0, cumulativeCost - baselineCost);
+            baselineCost = cumulativeCost;
+            const cumulativeTurns = result.num_turns ?? (baselineTurns + 1);
+            totals.num_turns += Math.max(0, cumulativeTurns - baselineTurns);
+            baselineTurns = cumulativeTurns;
+            totals.duration_ms += result.duration_ms ?? 0;
+            totals.duration_api_ms += result.duration_api_ms ?? 0;
+            model = result.model ?? model;
+            sessionId = result.session_id ?? sessionId;
+            estimated = estimated || finalised.estimated;
+            lastResultSeq = row.seq;
+        }
+    }
+    const tail = makeUsageAccumulator();
+    const tailRows = ports.events('tail', lastResultSeq);
+    for (const row of tailRows) {
+        for (const event of parse(row)) {
+            if (event.kind !== 'result')
+                tail.add(event, row.seq);
+        }
+    }
+    const tailUsage = tail.result();
+    const tailResult = tailUsage.result;
+    const hasTailUsage = [
+        tailResult.tokens_in,
+        tailResult.tokens_out,
+        tailResult.tokens_cache_read,
+        tailResult.tokens_cache_create,
+        tailResult.total_cost_usd,
+    ].some((value) => typeof value === 'number' && value > 0);
+    if (hasTailUsage) {
+        totals.tokens_in += tailResult.tokens_in ?? 0;
+        totals.tokens_out += tailResult.tokens_out ?? 0;
+        totals.tokens_cache_read += tailResult.tokens_cache_read ?? 0;
+        totals.tokens_cache_create += tailResult.tokens_cache_create ?? 0;
+        totals.total_cost_usd += tailResult.total_cost_usd ?? 0;
+        totals.num_turns += tailResult.num_turns ?? 1;
+        totals.duration_ms += tailResult.duration_ms ?? 0;
+        totals.duration_api_ms += tailResult.duration_api_ms ?? 0;
+        model = tailResult.model ?? model;
+        sessionId = tailResult.session_id ?? sessionId;
+        estimated = estimated || tailUsage.estimated;
+    }
+    const hasRecoveredUsage = Object.values(totals).some((value) => value > 0);
+    return {
+        result: hasRecoveredUsage
+            ? {
+                ...totals,
+                model,
+                session_id: sessionId,
+            }
+            : {},
+        estimated,
+        authoritative: false,
+    };
+}

package/server/dist/modules/execution/domain/job-accounting.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/modules/execution/domain/scheduling.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePendingQueue = normalizePendingQueue;
+exports.isDependencySatisfied = isDependencySatisfied;
+/** Preserve the first occurrence; remove stale IDs without relaunching terminal jobs. */
+function normalizePendingQueue(queue, jobs) {
+    const seen = new Set();
+    const normalizedQueue = [];
+    const removedJobIds = [];
+    for (const id of queue) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        if (jobs.get(id)?.status === 'queued')
+            normalizedQueue.push(id);
+        else
+            removedJobIds.push(id);
+    }
+    return { normalizedQueue, removedJobIds };
+}
+/** Historical/external missing dependencies are satisfied by the established contract. */
+function isDependencySatisfied(parentStatus) {
+    return parentStatus === null || parentStatus === 'completed';
+}

package/server/dist/modules/execution/domain/usage.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeRecoveredResult = sanitizeRecoveredResult;
+function sanitizeRecoveredResult(result) {
+    const safe = { ...result };
+    const numeric = [
+        'tokens_in', 'tokens_out', 'tokens_cache_read', 'tokens_cache_create',
+        'total_cost_usd', 'num_turns', 'duration_ms', 'duration_api_ms',
+    ];
+    for (const key of numeric) {
+        const value = safe[key];
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value) || value < 0)) {
+            delete safe[key];
+        }
+    }
+    if (safe.model !== undefined && typeof safe.model !== 'string')
+        delete safe.model;
+    if (safe.session_id !== undefined && typeof safe.session_id !== 'string')
+        delete safe.session_id;
+    return safe;
+}

package/server/dist/modules/execution/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceDailyBudgets = exports.sanitizeRecoveredResult = exports.recoverJobUsage = exports.recordJobInvocations = exports.isDependencySatisfied = exports.normalizePendingQueue = void 0;
+var scheduling_1 = require("./domain/scheduling");
+Object.defineProperty(exports, "normalizePendingQueue", { enumerable: true, get: function () { return scheduling_1.normalizePendingQueue; } });
+Object.defineProperty(exports, "isDependencySatisfied", { enumerable: true, get: function () { return scheduling_1.isDependencySatisfied; } });
+var record_job_invocations_1 = require("./application/record-job-invocations");
+Object.defineProperty(exports, "recordJobInvocations", { enumerable: true, get: function () { return record_job_invocations_1.recordJobInvocations; } });
+var recover_job_usage_1 = require("./application/recover-job-usage");
+Object.defineProperty(exports, "recoverJobUsage", { enumerable: true, get: function () { return recover_job_usage_1.recoverJobUsage; } });
+var usage_1 = require("./domain/usage");
+Object.defineProperty(exports, "sanitizeRecoveredResult", { enumerable: true, get: function () { return usage_1.sanitizeRecoveredResult; } });
+var enforce_budget_1 = require("./application/enforce-budget");
+Object.defineProperty(exports, "enforceDailyBudgets", { enumerable: true, get: function () { return enforce_budget_1.enforceDailyBudgets; } });

package/server/dist/modules/execution/ports.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });