@lazyingart/agintiflow 0.20.205 → 0.20.207

package/docs/supervision-campaign-ledger.md

@@ -38,11 +38,6 @@ Create, start, and finish a concrete run with `test`, `start`, `event`, and
 idempotent or append-only SQLite operation suitable for a persistent tmux
 campaign.
 
-Test registration validates that any named capability and scenario belong to
-the same campaign. Finishing a test updates the test, capability, and scenario
-status in one SQLite transaction, so a typo cannot silently leave the campaign
-matrix stale or split across contradictory states.
-
 Inspect current coverage:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.205",
+  "version": "0.20.207",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",
@@ -152,6 +152,7 @@
     "smoke:runtime-core": "node scripts/smoke-runtime-core.js",
     "smoke:localllm-auto-max": "node scripts/smoke-localllm-auto-max.js",
     "smoke:localllm-code-routing": "node scripts/smoke-localllm-code-routing.js",
+    "smoke:local-failure-recovery": "node scripts/smoke-local-failure-recovery.js",
     "smoke:local-resource-policy": "node scripts/smoke-local-resource-policy.js",
     "smoke:context-budget-recovery": "node scripts/smoke-context-budget-recovery.js",
     "smoke:localllm-model-tiers": "node scripts/smoke-localllm-model-tiers.js",
@@ -188,7 +189,7 @@
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/smoke-progressive-tool-selection.js

