intentdna 1.9.0 → 1.9.3

package/dist/runtime/local-execution-reconciliation.d.ts

@@ -0,0 +1,20 @@
+import type { RunView } from "./canonical-run-service.js";
+import type { LocalAttemptExecutionAuthority, LocalExecutionAuthorityBinding, LocalPreparedExecutionHandle } from "./local-execution-authority.js";
+import type { CanonicalResultDigest } from "./run-contracts.js";
+export type LocalPreparationReconciliationResult = {
+    readonly kind: "bound";
+    readonly preparation: LocalPreparedExecutionHandle;
+    readonly binding: LocalExecutionAuthorityBinding;
+} | {
+    readonly kind: "retired_never_launched";
+    readonly preparation: LocalPreparedExecutionHandle;
+    readonly reason: "run_terminal" | "run_cancelling" | "attempt_terminal" | "attempt_replaced" | "higher_claim" | "different_executor";
+    readonly attestation_digest: CanonicalResultDigest;
+} | {
+    readonly kind: "retained";
+    readonly preparation: LocalPreparedExecutionHandle;
+    readonly reason: "current_unattached" | "missing_ledger_state" | "inconsistent_ledger_state";
+};
+export declare function reconcileLocalExecutionPreparations(authority: LocalAttemptExecutionAuthority, view: RunView, options?: {
+    readonly now?: () => Date;
+}): Promise<readonly LocalPreparationReconciliationResult[]>;

package/dist/runtime/local-execution-reconciliation.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { canonicalizeJson } from "./canonical-json.js";
+function reconciliationFailureDigest(preparation, reason) {
+    return `sha256:${createHash("sha256")
+        .update(canonicalizeJson({
+        schema_version: "intentdna.local_preparation_reconciliation.v1",
+        preparation_digest: preparation.preparation_digest,
+        reason,
+    }), "utf8")
+        .digest("hex")}`;
+}
+function preparationMatchesView(preparation, view) {
+    return preparation.run_id === view.run.run_id;
+}
+function classifyUncommitted(inspection, view) {
+    const preparation = inspection.handle;
+    const attempt = view.attempts.find((candidate) => candidate.attempt_id === preparation.attempt_id);
+    const activation = view.activations.find((candidate) => candidate.activation_id === preparation.activation_id);
+    const claims = view.claims.filter((candidate) => candidate.attempt_id === preparation.attempt_id);
+    if (attempt === undefined || activation === undefined)
+        return "missing_ledger_state";
+    if (attempt.run_id !== preparation.run_id
+        || attempt.step_id !== preparation.step_id
+        || attempt.activation_id !== preparation.activation_id
+        || activation.run_id !== preparation.run_id
+        || activation.step_id !== preparation.step_id) {
+        return "inconsistent_ledger_state";
+    }
+    if (view.run.terminal !== null)
+        return "run_terminal";
+    if (view.run.status === "cancelling")
+        return "run_cancelling";
+    if (attempt.executor !== null) {
+        if (attempt.executor.kind !== "worker"
+            || attempt.executor.worker_session_id !== preparation.worker_session_id) {
+            return "different_executor";
+        }
+        return "inconsistent_ledger_state";
+    }
+    if (attempt.phase === "terminal")
+        return "attempt_terminal";
+    if (activation.current_attempt_id !== preparation.attempt_id)
+        return "attempt_replaced";
+    if (claims.length === 0)
+        return "missing_ledger_state";
+    if (claims.some((claim) => claim.run_id !== preparation.run_id
+        || claim.step_id !== preparation.step_id
+        || claim.activation_id !== preparation.activation_id)) {
+        return "inconsistent_ledger_state";
+    }
+    const claim = claims.reduce((latest, candidate) => (candidate.claim_epoch > latest.claim_epoch ? candidate : latest));
+    if (claim.claim_epoch > preparation.execution_claim_epoch)
+        return "higher_claim";
+    if (claim.claim_epoch < preparation.execution_claim_epoch)
+        return "inconsistent_ledger_state";
+    return "current_unattached";
+}
+export async function reconcileLocalExecutionPreparations(authority, view, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const results = [];
+    for (const inspection of authority.listPreparedExecutions()) {
+        const preparation = inspection.handle;
+        if (!preparationMatchesView(preparation, view)) {
+            results.push({ kind: "retained", preparation, reason: "missing_ledger_state" });
+            continue;
+        }
+        const attempt = view.attempts.find((candidate) => candidate.attempt_id === preparation.attempt_id);
+        if (attempt?.run_id === preparation.run_id
+            && attempt.step_id === preparation.step_id
+            && attempt.activation_id === preparation.activation_id
+            && attempt.executor?.kind === "worker"
+            && attempt.executor.worker_session_id === preparation.worker_session_id
+            && attempt.started_at !== null) {
+            results.push({
+                kind: "bound",
+                preparation,
+                binding: authority.bindExecution(preparation, { started_at: attempt.started_at }),
+            });
+            continue;
+        }
+        const reason = classifyUncommitted(inspection, view);
+        if (reason === "current_unattached"
+            || reason === "missing_ledger_state"
+            || reason === "inconsistent_ledger_state") {
+            results.push({ kind: "retained", preparation, reason });
+            continue;
+        }
+        const attestation = await authority.attestNeverLaunched({
+            run_id: preparation.run_id,
+            step_id: preparation.step_id,
+            activation_id: preparation.activation_id,
+            attempt_id: preparation.attempt_id,
+            execution_claim_epoch: preparation.execution_claim_epoch,
+            executor: { kind: "worker", worker_session_id: preparation.worker_session_id },
+            started_at: inspection.created_at,
+            failure_idempotency_key: reconciliationFailureDigest(preparation, reason),
+            requested_at: now().toISOString(),
+        });
+        results.push({
+            kind: "retired_never_launched",
+            preparation,
+            reason,
+            attestation_digest: attestation.attestation_digest,
+        });
+    }
+    return results;
+}

package/dist/runtime/local-execution-supervisor-script.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Self-contained CommonJS supervisor written into the private authority root.
+ * Keeping the child runtime dependency-free lets source tests and compiled CLI
+ * builds use the exact same protocol.
+ */
+export declare const LOCAL_EXECUTION_SUPERVISOR_SOURCE: string;
+export declare const LOCAL_EXECUTION_SUPERVISOR_DIGEST: `sha256:${string}`;