specrails-desktop 2.57.0 → 2.58.0

package/server/dist/modules/delivery/runtime/isolated-settlement-reconstruction.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureIsolatedSettlementSnapshot = ensureIsolatedSettlementSnapshot;
+const node_path_1 = __importDefault(require("node:path"));
+const loop_runs_store_1 = require("../../loops/runtime/loop-runs-store");
+const isolated_settlement_store_1 = require("./isolated-settlement-store");
+const rail_pr_store_1 = require("./rail-pr-store");
+const rail_worktrees_store_1 = require("./rail-worktrees-store");
+const unavailable = (reason) => { throw new Error(`Original isolated settlement snapshot is unavailable: ${reason}`); };
+const list = (json) => {
+    const value = JSON.parse(json);
+    return Array.isArray(value) ? value : unavailable('invalid durable list');
+};
+const absolute = (value) => typeof value === 'string' && !value.includes('\0') && node_path_1.default.isAbsolute(value);
+const sha = (value) => typeof value === 'string' && /^[0-9a-f]{40,64}$/i.test(value);
+/** Explicit recovery only. Proof comes from original records, never live settings
+ * or checkout contents. All legs freeze together, without cleanup authority. */
+function ensureIsolatedSettlementSnapshot(db, projectId, runId) {
+    return db.transaction(() => {
+        const frozen = (0, loop_runs_store_1.readDefinitionRun)(db, runId);
+        // Standalone/older callers still let Loop Manager validate its own request.
+        if (!frozen)
+            return undefined;
+        if (frozen.row.project_id !== projectId)
+            return unavailable('run belongs to another project');
+        const existing = db.prepare('SELECT delivery_id FROM definition_delivery_settlements WHERE project_id=? AND run_id=? AND superseded_by IS NULL LIMIT 1')
+            .get(projectId, runId);
+        if (existing)
+            return existing;
+        if (!frozen.request.deferTerminalOutcome)
+            return undefined;
+        if ((0, loop_runs_store_1.readDefinitionSuccessor)(db, runId))
+            return unavailable('an adopted fork owns this allocation');
+        const manifest = frozen.request.executionManifest;
+        const context = frozen.metadata.context;
+        if (!manifest || manifest.version !== 1 || manifest.projectId !== projectId || !manifest.repositories.length ||
+            context?.runId !== runId || !Array.isArray(context.repositories))
+            return unavailable('original repository manifest/context is missing');
+        const candidates = db.prepare(`SELECT * FROM rail_pr_deliveries WHERE repository_id IS NOT NULL
+      AND EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(run_ids) THEN run_ids ELSE '[]' END) WHERE value=?)`)
+            .all(runId);
+        const snapshots = [];
+        const seen = new Set();
+        const runTickets = new Set(list(frozen.row.ticket_ids_json ?? unavailable('launch ticket set was not captured')));
+        for (const repository of manifest.repositories) {
+            if (seen.has(repository.repositoryId) || !manifest.selectedRepositoryIds.includes(repository.repositoryId))
+                return unavailable('ambiguous repository identity');
+            seen.add(repository.repositoryId);
+            if (![repository.sourcePath, repository.worktreePath, repository.gitCommonDir].every(absolute) || !sha(repository.baseSha))
+                return unavailable('repository paths or base identity were not captured');
+            if (!context.repositories.some(item => item.id === repository.repositoryId && item.path === repository.worktreePath))
+                return unavailable('repository is outside the frozen Core mount');
+            const matches = candidates.filter(row => row.repository_id === repository.repositoryId && list(row.worktree_ids).includes(repository.worktreeId));
+            if (matches.length !== 1)
+                return unavailable('repository delivery is missing or ambiguous');
+            const delivery = matches[0];
+            if (rail_pr_store_1.TERMINAL_PR_DECISIONS.has(delivery.decision) || delivery.operation_token || delivery.is_continuation ||
+                delivery.repository_path !== repository.sourcePath || delivery.parent_delivery_id !== manifest.groupId)
+                return unavailable('delivery ownership or continuation contract changed');
+            const parent = db.prepare('SELECT decision,operation_token FROM rail_pr_deliveries WHERE id=?').get(manifest.groupId);
+            if (!parent || rail_pr_store_1.TERMINAL_PR_DECISIONS.has(parent.decision) || parent.operation_token)
+                return unavailable('delivery group ownership changed');
+            const ledger = (0, rail_worktrees_store_1.getRailWorktree)(db, repository.worktreeId);
+            if (!ledger || ledger.run_id !== runId || ledger.repository_id !== repository.repositoryId || ledger.repository_path !== repository.sourcePath ||
+                ledger.branch !== repository.branch || ledger.worktree_path !== repository.worktreePath || !['building', 'built', 'needs-review'].includes(ledger.merge_state))
+                return unavailable('worktree ledger does not prove the original allocation');
+            const branches = list(delivery.branches).filter(branch => branch.runId === runId);
+            const branch = branches[0];
+            if (!branch || !sha(branch.initialSha) || !['created', 'preexisting'].includes(branch.branchOwnership ?? '') ||
+                branch.branch !== repository.branch || branch.worktreePath !== repository.worktreePath || !Array.isArray(branch.overlayExcludes) ||
+                branch.overlayExcludes.some(value => typeof value !== 'string' || !value || value.includes('\0') || node_path_1.default.isAbsolute(value) || value.split(/[\\/]/).includes('..')))
+                return unavailable('initial SHA, branch or never-commit exclusions were not captured');
+            if (branches.some(item => item.initialSha !== branch.initialSha || item.branchOwnership !== branch.branchOwnership || item.branch !== branch.branch ||
+                item.worktreePath !== branch.worktreePath || JSON.stringify(item.overlayExcludes) !== JSON.stringify(branch.overlayExcludes) ||
+                !Number.isSafeInteger(item.ticketId) || item.ticketId < 0 || item.ticketId !== 0 && !runTickets.has(item.ticketId)))
+                return unavailable('branch records disagree with the frozen run');
+            const ticketIds = [...new Set(branches.map(item => item.ticketId).filter(id => id > 0))].sort((a, b) => a - b);
+            if (ledger.ticket_id !== 0 && !ticketIds.includes(ledger.ticket_id))
+                return unavailable('worktree ticket ownership changed');
+            const message = `specrails: ticket-${ledger.ticket_id} recovered (run ${runId})`;
+            snapshots.push({ version: 1, projectId, deliveryId: delivery.id, reconstructedFrom: 'durable-branch-records',
+                baseRepo: repository.sourcePath, overlaySourceRoot: repository.sourcePath, overlayProviderDir: '', overlayInstructions: '',
+                commitMessage: message, partialCommitMessage: `specrails: ticket-${ledger.ticket_id} partial recovered (run ${runId})`,
+                run: { runId, ledgerId: ledger.id, ticketId: ledger.ticket_id, ticketIds,
+                    handle: { branch: repository.branch, worktreePath: repository.worktreePath },
+                    baseRef: repository.baseSha, initialSha: branch.initialSha, branchOwnership: branch.branchOwnership,
+                    worktreeOwnership: 'preexisting', automaticRelease: false, overlayExcludes: [...branch.overlayExcludes], overlayCleanupEvidence: [], warmLinkEvidence: [],
+                    settlementIgnoredPaths: null, provenanceSnapshot: null, continuationTarget: null } });
+        }
+        if (snapshots.length !== manifest.selectedRepositoryIds.length || candidates.length !== snapshots.length)
+            return unavailable('repository delivery set is incomplete or ambiguous');
+        for (const snapshot of snapshots)
+            (0, isolated_settlement_store_1.saveIsolatedSettlementSnapshot)(db, snapshot);
+        return { delivery_id: snapshots[0].deliveryId };
+    }).immediate();
+}