@@ -204,6 +204,136 @@ sameNames(
 assert(!names(artifactValidationTools).includes("search_files"), "artifact validation phase reopened broad search");
 assert(!names(artifactValidationTools).includes("open_url"), "artifact validation phase reopened browser discovery");
 
+const localFailureRecoveryTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm", localFailureRecoveryActive: true },
+  goal: "Recover from repeated failed edits without restarting the task.",
+  profile: "code",
+  messages: [
+    { role: "assistant", tool_calls: [{ id: "failed-edit", function: { name: "apply_patch", arguments: "{}" } }] },
+    { role: "tool", tool_call_id: "failed-edit", content: '{"ok":false}' },
+  ],
+});
+sameNames(
+  localFailureRecoveryTools,
+  ["read_file", "apply_patch", "write_file", "run_command", "search_files", "inspect_project", "finish"],
+  "local failure recovery did not restore the bounded repair surface"
+);
+
+const dataDiscoveryStarterTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm" },
+  goal: "Clean these experiment exports and leave a reproducible analysis.",
+  profile: "data",
+});
+sameNames(
+  dataDiscoveryStarterTools,
+  ["inspect_project", "finish"],
+  "local data task exposed mutation tools before project inspection"
+);
+
+const dataInspectionMessages = [
+  { role: "user", content: "Goal: Clean these experiment exports and leave a reproducible analysis." },
+  {
+    role: "assistant",
+    tool_calls: [{ id: "data-inspect", function: { name: "inspect_project", arguments: '{"path":"."}' } }],
+  },
+  {
+    role: "tool",
+    tool_call_id: "data-inspect",
+    content: JSON.stringify({
+      ok: true,
+      recommendedReads: ["README.md", "tests/test_analysis.py"],
+      manifestFiles: [{ path: "README.md" }],
+      testFiles: [{ path: "tests/test_analysis.py" }],
+      topLevel: [
+        { path: "analysis.py", type: "file" },
+        { path: "TASK.md", type: "file" },
+      ],
+    }),
+  },
+];
+const dataContextTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm" },
+  goal: "Clean these experiment exports and leave a reproducible analysis.",
+  profile: "data",
+  messages: dataInspectionMessages,
+});
+sameNames(
+  dataContextTools,
+  ["read_file", "finish"],
+  "local data task exposed mutation tools before reading project contracts"
+);
+assertStrict.deepEqual(
+  enumFor(dataContextTools, "read_file", "path"),
+  ["README.md"],
+  "local data instruction phase did not constrain read_file to discovered instruction paths"
+);
+
+const dataImplementationMessages = [
+  ...dataInspectionMessages,
+  {
+    role: "assistant",
+    tool_calls: [{ id: "data-readme", function: { name: "read_file", arguments: '{"path":"README.md"}' } }],
+  },
+  { role: "tool", tool_call_id: "data-readme", content: '{"ok":true,"path":"README.md"}' },
+];
+const dataImplementationTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm" },
+  goal: "Clean these experiment exports and leave a reproducible analysis.",
+  profile: "data",
+  messages: dataImplementationMessages,
+});
+sameNames(
+  dataImplementationTools,
+  ["read_file", "finish"],
+  "local data task exposed mutation tools before reading an analyzer/config/test surface"
+);
+assertStrict.deepEqual(
+  enumFor(dataImplementationTools, "read_file", "path"),
+  ["tests/test_analysis.py", "analysis.py"],
+  "local data context phase did not constrain read_file to discovered analysis paths"
+);
+
+const dataReadyMessages = [
+  ...dataImplementationMessages,
+  {
+    role: "assistant",
+    tool_calls: [
+      { id: "data-test", function: { name: "read_file", arguments: '{"path":"tests/test_analysis.py"}' } },
+    ],
+  },
+  { role: "tool", tool_call_id: "data-test", content: '{"ok":true,"path":"tests/test_analysis.py"}' },
+];
+const dataReadyTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm" },
+  goal: "Clean these experiment exports and leave a reproducible analysis.",
+  profile: "data",
+  messages: dataReadyMessages,
+});
+sameNames(dataReadyTools, LOCAL_COMPACT_CODE_TOOL_NAMES, "local data task did not unlock after bounded discovery");
+
+const dataRecoveryBeforeDiscoveryTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm", localFailureRecoveryActive: true },
+  goal: "Recover this data task after a failed mutation.",
+  profile: "data",
+});
+sameNames(
+  dataRecoveryBeforeDiscoveryTools,
+  ["inspect_project", "finish"],
+  "local recovery bypassed the incomplete data discovery gate"
+);
+
+const dataRecoveryAfterDiscoveryTools = selectProgressiveTools(allTools, {
+  config: { provider: "localllm", localFailureRecoveryActive: true },
+  goal: "Recover this data task after a failed mutation.",
+  profile: "data",
+  messages: dataReadyMessages,
+});
+sameNames(
+  dataRecoveryAfterDiscoveryTools,
+  ["read_file", "apply_patch", "write_file", "run_command", "search_files", "inspect_project", "finish"],
+  "local recovery remained trapped after data discovery completed"
+);
+
 const artifactRepairTools = selectProgressiveTools(allTools, {
   config: { provider: "localllm", artifactValidationPhase: true, artifactValidationNeedsRepair: true },
   goal: "Repair the exact report from deterministic preflight evidence.",

package/scripts/smoke-skills.js

@@ -90,6 +90,13 @@ assert(selectedIds("debug a C# dotnet web API").includes("dotnet-csharp"), ".NET
 assert(selectedIds("fix a PHP Laravel composer project").includes("php"), "PHP prompt did not select php");
 assert(selectedIds("repair a Ruby Rails app with RSpec").includes("ruby"), "Ruby prompt did not select ruby");
 assert(selectedIds("clean a CSV dataset and make plots").includes("data-analysis"), "data prompt did not select data-analysis");
+const focusedDataSkills = selectedIds(
+  "these experiment exports are a mess; clean them, make a useful plot and report",
+  "data"
+);
+assert(focusedDataSkills.includes("data-analysis"), "explicit data profile omitted its core analysis skill");
+assert(!focusedDataSkills.includes("novel-writing"), "explicit data profile selected unrelated novel guidance");
+assert(!focusedDataSkills.includes("media-transcription-report"), "explicit data profile selected unrelated media guidance");
 assert(selectedIds("convert scanned PDF EPUB and image sources to markdown with OCR").includes("source-ingestion"), "source ingestion prompt did not select source-ingestion");
 assert(selectedIds("use json schema to fetch valid structured json for each chunk in parallel").includes("structured-json"), "structured JSON prompt did not select structured-json");
 assert(selectedIds("write README API docs and a tutorial").includes("docs-knowledge"), "docs prompt did not select docs-knowledge");

package/scripts/smoke-supervision-ledger.js

@@ -19,17 +19,6 @@ function run(command, args = []) {
   }));
 }
 
