hoi4-agent-tools 3.0.9 → 3.1.0

package/dist/hoi4_agent_tools/core/transactions.js

@@ -312,6 +312,7 @@ export class TransactionManager {
                 diagnostics,
                 validation: { passed, checks: validation.checks },
                 artifacts,
+                executionArtifacts: [],
                 appliedFiles: [],
                 rollbackStatus: 'available',
             };
@@ -398,11 +399,17 @@ export class TransactionManager {
                 }
                 if (manifest.diagnostics.length + result.diagnostics.length > TRANSACTION_MAX_DIAGNOSTICS ||
                     manifest.validation.checks.length + result.checks.length >
-                        TRANSACTION_MAX_VALIDATION_CHECKS) {
-                    throw new ServiceError('TRANSACTION_STRUCTURE_LIMIT', 'Post-write validation exceeds the supported transaction review structure limits');
+                        TRANSACTION_MAX_VALIDATION_CHECKS ||
+                    (manifest.executionArtifacts?.length ?? 0) + (result.artifacts?.length ?? 0) >
+                        TRANSACTION_MAX_ARTIFACTS) {
+                    throw new ServiceError('TRANSACTION_STRUCTURE_LIMIT', 'Post-write validation exceeds the supported transaction review or artifact limits');
                 }
                 manifest.diagnostics.push(...result.diagnostics);
                 manifest.validation.checks.push(...result.checks);
+                manifest.executionArtifacts ??= [];
+                for (const artifact of result.artifacts ?? [])
+                    if (!manifest.executionArtifacts.some(({ uri }) => uri === artifact.uri))
+                        manifest.executionArtifacts.push(artifact);
                 manifest.validation.passed =
                     manifest.validation.passed &&
                         result.checks.every(({ passed }) => passed) &&
@@ -513,6 +520,61 @@ export class TransactionManager {
             totalSize: cached.bytes.length,
         };
     }
+    /** Reconcile one interrupted job's journal without sweeping unrelated transactions. */
+    async recoverTransaction(workspaceId, transactionId, principal, signal) {
+        signal?.throwIfAborted();
+        const workspace = this.resolver.get(workspaceId, principal);
+        // Authenticate the selected journal and authorize its owner before changing protected state.
+        const initial = await this.load(workspace, transactionId, {
+            headMode: 'none',
+            ...(signal === undefined ? {} : { signal }),
+        });
+        this.assertRecoveryPrincipal(initial, principal);
+        return this.withWorkspaceLock(workspace, transactionId, async () => {
+            signal?.throwIfAborted();
+            // Never restore a pre-lock snapshot: a writer may have committed since the first read.
+            const current = await this.load(workspace, transactionId, {
+                headMode: 'none',
+                ...(signal === undefined ? {} : { signal }),
+            });
+            this.assertRecoveryPrincipal(current, principal);
+            const manifest = await this.load(workspace, transactionId, {
+                headMode: 'reconcile',
+                ...(signal === undefined ? {} : { signal }),
+            });
+            signal?.throwIfAborted();
+            if (manifest.state === 'applying' || manifest.state === 'rolling_back') {
+                await this.restoreInterruptedTransaction(workspace, manifest, principal);
+            }
+            return manifest;
+        });
+    }
+    assertRecoveryPrincipal(manifest, principal) {
+        if (principal !== undefined && (manifest.principal ?? null) !== principal) {
+            throw new ServiceError('TRANSACTION_PRINCIPAL_MISMATCH', 'Transaction recovery belongs to another principal');
+        }
+    }
+    async restoreInterruptedTransaction(workspace, manifest, principal) {
+        // Restoration and authenticated journal advancement are a non-cancellable critical phase.
+        try {
+            await this.restoreBeforeState(workspace, manifest, principal);
+            manifest.state = 'rolled_back';
+            manifest.failure = {
+                code: 'TRANSACTION_RECOVERED',
+                message: 'Incomplete transaction was rolled back during recovery',
+            };
+            await this.writeManifest(workspace, manifest);
+        }
+        catch (error) {
+            manifest.rollbackStatus = 'failed';
+            manifest.state = 'failed';
+            manifest.failure = this.safeFailure(error, 'TRANSACTION_RECOVERY_FAILED', 'Interrupted transaction could not be recovered safely');
+            await this.writeManifest(workspace, manifest);
+            if (error instanceof ServiceError)
+                throw error;
+            throw new ServiceError('TRANSACTION_RECOVERY_FAILED', 'Interrupted transaction could not be recovered safely');
+        }
+    }
     async recover(workspaceId, principal, signal) {
         signal?.throwIfAborted();
         const workspace = this.resolver.get(workspaceId, principal);
@@ -536,38 +598,29 @@ export class TransactionManager {
             if (!transactionIdPattern.test(entry.name))
                 continue;
             const manifest = await this.load(workspace, entry.name, {
-                headMode: 'reconcile',
+                headMode: 'none',
                 ...(signal === undefined ? {} : { signal }),
             });
-            if (principal !== undefined && (manifest.principal ?? null) !== principal) {
-                throw new ServiceError('TRANSACTION_PRINCIPAL_MISMATCH', 'Transaction recovery belongs to another principal');
-            }
-            if (manifest.state !== 'applying' && manifest.state !== 'rolling_back')
-                continue;
-            await this.withWorkspaceLock(workspace, manifest.transactionId, async () => {
-                signal?.throwIfAborted();
-                // Once source restoration starts, recovery and authenticated journal
-                // advancement form a non-cancellable critical phase.
+            this.assertRecoveryPrincipal(manifest, principal);
+            const interrupted = manifest.state === 'applying' || manifest.state === 'rolling_back';
+            if (!interrupted) {
                 try {
-                    await this.restoreBeforeState(workspace, manifest, principal);
-                    manifest.state = 'rolled_back';
-                    manifest.failure = {
-                        code: 'TRANSACTION_RECOVERED',
-                        message: 'Incomplete transaction was rolled back during recovery',
-                    };
-                    await this.writeManifest(workspace, manifest);
+                    // Ordinary startup must not contend with a live writer just to read terminal journals.
+                    await this.load(workspace, entry.name, {
+                        ...(signal === undefined ? {} : { signal }),
+                    });
+                    continue;
                 }
                 catch (error) {
-                    manifest.rollbackStatus = 'failed';
-                    manifest.state = 'failed';
-                    manifest.failure = this.safeFailure(error, 'TRANSACTION_RECOVERY_FAILED', 'Interrupted transaction could not be recovered safely');
-                    await this.writeManifest(workspace, manifest);
-                    if (error instanceof ServiceError)
+                    if (!(error instanceof ServiceError) ||
+                        error.code !== 'TRANSACTION_HEAD_RECONCILIATION_REQUIRED')
                         throw error;
-                    throw new ServiceError('TRANSACTION_RECOVERY_FAILED', 'Interrupted transaction could not be recovered safely');
                 }
-            });
-            recovered.push(manifest);
+            }
+            const reconciled = await this.recoverTransaction(workspaceId, entry.name, principal, signal);
+            if (interrupted) {
+                recovered.push(reconciled);
+            }
         }
         return recovered;
     }