package/server/dist/modules/delivery/runtime/isolated-settlement-store.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveIsolatedSettlementSnapshot = saveIsolatedSettlementSnapshot;
+exports.readIsolatedSettlementRecords = readIsolatedSettlementRecords;
+exports.saveIsolatedSettlementResult = saveIsolatedSettlementResult;
+exports.recordIsolatedProvenanceOnce = recordIsolatedProvenanceOnce;
+/** Admission is immutable. Restart must not adopt today's settings or ownership. */
+function saveIsolatedSettlementSnapshot(db, snapshot) {
+    const json = JSON.stringify(snapshot);
+    db.transaction(() => {
+        const prior = db.prepare('SELECT snapshot_json FROM definition_delivery_settlements WHERE delivery_id=? AND run_id=?')
+            .get(snapshot.deliveryId, snapshot.run.runId);
+        if (prior) {
+            if (prior.snapshot_json !== json)
+                throw new Error('Frozen isolated settlement cannot change');
+            return;
+        }
+        db.prepare('INSERT INTO definition_delivery_settlements(delivery_id,run_id,project_id,snapshot_json) VALUES (?,?,?,?)')
+            .run(snapshot.deliveryId, snapshot.run.runId, snapshot.projectId, json);
+    })();
+}
+function readIsolatedSettlementRecords(db, projectId, deliveryId) {
+    const rows = db.prepare('SELECT run_id,snapshot_json,result_json FROM definition_delivery_settlements WHERE project_id=? AND delivery_id=? AND superseded_by IS NULL ORDER BY created_at,run_id')
+        .all(projectId, deliveryId);
+    return rows.map(row => {
+        const snapshot = JSON.parse(row.snapshot_json);
+        if (snapshot.version !== 1 || snapshot.projectId !== projectId || snapshot.deliveryId !== deliveryId || snapshot.run?.runId !== row.run_id)
+            throw new Error('Isolated settlement identity is inconsistent');
+        const result = row.result_json ? JSON.parse(row.result_json) : null;
+        if (result && result.run?.runId !== row.run_id)
+            throw new Error('Isolated settlement result belongs to another run');
+        return { snapshot, result };
+    });
+}
+function saveIsolatedSettlementResult(db, deliveryId, result) {
+    const update = db.prepare("UPDATE definition_delivery_settlements SET result_json=?,updated_at=datetime('now') WHERE delivery_id=? AND run_id=?")
+        .run(JSON.stringify(result), deliveryId, result.run.runId);
+    if (update.changes !== 1)
+        throw new Error('Frozen isolated settlement is missing');
+}
+/** The provenance row batch and receipt share the project transaction. */
+function recordIsolatedProvenanceOnce(db, deliveryId, runId, record) {
+    db.transaction(() => {
+        const row = db.prepare('SELECT provenance_recorded FROM definition_delivery_settlements WHERE delivery_id=? AND run_id=?')
+            .get(deliveryId, runId);
+        if (!row)
+            throw new Error('Frozen isolated settlement is missing');
+        if (row.provenance_recorded)
+            return;
+        record();
+        db.prepare('UPDATE definition_delivery_settlements SET provenance_recorded=1 WHERE delivery_id=? AND run_id=?').run(deliveryId, runId);
+    })();
+}