-function runFails(command, args, expected) {
-  try {
-    run(command, args);
-  } catch (error) {
-    const output = `${error?.stdout || ""}\n${error?.stderr || ""}\n${error?.message || ""}`;
-    assert(expected.test(output), `unexpected ${command} failure: ${output}`);
-    return;
-  }
-  throw new Error(`${command} unexpectedly succeeded`);
-}
-
 function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
@@ -44,14 +33,6 @@ run("scenario", [
   "--prompt-quality", "normal", "--prompt", "Prepare the media chain without publishing.",
   "--expected-outputs", "[\"readiness.md\"]", "--validation", "Verify routine paths and no external write.",
 ]);
-runFails("test", [
-  "--id", "missing-capability", "--capability", "not-registered", "--scenario", "media-dry-run",
-  "--title", "Invalid capability reference", "--validation", "Must fail before insertion.",
-], /Unknown capability/);
-runFails("test", [
-  "--id", "missing-scenario", "--capability", "media-chain", "--scenario", "not-registered",
-  "--title", "Invalid scenario reference", "--validation", "Must fail before insertion.",
-], /Unknown scenario/);
 run("test", [
   "--id", "media-dry-run-001", "--capability", "media-chain", "--scenario", "media-dry-run",
   "--title", "Read-only established media routine probe", "--prompt-path", "TASK.md",
@@ -79,7 +60,7 @@ assert(status.ok, "ledger status did not succeed");
 assert(fs.statSync(db).size > 0, "ledger database is empty");
 assert(status.campaign?.id === "smoke", "campaign row was not preserved");
 assert(status.capability_counts.some((row) => row.status === "passed_after_fix" && row.count === 1), "capability status was not updated");
-assert(status.scenario_counts.some((row) => row.status === "passed_after_fix" && row.count === 1), "scenario result was not propagated");
+assert(status.scenario_counts.some((row) => row.status === "backlog" && row.count === 1), "scenario was not recorded");
 assert(status.test_counts.some((row) => row.status === "passed_after_fix" && row.count === 1), "test result was not recorded");
 assert(status.recent_tests[0]?.session_id === "session-smoke", "session evidence was not retained");
 

package/scripts/supervision-ledger.js

@@ -32,24 +32,6 @@ function jsonValue(value, fallback = []) {
   return JSON.stringify(JSON.parse(String(value)));
 }
 
-function assertCampaignReference(db, table, id, campaignId, label) {
-  if (!id) return;
-  const row = db.prepare(`SELECT id FROM ${table} WHERE id=? AND campaign_id=?`).get(id, campaignId);
-  if (!row) throw new Error(`Unknown ${label} for campaign ${campaignId}: ${id}`);
-}
-
-function runTransaction(db, operation) {
-  db.exec("BEGIN IMMEDIATE");
-  try {
-    const result = operation();
-    db.exec("COMMIT");
-    return result;
-  } catch (error) {
-    db.exec("ROLLBACK");
-    throw error;
-  }
-}
-
 function openLedger(dbPath) {
   const resolved = path.resolve(dbPath);
   fs.mkdirSync(path.dirname(resolved), { recursive: true });
@@ -149,10 +131,6 @@ function main() {
     result = { scenario: id };
   } else if (command === "test") {
     const id = required(options, "id");
-    const capabilityId = String(options.capability || "");
-    const scenarioId = String(options.scenario || "");
-    assertCampaignReference(db, "capabilities", capabilityId, campaignId, "capability");
-    assertCampaignReference(db, "scenarios", scenarioId, campaignId, "scenario");
     db.prepare(`INSERT INTO test_items
       (id, campaign_id, capability_id, scenario_id, title, profile, prompt_quality,
        prompt_path, expected_outputs_json, validation_plan, status, updated_at)
@@ -161,7 +139,7 @@ function main() {
       title=excluded.title, profile=excluded.profile, prompt_quality=excluded.prompt_quality,
       prompt_path=excluded.prompt_path, expected_outputs_json=excluded.expected_outputs_json,
       validation_plan=excluded.validation_plan, updated_at=excluded.updated_at`).run(
-      id, campaignId, capabilityId, scenarioId,
+      id, campaignId, String(options.capability || ""), String(options.scenario || ""),
       required(options, "title"), String(options.profile || "auto"),
       String(options.prompt_quality || "normal"), String(options.prompt_path || ""),
       jsonValue(options.expected_outputs), String(options.validation || ""),
@@ -188,28 +166,16 @@ function main() {
   } else if (command === "finish") {
     const id = required(options, "id");
     const status = required(options, "status");
-    const summary = required(options, "summary");
-    const evidence = jsonValue(options.evidence);
-    const item = db.prepare(
-      "SELECT capability_id, scenario_id FROM test_items WHERE id=? AND campaign_id=?"
-    ).get(id, campaignId);
-    if (!item) throw new Error(`Unknown test item: ${id}`);
-    assertCampaignReference(db, "capabilities", item.capability_id, campaignId, "capability");
-    assertCampaignReference(db, "scenarios", item.scenario_id, campaignId, "scenario");
-    runTransaction(db, () => {
-      db.prepare(`UPDATE test_items SET status=?, result_summary=?, evidence_json=?,
-        finished_at=?, updated_at=? WHERE id=? AND campaign_id=?`).run(
-        status, summary, evidence, timestamp, timestamp, id, campaignId
-      );
-      if (item.capability_id) {
-        db.prepare(`UPDATE capabilities SET status=?, last_test_id=?, updated_at=?
-          WHERE id=? AND campaign_id=?`).run(status, id, timestamp, item.capability_id, campaignId);
-      }
-      if (item.scenario_id) {
-        db.prepare("UPDATE scenarios SET status=?, updated_at=? WHERE id=? AND campaign_id=?")
-          .run(status, timestamp, item.scenario_id, campaignId);
-      }
-    });
+    const changed = db.prepare(`UPDATE test_items SET status=?, result_summary=?, evidence_json=?,
+      finished_at=?, updated_at=? WHERE id=? AND campaign_id=?`).run(
+      status, required(options, "summary"), jsonValue(options.evidence), timestamp, timestamp, id, campaignId
+    );
+    if (Number(changed.changes || 0) !== 1) throw new Error(`Unknown test item: ${id}`);
+    const item = db.prepare("SELECT capability_id FROM test_items WHERE id=?").get(id);
+    if (item?.capability_id) {
+      db.prepare("UPDATE capabilities SET status=?, last_test_id=?, updated_at=? WHERE id=?")
+        .run(status, id, timestamp, item.capability_id);
+    }
     result = { test: id, status };
   } else if (command === "fix") {
     const id = required(options, "id");

package/skills/data-analysis/SKILL.md

@@ -23,7 +23,8 @@ tools:
 ---
 # Data Analysis And ETL
 
-Preserve raw inputs. Inspect schemas, row counts, missing values, duplicate rows, units, time zones, and suspicious outliers before writing conclusions.
+Preserve raw/source/input exports as immutable evidence unless the user explicitly authorizes an in-place source change. Start with `inspect_project`, then read project instructions plus the relevant existing analyzer, configuration, and tests before editing or running ad hoc calculations. Inspect schemas, row counts, missing values, duplicate rows, units, aliases, time zones, and suspicious outliers before writing conclusions.
 
-Prefer a reproducible script over one-off chat math. Save cleaned data, plots, and reports with descriptive filenames. Rerun the script after edits and verify the output actually changed as intended.
+Prefer the project's existing reproducible analyzer over one-off chat math; repair or extend it when needed. Save cleaned data, plots, and reports at the exact declared output paths. Keep machine outputs separate from raw inputs and make the report explain methods, evidence, limitations, and the practical result.
 
+After an edit or patch conflict, reread the exact target and error before choosing a different bounded repair. Never repeat an unchanged failing patch. Rerun the smallest relevant check, then the full analysis and project tests. Verify cleaned schemas and row counts, inspect plot metadata or pixels, remove only generated caches, and do not claim success until every requested artifact exists and can be regenerated.

package/src/agent-runner.js

@@ -61,6 +61,12 @@ import {
   resolveLocalCodeRoute,
   restoreLocalCodePolicy,
 } from "./local-code-routing.js";
+import {
+  activateLocalFailureRecovery,
+  applyLocalFailureRecovery,
+  decideLocalFailureRecovery,
+  localFailureRecoveryInstruction,
+} from "./local-failure-recovery.js";
 import { resolveRuntimeConfig } from "./config.js";
 import {
   captureSessionRuntime,
@@ -2526,9 +2532,10 @@ export function recordExactOutputProgress(state = {}, toolResult = {}, config =
 }
 
 export function nextStepRuntimeConfig(config = {}, state = {}) {
+  const runtimeConfig = applyLocalFailureRecovery(config, state);
   if (state.meta?.artifactProgress?.complete) {
     return {
-      ...config,
+      ...runtimeConfig,
       artifactValidationPhase: true,
       convergenceOutputPhase: false,
       artifactValidationNeedsRepair: state.meta.artifactProgress.needsRepair === true,
@@ -2542,10 +2549,10 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
     };
   }
   const staticTotal = Number(state.meta?.toolLoop?.staticTotal || 0);
-  if (staticTotal < STATIC_DISCOVERY_CONVERGENCE_LIMIT) return config;
+  if (staticTotal < STATIC_DISCOVERY_CONVERGENCE_LIMIT) return runtimeConfig;
   const requiresPerSourceChecks = state.meta?.scs?.taskContract?.requiresPerSourceChecks === true;
   return {
-    ...config,
+    ...runtimeConfig,
     convergenceOutputPhase: true,
     convergenceAllowRunCommand: requiresPerSourceChecks,
   };
@@ -4168,11 +4175,15 @@ async function recordToolContractViolation({ config, state, store, observers, va
     total: totalViolationCount,
     lastCode: validation.code || "TOOL_CALL_INVALID",
   };
+  const localRecovery = decideLocalFailureRecovery(config, state);
+  const deferStopToLocalRecovery =
+    violationCount >= 2 && localRecovery.active === true && localRecovery.activated === true;
   const result = {
     ok: false,
     blocked: true,
-    recoverable: violationCount < 2,
-    stopRun: violationCount >= 2,
+    recoverable: violationCount < 2 || deferStopToLocalRecovery,
+    stopRun: violationCount >= 2 && !deferStopToLocalRecovery,
+    localFailureRecoveryPending: deferStopToLocalRecovery,
     violationCount,
     reason: validation.reason || "The model returned an invalid tool call and it was not dispatched.",
     category: "tool-contract-violation",
@@ -5030,6 +5041,37 @@ export async function runAgent(config) {
       const step = state.stepsCompleted + 1;
       throwIfAborted(config);
       await injectQueuedUserMessages(store, state, observers);
+      const localFailureRecovery = activateLocalFailureRecovery(config, state);
+      if (localFailureRecovery.active) {
+        config = applyLocalFailureRecovery(config, state);
+      }
+      if (localFailureRecovery.activated) {
+        state.provider = config.provider;
+        state.model = config.model;
+        state.meta.runtimeConfig = captureSessionRuntime(config, {
+          revision: state.meta.runtimeConfig?.revision || 1,
+        });
+        const recoveryInstruction = localFailureRecoveryInstruction(localFailureRecovery);
+        state.messages.push({ role: "user", content: recoveryInstruction });
+        const detail = {
+          step,
+          fromModel: localFailureRecovery.fromModel,
+          model: localFailureRecovery.model,
+          failureCount: localFailureRecovery.failureCount,
+          repeatedSignatureCount: localFailureRecovery.repeatedSignatureCount,
+          contractViolationCount: localFailureRecovery.contractViolationCount || 0,
+          failedTools: localFailureRecovery.failedTools || [],
+          reason: localFailureRecovery.reason,
+        };
+        await store.appendEvent("provider.local_failure_recovery", detail);
+        observers.event("provider.local_failure_recovery", detail);
+        emitConsole(
+          config,
+          `Local route recovery: ${localFailureRecovery.fromModel} -> ${localFailureRecovery.model} after repeated tool failures.`,
+          { kind: "meta" }
+        );
+        await store.saveState(state);
+      }
       const snapshot = await buildSnapshot(browserState, store, step, config);
       state.meta.lastUrl = snapshot.url || state.meta.lastUrl;
       await saveBrowserState(browserState, store).catch(() => {});

package/src/integration-run-registry.js

@@ -4,9 +4,15 @@ import {
   validateIntegrationThreadId,
 } from "./integration-policy.js";
 import { authorityFail } from "./integration-durable-common.js";
+import { types as utilTypes } from "node:util";
 
 export const INTEGRATION_RUN_REGISTRY_ATTESTATION_VERSION = "aginti-live-run-registry-v1";
 
+const PromisePrototype = Promise.prototype;
+const PromisePrototypeThen = Promise.prototype.then;
+const ReflectApply = Reflect.apply;
+const ReflectOwnKeys = Reflect.ownKeys;
+
 function assertPrincipalId(value) {
   if (typeof value !== "string" || !/^[A-Za-z0-9._~-]{16,128}$/u.test(value)) {
     authorityFail("INVALID_PRINCIPAL", "Integration principal scope is invalid.", { status: 401 });
@@ -53,6 +59,27 @@ export function createIntegrationRunRegistry() {
   const runs = new Map();
   const threadActiveRun = new Map();
 
+  function releaseExactRecord(runId, record) {
+    const current = runs.get(runId);
+    if (current !== record) return Object.freeze({ released: false });
+    runs.delete(runId);
+    if (threadActiveRun.get(record.threadId) === runId) threadActiveRun.delete(record.threadId);
+    return Object.freeze({ released: true, runId });
+  }
+
+  function assertNativePromise(promise) {
+    if (promise && (typeof promise === "object" || typeof promise === "function") && utilTypes.isProxy(promise)) {
+      authorityFail("AGENT_UNAVAILABLE", "Live run registry requires a native run promise.");
+    }
+    if (!utilTypes.isPromise(promise) || Object.getPrototypeOf(promise) !== PromisePrototype) {
+      authorityFail("AGENT_UNAVAILABLE", "Live run registry requires a native run promise.");
+    }
+    if (ReflectOwnKeys(promise).length !== 0) {
+      authorityFail("AGENT_UNAVAILABLE", "Live run registry promise must not expose own fields.");
+    }
+    return promise;
+  }
+
   function claimRun(claimInput = {}) {
     const claim = normalizeClaim(claimInput);
     const active = threadActiveRun.get(claim.threadId);
@@ -83,18 +110,23 @@ export function createIntegrationRunRegistry() {
     const runId = validateIntegrationRunId(runIdInput);
     const record = runs.get(runId);
     if (!record) notFound("Run");
-    if (!(promise instanceof Promise)) {
-      authorityFail("AGENT_UNAVAILABLE", "Live run registry requires a native run promise.");
+    if (record.promise) {
+      authorityFail("RUN_CONFLICT", "Integration run already has a native run promise.", { status: 409 });
+    }
+    try {
+      const nativePromise = assertNativePromise(promise);
+      const release = () => {
+        releaseExactRecord(runId, record);
+      };
+      const observer = ReflectApply(PromisePrototypeThen, nativePromise, [release, release]);
+      ReflectApply(PromisePrototypeThen, observer, [undefined, () => {}]);
+      record.promise = nativePromise;
+      return nativePromise;
+    } catch (error) {
+      releaseExactRecord(runId, record);
+      if (error?.code || error?.publicCode) throw error;
+      authorityFail("AGENT_UNAVAILABLE", "Live run registry could not attach the native run promise.");
     }
-    record.promise = promise.finally(() => {
-      const current = runs.get(runId);
-      if (current === record) {
-        runs.delete(runId);
-        if (threadActiveRun.get(record.threadId) === runId) threadActiveRun.delete(record.threadId);
-      }
-    });
-    record.promise.catch(() => {});
-    return record.promise;
   }
 
   function getRun(runIdInput, scope = {}) {
@@ -135,9 +167,7 @@ export function createIntegrationRunRegistry() {
     const runId = validateIntegrationRunId(runIdInput);
     const record = runs.get(runId);
     if (!record) return Object.freeze({ released: false });
-    runs.delete(runId);
-    if (threadActiveRun.get(record.threadId) === runId) threadActiveRun.delete(record.threadId);
-    return Object.freeze({ released: true, runId });
+    return releaseExactRecord(runId, record);
   }
 
   function hasActiveThreadRun(threadIdInput) {