@lazyingart/agintiflow 0.20.205 → 0.20.206

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.206",
   "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",

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/src/agent-runner.js

@@ -7,7 +7,6 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { chromium } from "playwright";
 import { createClient, createPlan, requestNextStep } from "./model-client.js";
 import { SessionStore } from "./session-store.js";
-import { assertIntegrationRunAgentInvocation } from "./integration-session-persistence.js";
 import { captureSnapshot } from "./snapshot.js";
 import { checkToolUse } from "./guardrails.js";
 import { ensureDockerSandboxReady, runDockerSandboxCommand } from "./docker-sandbox.js";
@@ -237,9 +236,8 @@ function withSelectedSkillReadOnlyRoots(config = {}, state = {}) {
 function throwIfAborted(config) {
   if (config.abortSignal?.aborted) {
     const reason = config.abortSignal.reason;
-    if (reason instanceof Error) throw reason;
-    const error = new Error("Run interrupted by user.");
-    error.name = "AbortError";
+    const error = reason instanceof Error ? reason : new Error("Run interrupted by user.");
+    error.name = error.name || "AbortError";
     throw error;
   }
 }
@@ -4526,7 +4524,6 @@ async function recordPreInferenceFailure({ error, config, state, store, observer
 }
 
 export async function runAgent(config) {
-  assertIntegrationRunAgentInvocation(config);
   const incomingConfig = config;
   const sessionId = config.resume || config.sessionId || `web-agent-${crypto.randomUUID()}`;
   const store = new SessionStore(config.sessionsDir, sessionId, {

package/src/integration-core-event-projector.js

@@ -59,7 +59,7 @@ const FORBIDDEN_KEYS = new Set([
   "url",
 ]);
 const ABSOLUTE_PATH_OR_SECRET_PATTERN =
-  /(?:^|[\s("'`<>\[{=])(?:file:\/\/\/[^\s"'`<>)\]}]+|\/(?!\/)[^\s"'`<>)\]}]+|[A-Za-z]:[\\/][^\s"'`<>)\]}]+|\\\\[^\\/\s"'`<>)\]}]+\\[^\s"'`<>)\]}]+|(?:api[_-]?key|token|secret|password)\s*[:=])/iu;
+  /(?:^|[\s("'`])(?:\/(?:workspace|home|users|root|etc|usr|var|opt|srv|run|tmp|proc|sys|dev|mnt|media|aginti-(?:home|cache|env))(?:\/|\b)|[A-Za-z]:\\|(?:api[_-]?key|token|secret|password)\s*[:=])/iu;
 const EVENT_LEDGER_STORE_REQUIRED_KEYS = Object.freeze([
   "owner",
   "authority",
@@ -383,103 +383,29 @@ export function createIntegrationCoreEventProjector(options = {}) {
     }
   }
 
-  function toolStateKey(scope) {
-    return `${scope.principalId}\n${scope.browserSessionId}\n${scope.threadId}\n${scope.runId}`;
-  }
-
-  function validateLedgerHeadCursor(headInput, label) {
-    const seq = Number(headInput?.seq ?? 0);
-    const hash = String(headInput?.hash ?? "0".repeat(64));
-    if (
-      !Number.isSafeInteger(seq) ||
-      seq < 0 ||
-      !/^[a-f0-9]{64}$/u.test(hash) ||
-      ((seq === 0) !== (hash === "0".repeat(64)))
-    ) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", `${label} cursor is invalid.`);
-    }
-    return Object.freeze({ seq, hash });
-  }
-
-  function assertPublicEventEnvelopeHash(event, label) {
-    const checked = createPublicIntegrationEvent({
-      threadId: event.threadId,
-      runId: event.runId,
-      seq: event.seq,
-      type: event.type,
-      payload: event.payload,
-      createdAt: event.createdAt,
-      previousHash: event.previousHash,
-    });
-    if (
-      event.schemaVersion !== checked.schemaVersion ||
-      event.id !== checked.id ||
-      event.hash !== checked.hash ||
-      contractDigest(event) !== contractDigest(checked)
-    ) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", `${label} hash is invalid.`);
-    }
-  }
-
-  async function loadLedgerHeadAndLastEvent(ledger, scope) {
-    if (
-      !ledger ||
-      typeof ledger.loadHead !== "function" ||
-      typeof ledger.loadCursor !== "function" ||
-      typeof ledger.loadEventsAfter !== "function"
-    ) {
-      authorityFail("PUBLIC_EVENT_LEDGER_UNAVAILABLE", "Public event ledger head is unavailable.");
-    }
-    const head = validateLedgerHeadCursor(await ledger.loadHead(), "Public event ledger head");
-    if (head.seq === 0) return Object.freeze({ head, lastEvent: null });
-    const cursor = validateLedgerHeadCursor(await ledger.loadCursor(head.seq), "Public event ledger head event");
-    if (cursor.seq !== head.seq || cursor.hash !== head.hash) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger head cursor does not match the last event.");
-    }
-    const events = await ledger.loadEventsAfter(head.seq - 1);
-    if (!Array.isArray(events) || events.length !== 1) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger did not return the exact last event.");
-    }
-    const [lastEvent] = events;
-    assertExactPublicEventView(lastEvent, "Public event ledger last event");
-    if (
-      lastEvent.threadId !== scope.threadId ||
-      lastEvent.runId !== scope.runId ||
-      lastEvent.seq !== head.seq ||
-      lastEvent.hash !== head.hash
-    ) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger last event does not match the requested head.");
-    }
-    if (
-      (lastEvent.principalId !== undefined && lastEvent.principalId !== scope.principalId) ||
-      (lastEvent.browserSessionId !== undefined && lastEvent.browserSessionId !== scope.browserSessionId)
-    ) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger last event substituted scope.");
-    }
-    assertPublicEventEnvelopeHash(lastEvent, "Public event ledger last event");
-    return Object.freeze({ head, lastEvent });
-  }
-
   async function appendProjectedEvent(projectedInput, scopeInput) {
     const scope = assertScope(scopeInput);
     const projected = projectedInput;
     if (!projected) return null;
-    const projectedIsTerminal = TERMINAL_TYPES.has(projected.type);
-    if ((projected.terminal === true) !== projectedIsTerminal) {
-      authorityFail("UNSUPPORTED_CORE_EVENT", "Projected event terminal flag does not match its public type.", { status: 400 });
-    }
-    const stateKey = toolStateKey(scope);
     const ledger =
       typeof eventLedgerStore.ledgerForRun === "function"
         ? eventLedgerStore.ledgerForRun(scope)
         : null;
     assertLedgerScope(ledger || {}, scope);
-    const { head, lastEvent } = await loadLedgerHeadAndLastEvent(ledger, scope);
-    if (lastEvent && TERMINAL_TYPES.has(lastEvent.type)) {
-      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger terminal finality blocks later run events.");
+    const head =
+      ledger && typeof ledger.loadHead === "function"
+        ? await ledger.loadHead()
+        : { seq: 0, hash: "0".repeat(64) };
+    const previousSeq = Number(head?.seq || 0);
+    const previousHash = String(head?.hash || "0".repeat(64));
+    if (
+      !Number.isSafeInteger(previousSeq) ||
+      previousSeq < 0 ||
+      !/^[a-f0-9]{64}$/u.test(previousHash) ||
+      ((previousSeq === 0) !== (previousHash === "0".repeat(64)))
+    ) {
+      authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger head cursor is invalid.");
     }
-    const previousSeq = head.seq;
-    const previousHash = head.hash;
     if (
       projected.expectedPreviousSeq !== undefined &&
       (projected.expectedPreviousSeq !== previousSeq || projected.expectedPreviousHash !== previousHash)
@@ -492,23 +418,11 @@ export function createIntegrationCoreEventProjector(options = {}) {
       createdAt: projected.createdAt,
     });
     assertExactPublicEventView(event, "Public event ledger append");
-    const checked = createPublicIntegrationEvent({
-      threadId: event.threadId,
-      runId: event.runId,
-      seq: event.seq,
-      type: event.type,
-      payload: event.payload,
-      createdAt: event.createdAt,
-      previousHash: event.previousHash,
-    });
     if (
       event.threadId !== scope.threadId ||
       event.runId !== scope.runId ||
-      event.schemaVersion !== checked.schemaVersion ||
-      event.id !== checked.id ||
       event.seq !== previousSeq + 1 ||
       event.previousHash !== previousHash ||
-      event.hash !== checked.hash ||
       event.type !== projected.type ||
       event.createdAt !== projected.createdAt ||
       contractDigest(event.payload) !== contractDigest(projected.payload)
@@ -521,7 +435,16 @@ export function createIntegrationCoreEventProjector(options = {}) {
     ) {
       authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger append substituted the requested scope.");
     }
-    if (checked.hash !== event.hash || contractDigest(checked) !== contractDigest(event)) {
+    const checked = createPublicIntegrationEvent({
+      threadId: event.threadId,
+      runId: event.runId,
+      seq: event.seq,
+      type: event.type,
+      payload: event.payload,
+      createdAt: event.createdAt,
+      previousHash: event.previousHash,
+    });
+    if (checked.hash !== event.hash) {
       authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Appended public event hash is invalid.");
     }
     if (ledger && typeof ledger.loadHead === "function") {
@@ -530,39 +453,36 @@ export function createIntegrationCoreEventProjector(options = {}) {
         authorityFail("PUBLIC_EVENT_LEDGER_CORRUPT", "Public event ledger head did not advance to the appended event.");
       }
     }
-    if (projected.terminal) {
-      toolStateByRun.delete(stateKey);
-    }
+    if (projected.terminal) toolStateByRun.delete(scope.runId);
     return Object.freeze({ ...checked, terminal: projected.terminal });
   }
 
   async function appendCoreEvent(type, data, scopeInput) {
     const scope = assertScope(scopeInput);
     const rawType = String(type || "");
-    const stateKey = toolStateKey(scope);
     const needsToolState = TOOL_EVENT_TYPES.has(rawType);
-    const hadState = toolStateByRun.has(stateKey);
-    let toolState = needsToolState ? toolStateByRun.get(stateKey) : undefined;
+    const hadState = toolStateByRun.has(scope.runId);
+    let toolState = needsToolState ? toolStateByRun.get(scope.runId) : undefined;
     if (needsToolState && !toolState) {
       toolState = { nextOrdinal: 0, activeByTool: new Map() };
-      toolStateByRun.set(stateKey, toolState);
+      toolStateByRun.set(scope.runId, toolState);
     }
     const snapshot = needsToolState ? snapshotToolState(toolState) : null;
     let projected = null;
     try {
       projected = projectCoreEvent(type, data, { now, runId: scope.runId, ...(needsToolState ? { toolState } : {}) });
     } catch (error) {
-      if (needsToolState) restoreToolState(stateKey, hadState, snapshot);
+      if (needsToolState) restoreToolState(scope.runId, hadState, snapshot);
       throw error;
     }
     if (!projected) {
-      if (needsToolState) restoreToolState(stateKey, hadState, snapshot);
+      if (needsToolState) restoreToolState(scope.runId, hadState, snapshot);
       return null;
     }
     try {
       return await appendProjectedEvent(projected, scope);
     } catch (error) {
-      if (needsToolState) restoreToolState(stateKey, hadState, snapshot);
+      if (needsToolState) restoreToolState(scope.runId, hadState, snapshot);
       throw error;
     }
   }
@@ -576,12 +496,8 @@ export function createIntegrationCoreEventProjector(options = {}) {
     owner: "aginti",
     authority: "aginti",
     appendCoreEvent,
+    appendProjectedEvent,
     appendAuthorityTerminalEvent,
-    clearRun(scopeInput, options = {}) {
-      const scope = assertScope(scopeInput);
-      const stateKey = toolStateKey(scope);
-      toolStateByRun.delete(stateKey);
-    },
     projectCoreEvent(type, data, scope = {}) {
       return projectCoreEvent(type, data, { now, runId: scope.runId || "" });
     },