package/server/dist/modules/delivery/runtime/multi-repo-execution-store.js

@@ -41,7 +41,9 @@ function getRepositoryExecutionReferences(db, repositoryId) {
     WHERE repository_id = ? AND decision NOT IN ('completed','merged','discarded','superseded')`).all(repositoryId);
     const worktrees = db.prepare(`SELECT run_id FROM rail_worktrees WHERE repository_id = ?
     AND merge_state NOT IN ('merged','failed','released')`).all(repositoryId);
-    const runs = db.prepare("SELECT id, execution_manifest FROM loop_runs WHERE status <> 'completed' AND execution_manifest IS NOT NULL").all();
+    const runs = db.prepare(`SELECT id, execution_manifest FROM loop_runs WHERE status <> 'completed' AND execution_manifest IS NOT NULL
+    AND NOT EXISTS (SELECT 1 FROM definition_fork_operations AS fork WHERE fork.source_run_id = loop_runs.id AND fork.adopted = 1)`)
+        .all();
     const manifestRunIds = runs.filter((row) => readExecutionManifest(row.execution_manifest)?.selectedRepositoryIds.includes(repositoryId)).map((row) => row.id);
     return {
         runIds: [...new Set([...worktrees.flatMap((row) => row.run_id ? [row.run_id] : []), ...manifestRunIds])],