@aetheros/kernel-runtime 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aetheros/kernel-runtime",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,10 +23,17 @@
     "./guarded-restore": "./src/guarded-restore.js",
     "./envelope-migrations": "./src/envelope-migrations.js",
     "./agent-memory": "./src/agent-memory.js",
-    "./effect-journal": "./src/effect-journal.js"
+    "./effect-journal": "./src/effect-journal.js",
+    "./budgets": "./src/budgets.js",
+    "./lock-inspection": "./src/lock-inspection.js",
+    "./process-identity": "./src/process-identity.js",
+    "./claims": "./src/claims.js",
+    "./claims-conformance": "./src/claims-conformance.js",
+    "./storage": "./src/storage.js",
+    "./storage-conformance": "./src/storage-conformance.js"
   },
   "scripts": {
-    "check": "node --check src/index.js && node --check src/transactions.js && node --check src/migrations.js && node --check src/audit.js && node --check src/connectors.js && node --check src/backups.js && node --check src/encrypted-backups.js && node --check src/authenticated-connectors.js && node --check src/authenticated-audit.js && node --check src/release-signatures.js && node --check src/encrypted-state.js && node --check src/canonical-json.js && node --check src/guarded-restore.js && node --check src/envelope-migrations.js && node --check src/agent-memory.js && node --check src/effect-journal.js",
+    "check": "node --check src/index.js && node --check src/transactions.js && node --check src/migrations.js && node --check src/audit.js && node --check src/connectors.js && node --check src/backups.js && node --check src/encrypted-backups.js && node --check src/authenticated-connectors.js && node --check src/authenticated-audit.js && node --check src/release-signatures.js && node --check src/encrypted-state.js && node --check src/canonical-json.js && node --check src/guarded-restore.js && node --check src/envelope-migrations.js && node --check src/agent-memory.js && node --check src/effect-journal.js && node --check src/budgets.js && node --check src/lock-inspection.js && node --check src/process-identity.js && node --check src/claims.js && node --check src/claims-conformance.js && node --check src/storage.js && node --check src/storage-conformance.js",
     "test": "node --test test/*.test.mjs"
   },
   "files": [

package/src/agent-memory.js

@@ -26,9 +26,11 @@ function checkedMemory(value) {
 }
 
 /** Dedicated encrypted tenant memory. Hosts explicitly authorize every agent/shared scope. */
-export function createEncryptedAgentMemory(path, authority, {tenantId, key, keyId, readKeys, authorize} = {}) {
+export function createEncryptedAgentMemory(path, authority, {tenantId, key, keyId, readKeys, keyProvider, authorize} = {}) {
   if (!(authority instanceof TokenAuthority) || typeof tenantId !== 'string' || !tenantId.trim() || typeof authorize !== 'function') throw new TypeError('Tenant authority and explicit memory authorization policy required');
-  const store = createEncryptedStateStore(path, {tenantId, key, keyId, readKeys});
+  if (keyProvider !== undefined && [key, keyId, readKeys].some(value => value !== undefined)) throw new TypeError('Select static keys or a host key provider');
+  const store = createEncryptedStateStore(path, keyProvider === undefined
+    ? {tenantId, key, keyId, readKeys} : {tenantId, keyProvider});
   async function allow(token, operation, agentId) {
     const authenticate = () => authority.authenticate(token, {tenantId, permission: operation === 'get' || operation === 'list' ? 'read' : 'write'});
     const identity = authenticate();

package/src/audit-anchors.js

@@ -0,0 +1,124 @@
+import {createHash} from 'node:crypto';
+import {FileAuditLog} from './audit.js';
+import {TransactionalStateStore} from './transactions.js';
+import {canonicalJson} from './canonical-json.js';
+
+const DOMAIN='aetheros.audit-anchor.v1';
+const GENESIS='GENESIS';
+const copy=value=>structuredClone(value);
+const hash=value=>createHash('sha256').update(value).digest('hex');
+const text=value=>typeof value==='string'&&value.length>0&&value.length<=256&&/^[A-Za-z0-9_.:-]+$/.test(value);
+const digest=value=>value===GENESIS||typeof value==='string'&&/^[a-f0-9]{64}$/.test(value);
+const exact=(value,keys)=>value&&Object.getPrototypeOf(value)===Object.prototype&&Object.keys(value).sort().join(',')===[...keys].sort().join(',');
+const fail=()=>{throw new Error('Audit anchor operation blocked');};
+const statementKeys=['domain','streamId','sinkId','keyId','sequence','previousAnchor','startHash','tailHash','count'];
+const bytes=statement=>Buffer.from(canonicalJson(statement),'utf8');
+const anchorDigest=envelope=>hash(canonicalJson(envelope));
+function validate(envelope,{streamId,sinkId}) {
+ if(!exact(envelope,['statement','signature'])||typeof envelope.signature!=='string'||!envelope.signature.length||envelope.signature.length>16384)fail();
+ const s=envelope.statement;
+ if(!exact(s,statementKeys)||s.domain!==DOMAIN||s.streamId!==streamId||s.sinkId!==sinkId||!text(s.keyId)||!Number.isSafeInteger(s.sequence)||s.sequence<1||!digest(s.previousAnchor)||!digest(s.startHash)||!digest(s.tailHash)||s.tailHash===GENESIS||!Number.isSafeInteger(s.count)||s.count<1||s.count>100000)fail();
+ if(s.sequence===1&&(s.previousAnchor!==GENESIS||s.startHash!==GENESIS))fail();
+ if(s.sequence>1&&(s.previousAnchor===GENESIS||s.startHash===GENESIS))fail();
+ return s;
+}
+/** Authenticate a detached anchor using explicit host trust; no downloaded key is trusted. */
+export async function verifyAuditAnchor(envelope,{streamId,sinkId,verify}={}) {
+ try {
+  if(!text(streamId)||!text(sinkId)||typeof verify!=='function')fail();
+  const snapshot=copy(envelope),s=validate(snapshot,{streamId,sinkId});
+  if(await verify({payload:bytes(s),keyId:s.keyId,signature:snapshot.signature})!==true)fail();
+  return {anchorDigest:anchorDigest(snapshot),statement:copy(s)};
+ }catch{fail();}
+}
+
+/** Privileged local-host delivery primitive. Hosts authenticate/authorize all callers. */
+export class FileAuditAnchorDelivery {
+ constructor(path,{audit,tenantId,streamId,sinkId,keyId,sign,verify,readCheckpoint,deliver,verifyReceipt,stateStore}={}) {
+  if(!(audit instanceof FileAuditLog)||typeof tenantId!=='string'||!tenantId.trim()||![streamId,sinkId,keyId].every(text)||![sign,verify,readCheckpoint,deliver,verifyReceipt].every(x=>typeof x==='function'))throw new TypeError('Explicit audit anchor host configuration required');
+  const base=new TransactionalStateStore(path);
+  if(base.path===audit.state.path||stateStore!==undefined&&(!(stateStore instanceof TransactionalStateStore)||stateStore.path!==base.path))throw new TypeError('Separate matching anchor state required');
+  this.state=stateStore??base;
+  this.config=Object.freeze({audit,tenantId,streamId,sinkId,keyId,sign,verify,readCheckpoint,deliver,verifyReceipt});
+ }
+ stateKey(){return 'security.audit-anchor/'+this.config.streamId;}
+ async #checked(current) {
+  const c=this.config;
+  if(current===null)return {version:1,tenantId:c.tenantId,streamId:c.streamId,sinkId:c.sinkId,committed:null,pending:null};
+  if(!exact(current,['version','tenantId','streamId','sinkId','committed','pending'])||current.version!==1||current.tenantId!==c.tenantId||current.streamId!==c.streamId||current.sinkId!==c.sinkId)fail();
+  for(const e of [current.committed,current.pending])if(e!==null)await verifyAuditAnchor(e,c);
+  if(current.pending!==null){
+   const s=current.pending.statement,previous=current.committed;
+   if(s.sequence!==(previous?.statement.sequence??0)+1||s.previousAnchor!==(previous?anchorDigest(previous):GENESIS)||s.startHash!==(previous?.statement.tailHash??GENESIS))fail();
+  }
+  return current;
+ }
+ async #receipt(receipt,envelope) {
+  const c=this.config,r=copy(receipt),s=envelope.statement;
+  if(!exact(r,['streamId','sinkId','sequence','anchorDigest','proof'])||r.streamId!==c.streamId||r.sinkId!==c.sinkId||r.sequence!==s.sequence||r.anchorDigest!==anchorDigest(envelope)||typeof r.proof!=='string'||!r.proof.length||r.proof.length>16384)fail();
+  if(await c.verifyReceipt(copy(r))!==true)fail();
+ }
+ async #remote(current) {
+  const receipt=await this.config.readCheckpoint();
+  if(receipt===null){if(current.committed!==null)fail();return false;}
+  if(current.pending!==null){
+   try{await this.#receipt(receipt,current.pending);return true;}catch{/* May instead be the last committed checkpoint. */}
+  }
+  if(current.committed===null)fail();
+  await this.#receipt(receipt,current.committed);
+  return false;
+ }
+ async #prepare() {
+  const c=this.config;
+  return this.state.updateTenant(this.stateKey(),async raw=>{
+   const current=await this.#checked(raw);
+   // Read authoritative external position before any new signing. Unknown/rollback/fork blocks.
+   await this.#remote(current);
+   if(current.pending!==null)return current;
+   const log=await c.audit.state.getTenant(c.audit.key(c.tenantId));
+   const startHash=current.committed?.statement.tailHash??GENESIS;
+   if(log===null){if(startHash!==GENESIS)fail();return current;}
+   if(!exact(log,['schemaVersion','maxEntries','anchorHash','entries'])||log.schemaVersion!==1||log.maxEntries!==c.audit.maxEntries||!digest(log.anchorHash)||!Array.isArray(log.entries)||log.entries.length>c.audit.maxEntries)fail();
+   let previous=log.anchorHash;
+   for(const entry of log.entries){
+    if(!entry||entry.tenantId!==c.tenantId||entry.previousHash!==previous||(entry.hashVersion!==undefined&&entry.hashVersion!==2))fail();
+    const {hash:entryHash,...payload}=entry;
+    if(entryHash!==hash(entry.hashVersion===2?canonicalJson(payload):JSON.stringify(payload)))fail();
+    previous=entryHash;
+   }
+   const position=startHash===log.anchorHash?-1:log.entries.findIndex(e=>e.hash===startHash);
+   if(startHash!==log.anchorHash&&position<0)fail(); // Retention removed required continuity.
+   const entries=log.entries.slice(position+1);
+   if(entries.length===0)return current;
+   const sequence=(current.committed?.statement.sequence??0)+1;
+   if(!Number.isSafeInteger(sequence))fail();
+   const statement={domain:DOMAIN,streamId:c.streamId,sinkId:c.sinkId,keyId:c.keyId,sequence,previousAnchor:current.committed?anchorDigest(current.committed):GENESIS,startHash,tailHash:entries.at(-1).hash,count:entries.length};
+   const signature=await c.sign({payload:bytes(statement),keyId:c.keyId});
+   const pending={statement,signature};
+   await verifyAuditAnchor(pending,c);
+   current.pending=pending;
+   return current;
+  });
+ }
+ /** Explicit one-anchor flush; never a scheduler or audit/connector effect dispatcher. */
+ async flush() {
+  try {
+   const current=await this.#prepare(),pending=current.pending;
+   if(pending===null)return {status:'idle',sequence:current.committed?.statement.sequence??0};
+   if(!await this.#remote(current)){
+    const receipt=await this.config.deliver(copy(pending));
+    await this.#receipt(receipt,pending);
+   }
+   // A receipt asserts durable acceptance; checkpoint lookup must independently agree.
+   const remote=await this.config.readCheckpoint();
+   await this.#receipt(remote,pending);
+   const result=await this.state.updateTenant(this.stateKey(),async raw=>{
+    const latest=await this.#checked(raw);
+    if(latest.pending===null&&latest.committed!==null&&anchorDigest(latest.committed)===anchorDigest(pending))return latest;
+    if(latest.pending===null||anchorDigest(latest.pending)!==anchorDigest(pending))fail();
+    latest.committed=latest.pending;latest.pending=null;return latest;
+   });
+   return {status:'delivered',sequence:result.committed.statement.sequence,anchorDigest:anchorDigest(result.committed)};
+  }catch{fail();}
+ }
+}

package/src/audit.js

@@ -86,3 +86,5 @@ export class FileAuditLog {
     }catch{return {valid:false,count:Array.isArray(log?.entries)?log.entries.length:0};}
   }
 }
+
+export {FileAuditAnchorDelivery,verifyAuditAnchor} from './audit-anchors.js';

package/src/authenticated-connectors.js

@@ -5,6 +5,7 @@ import {ConnectorRegistry} from './connectors.js';
 import {FileEffectJournal} from './effect-journal.js';
 import {snapshotEffectBinding} from './effect-binding.js';
 import {canonicalJson} from './canonical-json.js';
+import {snapshotRetryCapability, assertRetryCapabilityTime} from './retry-capability.js';
 
 export class ConnectorInvocationError extends Error {
   constructor(code, effectMayHaveOccurred) {
@@ -19,20 +20,24 @@ export class ConnectorInvocationError extends Error {
  * Optional effectJournal enables durable write recovery; without it the legacy
  * invocation contract is unchanged. Journal lock contention fails closed. Hosts
  * keep result receipts free of secrets and enforce Review in authorize.
- * All ambiguous writes stay blocked, including remotely idempotent operations.
+ * Ordinary invoke blocks ambiguous writes. Explicit retries require verified host contracts.
  */
 export class AuthenticatedConnectorRegistry {
   #definitions = new Map();
   #catalog = new ConnectorRegistry();
   #authority; #audit; #tenantId; #authorize; #effectJournal; #requireEffectBinding;
+  #getRetryCapability; #verifyRetryCapability; #authorizeRetry; #executeRetry; #authorizeRetryRecovery;
   #authorizeClaimRecovery; #authorizeReconciliation; #verifyReconciliation; #authorizeReceiptLookup; #lookupRemoteReceipt;
-  constructor(authority, audit, {tenantId, authorize, effectJournal, requireEffectBinding = false, authorizeReconciliation, verifyReconciliation, authorizeReceiptLookup, lookupRemoteReceipt, authorizeClaimRecovery} = {}) {
+  constructor(authority, audit, {tenantId, authorize, effectJournal, requireEffectBinding = false, authorizeReconciliation, verifyReconciliation, authorizeReceiptLookup, lookupRemoteReceipt, authorizeClaimRecovery, getRetryCapability, verifyRetryCapability, authorizeRetry, executeRetry, authorizeRetryRecovery} = {}) {
     if (!(authority instanceof TokenAuthority) || !(audit instanceof FileAuditLog)) throw new TypeError('Token authority and file audit log required');
     if (typeof tenantId !== 'string' || !tenantId.trim()) throw new TypeError('Connector tenant required');
     if (authorize !== undefined && typeof authorize !== 'function') throw new TypeError('Invalid connector policy');
     if (effectJournal !== undefined && !(effectJournal instanceof FileEffectJournal)) throw new TypeError('File effect journal required');
     if (typeof requireEffectBinding !== 'boolean' || (requireEffectBinding && !effectJournal)) throw new TypeError('Effect binding requires a journal');
-    for (const policy of [authorizeReconciliation, verifyReconciliation, authorizeReceiptLookup, lookupRemoteReceipt, authorizeClaimRecovery]) if (policy !== undefined && typeof policy !== 'function') throw new TypeError('Invalid reconciliation policy');
+    for (const policy of [authorizeReconciliation, verifyReconciliation, authorizeReceiptLookup, lookupRemoteReceipt, authorizeClaimRecovery, getRetryCapability, verifyRetryCapability, authorizeRetry, executeRetry, authorizeRetryRecovery]) if (policy !== undefined && typeof policy !== 'function') throw new TypeError('Invalid reconciliation policy');
+    this.#authorizeRetryRecovery = authorizeRetryRecovery;
+    this.#authorizeRetry = authorizeRetry; this.#executeRetry = executeRetry;
+    this.#getRetryCapability = getRetryCapability; this.#verifyRetryCapability = verifyRetryCapability;
     this.#authorizeClaimRecovery = authorizeClaimRecovery;
     this.#authorizeReceiptLookup = authorizeReceiptLookup; this.#lookupRemoteReceipt = lookupRemoteReceipt;
     this.#authorizeReconciliation = authorizeReconciliation; this.#verifyReconciliation = verifyReconciliation;
@@ -46,6 +51,231 @@ export class AuthenticatedConnectorRegistry {
     return this;
   }
   list() { return this.#catalog.list(); }
+  /** Inspect a host-declared guarantee. Never authorizes, reserves, dispatches or enables retries. */
+  async inspectRetryCapability({token, expectedEntry, input, signal} = {}) {
+    const authenticate = () => this.#authority.authenticate(token, {tenantId:this.#tenantId, permission:'admin'});
+    const identity = authenticate(), requestId = randomUUID();
+    const record = (outcome, phase) => this.#audit.state.exclusive(() => this.#audit.append({
+      tenantId:identity.tenantId, actor:identity.subject, action:'connector.retry-capability', outcome,
+      metadata:{requestId, phase},
+    }));
+    try {
+      signal?.throwIfAborted();
+      if (!this.#effectJournal || !this.#getRetryCapability || !this.#verifyRetryCapability) throw new Error('Retry capability inspection not configured');
+      const snapshot = JSON.parse(canonicalJson({expectedEntry, input})), entry = snapshot.expectedEntry;
+      if (!entry || entry.tenantId !== identity.tenantId || entry.kind !== 'idempotent-write' ||
+          !['dispatched', 'reconciliation_required'].includes(entry.status) || !snapshotEffectBinding(entry.binding) ||
+          this.#definitions.get(entry.connectorId)?.find(value => value.id === entry.operationId)?.effect !== 'write') throw new Error('Bound uncertain idempotent effect required');
+      const request = {...snapshot, identity:structuredClone(identity)};
+      const check = async () => {
+        authenticate(); signal?.throwIfAborted();
+        const current = await this.#effectJournal.get({tenantId:entry.tenantId, effectKey:entry.effectKey});
+        if (canonicalJson(current) !== canonicalJson(entry)) throw new Error('Effect changed');
+        authenticate(); signal?.throwIfAborted();
+      };
+      const declaration = async () => {
+        await check();
+        const result = snapshotRetryCapability(await this.#getRetryCapability(structuredClone(request)), entry, snapshot.input);
+        await check(); assertRetryCapabilityTime(result);
+        return result;
+      };
+      const contract = await declaration();
+      const verify = async () => {
+        // A separate trusted host verifier pins endpoint/account/policy, original-dispatch
+        // coverage and remote guarantees. Neither caller nor remote tool can approve itself.
+        if (canonicalJson(await declaration()) !== canonicalJson(contract)) throw new Error('Retry capability changed');
+        if (await this.#verifyRetryCapability({...structuredClone(request), capability:structuredClone(contract)}) !== true) throw new Error('Remote guarantee unverified');
+        await check(); assertRetryCapabilityTime(contract);
+        if (canonicalJson(await declaration()) !== canonicalJson(contract)) throw new Error('Retry capability withdrawn');
+      };
+      await verify();
+      await record('success', 'verified-contract-only');
+      await verify();
+      return {capability:structuredClone(contract), retryAuthorized:false};
+    } catch {
+      try { await record('failed', 'inspection'); } catch { /* No inspection result grants dispatch. */ }
+      throw new ConnectorInvocationError('CONNECTOR_RECONCILIATION_REQUIRED', true);
+    }
+  }
+  /** Reserve one reviewed retry attempt only. No adapter execution or replay permission. */
+  async reserveRetry({token, expectedEntry, input, reviewId, decisionId, signal} = {}) {
+    const authenticate = () => this.#authority.authenticate(token, {tenantId:this.#tenantId, permission:'admin'});
+    const identity = authenticate(), requestId = randomUUID();
+    const record = (outcome, phase) => this.#audit.state.exclusive(() => this.#audit.append({
+      tenantId:identity.tenantId, actor:identity.subject, action:'connector.retry-reservation', outcome,
+      metadata:{requestId, phase},
+    }));
+    try {
+      signal?.throwIfAborted();
+      if (!this.#effectJournal || !this.#getRetryCapability || !this.#verifyRetryCapability || !this.#authorizeRetry) throw new Error('Retry reservation not configured');
+      const snapshot = JSON.parse(canonicalJson({expectedEntry, input, reviewId, decisionId})), entry = snapshot.expectedEntry;
+      if (!entry || entry.tenantId !== identity.tenantId || entry.kind !== 'idempotent-write' ||
+          !['dispatched', 'reconciliation_required'].includes(entry.status) || !snapshotEffectBinding(entry.binding) ||
+          Object.hasOwn(entry, 'retry') ||
+          this.#definitions.get(entry.connectorId)?.find(value => value.id === entry.operationId)?.effect !== 'write' ||
+          typeof snapshot.reviewId !== 'string' || !snapshot.reviewId.trim() || snapshot.reviewId === entry.binding.reviewId ||
+          typeof snapshot.decisionId !== 'string' || !snapshot.decisionId.trim() || snapshot.decisionId === entry.binding.decisionId) throw new Error('Fresh retry Review required');
+      const base = {identity:structuredClone(identity), expectedEntry:entry, input:snapshot.input};
+      const check = async () => {
+        authenticate(); signal?.throwIfAborted();
+        const current = await this.#effectJournal.get({tenantId:entry.tenantId, effectKey:entry.effectKey});
+        if (canonicalJson(current) !== canonicalJson(entry)) throw new Error('Effect changed');
+        authenticate(); signal?.throwIfAborted();
+      };
+      const declaration = async () => {
+        await check();
+        const value = snapshotRetryCapability(await this.#getRetryCapability(structuredClone(base)), entry, snapshot.input);
+        await check(); assertRetryCapabilityTime(value);
+        return value;
+      };
+      const capability = await declaration();
+      const attempt = {id:randomUUID(), number:1, status:'reserved'};
+      const request = {...base, action:'reserve-retry', capability, reviewId:snapshot.reviewId, decisionId:snapshot.decisionId, attempt};
+      const guard = async () => {
+        await check();
+        if (canonicalJson(await declaration()) !== canonicalJson(capability)) throw new Error('Retry capability changed');
+        // Independently establish original endpoint/key/request and retention provenance.
+        if (await this.#verifyRetryCapability({...structuredClone(base), capability:structuredClone(capability)}) !== true) throw new Error('Remote guarantee unverified');
+        await check(); assertRetryCapabilityTime(capability);
+        // Host verifies a fresh action/result-bound Review and current authoritative claim.
+        if (await this.#authorizeRetry(structuredClone(request)) !== true) throw new Error('Retry Review denied');
+        await check();
+        if (canonicalJson(await declaration()) !== canonicalJson(capability)) throw new Error('Retry capability withdrawn');
+        authenticate(); signal?.throwIfAborted(); assertRetryCapabilityTime(capability);
+        return true;
+      };
+      await guard();
+      await record('success', 'authorized');
+      const updated = await this.#effectJournal.reserveRetryAttempt({expectedEntry:entry, input:snapshot.input, capability,
+        reviewId:snapshot.reviewId, decisionId:snapshot.decisionId, subject:identity.subject, attemptId:attempt.id, beforeCommit:guard});
+      await record('success', 'reserved');
+      authenticate(); signal?.throwIfAborted();
+      return {entry:updated, retryAuthorized:false};
+    } catch {
+      try { await record('failed', 'reservation'); } catch { /* A reservation may be durable: inspect; never redispatch. */ }
+      throw new ConnectorInvocationError('CONNECTOR_RECONCILIATION_REQUIRED', true);
+    }
+  }
+  /** Consume one R2 reservation through a trusted host executor. Interrupted attempts never resume here. */
+  async executeRetry({token, expectedEntry, input, reviewId, decisionId, signal} = {}) {
+    const authenticate = () => this.#authority.authenticate(token, {tenantId:this.#tenantId, permission:'admin'});
+    const identity = authenticate(), requestId = randomUUID();
+    const record = (outcome, phase) => this.#audit.state.exclusive(() => this.#audit.append({
+      tenantId:identity.tenantId, actor:identity.subject, action:'connector.retry-execution', outcome,
+      metadata:{requestId, phase},
+    }));
+    let dispatchedEntry;
+    try {
+      signal?.throwIfAborted();
+      if (!this.#effectJournal || !this.#getRetryCapability || !this.#verifyRetryCapability || !this.#authorizeRetry || !this.#executeRetry) throw new Error('Retry execution not configured');
+      const snapshot = JSON.parse(canonicalJson({expectedEntry, input, reviewId, decisionId})), entry = snapshot.expectedEntry;
+      if (!entry || entry.tenantId !== identity.tenantId || entry.kind !== 'idempotent-write' ||
+          !['dispatched', 'reconciliation_required'].includes(entry.status) || !snapshotEffectBinding(entry.binding) ||
+          entry.retry?.version !== 1 || entry.retry.number !== 1 || entry.retry.status !== 'reserved' ||
+          this.#definitions.get(entry.connectorId)?.find(value => value.id === entry.operationId)?.effect !== 'write' ||
+          typeof snapshot.reviewId !== 'string' || !snapshot.reviewId.trim() ||
+          [entry.binding.reviewId, entry.retry.authorization.reviewId].includes(snapshot.reviewId) ||
+          typeof snapshot.decisionId !== 'string' || !snapshot.decisionId.trim() ||
+          [entry.binding.decisionId, entry.retry.authorization.decisionId].includes(snapshot.decisionId)) throw new Error('Fresh execution Review and reservation required');
+      const capability = snapshotRetryCapability(entry.retry.authorization.capability, entry, snapshot.input);
+      const base = {identity:structuredClone(identity), expectedEntry:entry, input:snapshot.input};
+      const request = {...base, action:'execute-retry', capability, reviewId:snapshot.reviewId, decisionId:snapshot.decisionId,
+        attempt:{id:entry.retry.id, number:1, status:'reserved'}};
+      const guard = async (expected = entry) => {
+        const check = async () => {
+          authenticate(); signal?.throwIfAborted();
+          if (canonicalJson(await this.#effectJournal.get(entry)) !== canonicalJson(expected)) throw new Error('Effect changed');
+          authenticate(); signal?.throwIfAborted();
+        };
+        const declaration = async () => {
+          const value = snapshotRetryCapability(await this.#getRetryCapability(structuredClone(base)), entry, snapshot.input);
+          if (canonicalJson(value) !== canonicalJson(capability)) throw new Error('Retry capability changed');
+          await check();
+        };
+        await check(); await declaration();
+        if (await this.#verifyRetryCapability({...structuredClone(base), capability:structuredClone(capability)}) !== true) throw new Error('Remote guarantee unverified');
+        await check(); assertRetryCapabilityTime(capability);
+        // Host verifies this execution action, exact reservation/result, current grants and claim generation.
+        if (await this.#authorizeRetry(structuredClone(request)) !== true) throw new Error('Retry execution denied');
+        await check(); await declaration();
+        authenticate(); signal?.throwIfAborted(); assertRetryCapabilityTime(capability);
+        return true;
+      };
+      await guard();
+      await record('success', 'authorized');
+      dispatchedEntry = await this.#effectJournal.transitionRetryAttempt({expectedEntry:entry, target:'dispatched', input:snapshot.input,
+        reviewId:snapshot.reviewId, decisionId:snapshot.decisionId, subject:identity.subject, beforeCommit:() => guard()});
+      await record('success', 'dispatch-intent');
+      await guard(dispatchedEntry);
+      // No await between the final synchronous checks and executor entry. Host must route
+      // using the pinned endpoint/account/key contract and enforce it at remote admission.
+      authenticate(); signal?.throwIfAborted(); assertRetryCapabilityTime(capability);
+      const pending = this.#executeRetry({...structuredClone(request), actor:entry.subject, tenantId:entry.tenantId,
+        connectorId:entry.connectorId, operationId:entry.operationId, idempotencyKey:entry.effectKey,
+        binding:structuredClone(entry.binding), ...(signal && {signal})});
+      const result = JSON.parse(canonicalJson(await pending));
+      authenticate(); signal?.throwIfAborted();
+      await this.#effectJournal.transitionRetryAttempt({expectedEntry:dispatchedEntry, target:'confirmed',
+        receipt:{source:'authenticated-connector-result-v1', result}, beforeCommit:async () => {
+          authenticate(); signal?.throwIfAborted(); return true;
+        }});
+      await record('success', 'confirmed');
+      authenticate(); signal?.throwIfAborted();
+      return structuredClone(result);
+    } catch {
+      if (dispatchedEntry) {
+        try { await this.#effectJournal.transitionRetryAttempt({expectedEntry:dispatchedEntry, target:'reconciliation_required', beforeCommit:async () => true}); }
+        catch { /* Preserve concurrent reconciliation, confirmed receipts and unavailable stores. */ }
+      }
+      try { await record('failed', 'execution'); } catch { /* Inspect journal; never infer that a failed response permits redispatch. */ }
+      throw new ConnectorInvocationError('CONNECTOR_RECONCILIATION_REQUIRED', true);
+    }
+  }
+  /** Retire an interrupted retry under fresh Review. No dispatch, lookup or confirmation. */
+  async recoverRetry({token, expectedEntry, reviewId, decisionId, signal} = {}) {
+    const authenticate = () => this.#authority.authenticate(token, {tenantId:this.#tenantId, permission:'admin'});
+    const identity = authenticate(), requestId = randomUUID();
+    const record = (outcome, phase) => this.#audit.state.exclusive(() => this.#audit.append({
+      tenantId:identity.tenantId, actor:identity.subject, action:'connector.retry-recovery', outcome,
+      metadata:{requestId, phase},
+    }));
+    try {
+      signal?.throwIfAborted();
+      if (!this.#effectJournal || !this.#authorizeRetryRecovery) throw new Error('Retry recovery not configured');
+      const snapshot = JSON.parse(canonicalJson({expectedEntry, reviewId, decisionId})), entry = snapshot.expectedEntry;
+      if (!entry || entry.tenantId !== identity.tenantId || entry.kind !== 'idempotent-write' ||
+          !['dispatched', 'reconciliation_required'].includes(entry.status) || !snapshotEffectBinding(entry.binding) ||
+          entry.retry?.version !== 1 || entry.retry.number !== 1 ||
+          !['reserved', 'dispatched', 'reconciliation_required'].includes(entry.retry.status) || Object.hasOwn(entry.retry, 'recovery') ||
+          this.#definitions.get(entry.connectorId)?.find(value => value.id === entry.operationId)?.effect !== 'write' ||
+          typeof snapshot.reviewId !== 'string' || !snapshot.reviewId.trim() ||
+          [entry.binding.reviewId, entry.retry.authorization?.reviewId, entry.retry.execution?.reviewId].includes(snapshot.reviewId) ||
+          typeof snapshot.decisionId !== 'string' || !snapshot.decisionId.trim() ||
+          [entry.binding.decisionId, entry.retry.authorization?.decisionId, entry.retry.execution?.decisionId].includes(snapshot.decisionId)) throw new Error('Fresh recovery Review required');
+      const request = {...snapshot, identity:structuredClone(identity), action:'recover-retry'};
+      const check = async () => {
+        authenticate(); signal?.throwIfAborted();
+        if (canonicalJson(await this.#effectJournal.get(entry)) !== canonicalJson(entry)) throw new Error('Effect changed');
+        authenticate(); signal?.throwIfAborted();
+      };
+      const guard = async () => {
+        await check();
+        // Host checks this exact action/attempt/snapshot, fresh Review, current grants
+        // and authoritative claim generation. Recovery grants no execution permission.
+        if (await this.#authorizeRetryRecovery(structuredClone(request)) !== true) throw new Error('Retry recovery denied');
+        await check(); return true;
+      };
+      await guard();
+      await record('success', 'authorized');
+      const updated = await this.#effectJournal.recoverRetryAttempt({...snapshot, subject:identity.subject, beforeCommit:guard});
+      await record('success', 'retired');
+      authenticate(); signal?.throwIfAborted();
+      return {entry:updated, retryAuthorized:false};
+    } catch {
+      try { await record('failed', 'recovery'); } catch { /* Retirement may be durable; inspect before another action. */ }
+      throw new ConnectorInvocationError('CONNECTOR_RECONCILIATION_REQUIRED', true);
+    }
+  }
   /** Review a prepared-only generation handoff. Never dispatches or recovers an uncertain write. */
   async recoverPreparedClaim({token, expectedEntry, nextGeneration, decisionId, signal} = {}) {
     const authenticate = () => this.#authority.authenticate(token, {tenantId:this.#tenantId, permission:'admin'});