@tangle-network/agent-runtime 0.102.2 → 0.103.1

package/dist/{chunk-3DW5DEKQ.js → chunk-5AITUUHO.js}

@@ -3,13 +3,13 @@ import {
   agentImprovementTargetInput,
   verifyAgentImprovementActivation,
   verifyAgentImprovementProposal
-} from "./chunk-7FJJUC73.js";
+} from "./chunk-LFM4JBRW.js";
 import {
   canonicalCandidateDigest,
   canonicalCandidateDocument,
   immutableCandidateValue,
   verifyCanonicalCandidateDocument
-} from "./chunk-LJLG734E.js";
+} from "./chunk-SBTWKPVR.js";
 
 // src/intelligence/activation.ts
 import {
@@ -197,4 +197,4 @@ export {
   verifyAgentImprovementActivationResult,
   executeAgentImprovementActivation
 };
-//# sourceMappingURL=chunk-3DW5DEKQ.js.map
+//# sourceMappingURL=chunk-5AITUUHO.js.map

package/dist/{chunk-SQ3ZJH3Y.js → chunk-6WZZXQV5.js}

@@ -1,6 +1,9 @@
 import {
-  contentAddress
-} from "./chunk-IMSNJSXH.js";
+  contentAddress,
+  materializeTreeView,
+  pendingWaits,
+  replaySpawnTree
+} from "./chunk-ISPWRSEC.js";
 import {
   addTokenUsage,
   zeroTokenUsage
@@ -1684,6 +1687,186 @@ function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 
+// src/runtime/supervise/progress.ts
+var DEFAULT_STALL_AFTER_MS = 18e4;
+function createActivityLog(limit = 12) {
+  const notes = [];
+  const cap = Math.max(1, Math.floor(limit));
+  return {
+    push(note) {
+      notes.push(note);
+      if (notes.length > cap) notes.splice(0, notes.length - cap);
+    },
+    read: () => [...notes],
+    last: () => notes[notes.length - 1],
+    size: () => notes.length
+  };
+}
+function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_AFTER_MS) {
+  const live = scope.status !== "done" && scope.status !== "failed" && scope.status !== "cancelled";
+  const executorActivityAt = executor?.recentActivity?.length ? executor.recentActivity[executor.recentActivity.length - 1].at : 0;
+  const lastActivityAt = Math.max(scope.lastActivityAt, executorActivityAt);
+  const idleMs = Math.max(0, now - lastActivityAt);
+  const note = executor?.note;
+  return {
+    id: scope.id,
+    status: scope.status,
+    live,
+    steerable: scope.steerable,
+    startedAt: scope.startedAt,
+    lastActivityAt,
+    idleMs,
+    // Only a LIVE worker can stall; a settled one is simply finished.
+    stalled: live && idleMs > stallAfterMs,
+    stallAfterMs,
+    turns: executor?.turns ?? scope.turns,
+    tokens: scope.tokens,
+    usd: scope.usd,
+    pendingMessages: executor?.pendingMessages ?? 0,
+    recentActivity: executor?.recentActivity ?? [],
+    ...note ? { note } : {}
+  };
+}
+
+// src/runtime/supervise/wait.ts
+function timerAt(ms, now) {
+  return { kind: "timer", untilMs: now + ms };
+}
+function pollFor(probe, opts, now) {
+  return {
+    kind: "poll",
+    probe,
+    intervalMs: opts.intervalMs,
+    ...opts.timeoutMs !== void 0 ? { timeoutAtMs: now + opts.timeoutMs } : {},
+    ...opts.args ? { args: opts.args } : {}
+  };
+}
+function createWaitProbes(entries) {
+  const map = new Map(Object.entries(entries));
+  return { resolve: (name) => map.get(name) };
+}
+function isWaitOutcome(value) {
+  return typeof value === "object" && value !== null && value.waitOutcome === true;
+}
+function waitUntil(spec) {
+  return spec.kind === "timer" ? spec.untilMs : spec.timeoutAtMs;
+}
+function validateWaitSpec(spec) {
+  if (spec.kind === "timer") {
+    return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
+  }
+  if (typeof spec.probe !== "string" || spec.probe.length === 0) {
+    return "poll.probe must be a non-empty probe name";
+  }
+  if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) {
+    return "poll.intervalMs must be > 0";
+  }
+  if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) {
+    return "poll.timeoutAtMs must be a finite epoch-ms instant";
+  }
+  return null;
+}
+function assertWaitWithinDeadline(spec, deadlineMs) {
+  if (deadlineMs <= 0) return true;
+  const until = waitUntil(spec);
+  if (until === void 0) return false;
+  return until <= deadlineMs;
+}
+async function runWait(args) {
+  const { spec, label, armedAt, resumed, signal, now } = args;
+  const sleep = args.sleep ?? defaultSleep;
+  if (signal.aborted) return { kind: "cancelled", reason: "aborted before arming" };
+  if (spec.kind === "timer") {
+    const remaining = spec.untilMs - now();
+    if (remaining > 0) await sleep(remaining, signal);
+    if (signal.aborted) return { kind: "cancelled", reason: "wait aborted" };
+    return {
+      kind: "woke",
+      outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
+    };
+  }
+  const probe = args.probes?.resolve(spec.probe);
+  if (!probe) {
+    throw new ValidationError(
+      `wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`
+    );
+  }
+  let polls = 0;
+  let probeErrors = 0;
+  for (; ; ) {
+    if (signal.aborted) return { kind: "cancelled", reason: "wait aborted" };
+    polls += 1;
+    let fired = false;
+    try {
+      fired = await probe(spec.args, signal);
+    } catch {
+      probeErrors += 1;
+    }
+    if (fired) {
+      return {
+        kind: "woke",
+        outcome: outcome(
+          "poll",
+          "fired",
+          label,
+          spec.timeoutAtMs,
+          armedAt,
+          now(),
+          polls,
+          probeErrors,
+          resumed
+        )
+      };
+    }
+    if (spec.timeoutAtMs !== void 0 && now() >= spec.timeoutAtMs) {
+      return {
+        kind: "woke",
+        outcome: outcome(
+          "poll",
+          "timeout",
+          label,
+          spec.timeoutAtMs,
+          armedAt,
+          now(),
+          polls,
+          probeErrors,
+          resumed
+        )
+      };
+    }
+    const nextCheck = spec.timeoutAtMs === void 0 ? spec.intervalMs : Math.min(spec.intervalMs, Math.max(0, spec.timeoutAtMs - now()));
+    await sleep(nextCheck, signal);
+  }
+}
+function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeErrors, resumed) {
+  return {
+    waitOutcome: true,
+    kind,
+    settled,
+    label,
+    ...untilMs !== void 0 ? { untilMs } : {},
+    armedAt,
+    wokenAt,
+    polls,
+    probeErrors,
+    resumed
+  };
+}
+function defaultSleep(ms, signal) {
+  if (ms <= 0 || signal.aborted) return Promise.resolve();
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      resolve2();
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // src/runtime/supervise/scope.ts
 var nestedScopeSeamKey = "nested-scope";
 function makeNestedScopeSeam(args, childNodeId) {
@@ -1713,10 +1896,14 @@ function makeNestedScopeSeam(args, childNodeId) {
 }
 function createScope(args) {
   const children = /* @__PURE__ */ new Map();
-  let spawnOrdinal = 0;
-  let cursorSeq = 0;
+  let spawnOrdinal = args.resumeFrom ? args.resumeFrom.maxSpawnOrdinal + 1 : 0;
+  let cursorSeq = args.resumeFrom ? args.resumeFrom.maxCursorSeq + 1 : 0;
+  let waitOrdinal = args.resumeFrom ? args.resumeFrom.maxWaitOrdinal + 1 : 0;
   let meterSeq = 0;
   const now = args.now ?? Date.now;
+  const unclaimedWaits = new Map(
+    (args.resumeFrom?.waits ?? []).map((w) => [w.label, w])
+  );
   function spawn4(agent, task, opts) {
     if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) {
       return { ok: false, reason: "depth-exceeded" };
@@ -1763,7 +1950,11 @@ function createScope(args) {
         settled: void 0,
         delivered: false,
         executorDone: false,
-        ...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {}
+        startedAt: now(),
+        lastActivityAt: now(),
+        ...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {},
+        ...executor.progress ? { readProgress: executor.progress.bind(executor) } : {},
+        ...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {}
       };
       children.set(id, live);
       void args.journal.appendEvent(args.root, {
@@ -1804,7 +1995,8 @@ function createScope(args) {
         opts,
         args.pool,
         reservation.ticket,
-        args.blobs
+        args.blobs,
+        now
       ).then((s) => {
         live.resolved = s;
         return s;
@@ -1854,8 +2046,152 @@ function createScope(args) {
     const child = children.get(nodeId);
     if (!child || child.delivered || !child.deliver) return false;
     child.deliver(msg);
+    child.lastActivityAt = now();
     return true;
   }
+  function wait(spec, opts) {
+    if (validateWaitSpec(spec) !== null) return { ok: false, reason: "invalid-spec" };
+    if (spec.kind === "poll" && args.probes?.resolve(spec.probe) === void 0) {
+      return { ok: false, reason: "unknown-probe" };
+    }
+    const adopted = unclaimedWaits.get(opts.label);
+    if (adopted) unclaimedWaits.delete(opts.label);
+    const effectiveSpec = adopted?.spec ?? spec;
+    const armedAt = adopted?.armedAt ?? now();
+    if (!assertWaitWithinDeadline(effectiveSpec, args.pool.readout().deadlineMs)) {
+      return { ok: false, reason: "deadline-exceeded" };
+    }
+    const id = adopted ? adopted.id : `${args.parentId}:w${waitOrdinal}`;
+    const ordinal = adopted ? adopted.ordinal : waitOrdinal;
+    if (!adopted) waitOrdinal += 1;
+    const waitAbort = new AbortController();
+    const cascadeAbort = () => waitAbort.abort();
+    if (args.signal.aborted) waitAbort.abort();
+    else args.signal.addEventListener("abort", cascadeAbort, { once: true });
+    const handle = {
+      id,
+      label: opts.label,
+      get status() {
+        return children.get(id)?.status ?? "cancelled";
+      },
+      abort(reason) {
+        waitAbort.abort(reason);
+      }
+    };
+    const live = {
+      id,
+      status: "waiting",
+      runtime: "wait",
+      // A wait's recorded budget is zero on every channel — nothing was reserved, so nothing may
+      // be reconciled, and a journal reader sums it as the zero it truly is.
+      budget: { maxIterations: 0, maxTokens: 0 },
+      label: opts.label,
+      spent: zeroSpend(),
+      settled: void 0,
+      delivered: false,
+      executorDone: false,
+      startedAt: armedAt,
+      lastActivityAt: now(),
+      wait: { spec: effectiveSpec, armedAt, label: opts.label }
+    };
+    children.set(id, live);
+    if (!adopted) {
+      void args.journal.appendEvent(args.root, {
+        kind: "waiting",
+        id,
+        parent: args.parentId,
+        label: opts.label,
+        spec: effectiveSpec,
+        armedAt,
+        seq: ordinal,
+        at: new Date(now()).toISOString()
+      });
+    }
+    notifyRuntimeHookEvent(
+      args.hooks,
+      {
+        id: `${id}:waiting`,
+        runId: args.root,
+        target: "agent.spawn",
+        phase: "after",
+        timestamp: now(),
+        stepIndex: ordinal,
+        parentId: args.parentId,
+        payload: {
+          childId: id,
+          label: opts.label,
+          runtime: "wait",
+          wait: effectiveSpec,
+          armedAt,
+          resumed: adopted !== void 0
+        }
+      },
+      { signal: args.signal }
+    );
+    const settled = runWait({
+      spec: effectiveSpec,
+      label: opts.label,
+      armedAt,
+      resumed: adopted !== void 0,
+      signal: waitAbort.signal,
+      ...args.probes ? { probes: args.probes } : {},
+      now,
+      ...args.waitSleep ? { sleep: args.waitSleep } : {}
+    }).then(async (resolution) => {
+      live.executorDone = true;
+      live.lastActivityAt = now();
+      if (resolution.kind === "cancelled") {
+        return { kind: "down", reason: resolution.reason, infra: false, restartCount: 0 };
+      }
+      const outRef = contentAddress(resolution.outcome);
+      await args.blobs.put(outRef, resolution.outcome);
+      return { kind: "done", out: resolution.outcome, outRef, spent: zeroSpend() };
+    }).catch((err) => {
+      live.executorDone = true;
+      return { kind: "down", reason: errMessage(err), infra: true, restartCount: 0 };
+    }).then((s) => {
+      live.resolved = s;
+      return s;
+    }).finally(() => {
+      args.signal.removeEventListener("abort", cascadeAbort);
+    });
+    live.settled = settled;
+    return { ok: true, handle };
+  }
+  function progress(nodeId, opts = {}) {
+    const child = children.get(nodeId);
+    if (!child) return void 0;
+    let fromExecutor;
+    try {
+      fromExecutor = child.readProgress?.();
+    } catch {
+      fromExecutor = void 0;
+    }
+    return readWorkerProgress(
+      {
+        id: child.id,
+        status: child.status,
+        steerable: child.deliver !== void 0 && !child.delivered,
+        startedAt: child.startedAt,
+        lastActivityAt: child.lastActivityAt,
+        turns: child.spent.iterations,
+        tokens: child.spent.tokens,
+        usd: child.spent.usd
+      },
+      fromExecutor,
+      opts.now ?? now(),
+      opts.stallAfterMs ?? DEFAULT_STALL_AFTER_MS
+    );
+  }
+  function traceSource(nodeId) {
+    const child = children.get(nodeId);
+    if (!child) return void 0;
+    try {
+      return child.readTraceSource?.();
+    } catch {
+      return void 0;
+    }
+  }
   async function meter(spend, detail) {
     const seq = meterSeq++;
     args.pool.observe(spend);
@@ -1880,13 +2216,22 @@ function createScope(args) {
       { signal: args.signal }
     );
   }
+  const resume = args.resumeFrom ? {
+    settled: args.resumeFrom.settled,
+    view: args.resumeFrom.view,
+    waits: args.resumeFrom.waits
+  } : void 0;
   return {
     spawn: spawn4,
     next,
     nextResolved,
     send,
+    wait,
+    progress,
+    traceSource,
     signal: args.signal,
     meter,
+    ...resume ? { resume } : {},
     get view() {
       return makeTreeView(args.parentId, children);
     },
@@ -1900,6 +2245,7 @@ async function raceFirstSettled(pending) {
 }
 async function finalizeSettlement(child, settlement, seq, args, now) {
   const handle = frozenHandle(child);
+  if (child.wait) return finalizeWait(child, settlement, seq, args, now, handle);
   if (settlement.kind === "down") {
     child.status = "failed";
     await args.journal.appendEvent(args.root, {
@@ -2002,7 +2348,61 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
     seq
   };
 }
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs) {
+async function finalizeWait(child, settlement, seq, args, now, handle) {
+  const at = new Date(now()).toISOString();
+  if (settlement.kind === "down") {
+    child.status = "cancelled";
+    await args.journal.appendEvent(args.root, {
+      kind: "woken",
+      id: child.id,
+      by: "cancelled",
+      seq,
+      at
+    });
+    return {
+      kind: "down",
+      handle,
+      reason: settlement.reason,
+      infra: settlement.infra,
+      restartCount: settlement.restartCount,
+      seq
+    };
+  }
+  child.status = "done";
+  child.outRef = settlement.outRef;
+  const out = settlement.out;
+  await args.journal.appendEvent(args.root, {
+    kind: "woken",
+    id: child.id,
+    by: out.settled,
+    outRef: settlement.outRef,
+    seq,
+    at
+  });
+  notifyRuntimeHookEvent(
+    args.hooks,
+    {
+      id: `${child.id}:woken`,
+      runId: args.root,
+      target: "agent.child",
+      phase: "after",
+      timestamp: now(),
+      stepIndex: seq,
+      parentId: args.parentId,
+      payload: { childId: child.id, status: "done", wait: out }
+    },
+    { signal: args.signal }
+  );
+  return {
+    kind: "done",
+    handle,
+    out: settlement.out,
+    outRef: settlement.outRef,
+    spent: settlement.spent,
+    seq
+  };
+}
+async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now) {
   let reconciled = false;
   const reconcileOnce = (spend) => {
     if (reconciled) return;
@@ -2014,7 +2414,10 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
     const ran = executor.execute(task, childAbort.signal);
     let artifact;
     if (isAsyncIterable(ran)) {
-      const spend = await foldStream(ran);
+      const spend = await foldStream(ran, (running) => {
+        live.spent = running;
+        live.lastActivityAt = now();
+      });
       live.spent = spend;
       artifact = executor.resultArtifact();
       reconcileOnce(spend);
@@ -2082,7 +2485,8 @@ function makeTreeView(root, children) {
   return {
     root,
     nodes,
-    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length
+    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length,
+    waiting: nodes.filter((n) => n.status === "waiting").length
   };
 }
 function frozenHandle(child) {
@@ -2094,7 +2498,7 @@ function frozenHandle(child) {
     }
   };
 }
-async function foldStream(stream) {
+async function foldStream(stream, onProgress) {
   const tokens = { input: 0, output: 0 };
   let usd = 0;
   let iterations = 0;
@@ -2107,6 +2511,7 @@ async function foldStream(stream) {
     } else {
       iterations += 1;
     }
+    onProgress?.({ iterations, tokens: { ...tokens }, usd, ms: 0 });
   }
   return { iterations, tokens, usd, ms: 0 };
 }
@@ -2312,22 +2717,49 @@ function createBudgetPool(root, now = Date.now) {
 }
 
 // src/runtime/supervise/supervisor.ts
+function maxSeqOf(events, pred) {
+  let max = -1;
+  for (const ev of events) if (pred(ev) && ev.seq > max) max = ev.seq;
+  return max;
+}
 var defaultMaxDepth = 4;
 function createSupervisor() {
   let attached;
   async function run(root, task, opts) {
     const now = opts.now ?? Date.now;
     const pool = createBudgetPool(opts.budget, now);
-    await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
-    await opts.journal.appendEvent(opts.runId, {
-      kind: "spawned",
-      id: opts.runId,
-      label: "root",
-      budget: opts.budget,
-      runtime: "inline",
-      seq: 0,
-      at: new Date(now()).toISOString()
-    });
+    const prior = opts.resume === true ? await opts.journal.loadTree(opts.runId) : void 0;
+    const resuming = prior !== void 0 && prior.length > 0;
+    let resumeFrom;
+    if (resuming) {
+      const settled = await replaySpawnTree(opts.journal, opts.blobs, opts.runId);
+      const view = materializeTreeView(prior);
+      resumeFrom = {
+        settled,
+        view,
+        maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
+        maxCursorSeq: maxSeqOf(
+          prior,
+          (ev) => ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken"
+        ),
+        maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
+        // Waits armed but never woken: the run died mid-wait. They ride onto `Scope.resume.waits`,
+        // and re-arming the same label adopts the ORIGINAL absolute deadline rather than
+        // restarting the countdown from this process's clock.
+        waits: pendingWaits(prior)
+      };
+    } else {
+      await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
+      await opts.journal.appendEvent(opts.runId, {
+        kind: "spawned",
+        id: opts.runId,
+        label: "root",
+        budget: opts.budget,
+        runtime: "inline",
+        seq: 0,
+        at: new Date(now()).toISOString()
+      });
+    }
     const controller = new AbortController();
     const cascadeAbort = (reason) => {
       if (controller.signal.aborted) return;
@@ -2352,7 +2784,9 @@ function createSupervisor() {
       maxDepth: opts.maxDepth ?? defaultMaxDepth,
       signal: controller.signal,
       now,
-      hooks: opts.hooks
+      hooks: opts.hooks,
+      ...opts.probes ? { probes: opts.probes } : {},
+      ...resumeFrom ? { resumeFrom } : {}
     });
     const openScope = scope;
     if (attached) {
@@ -2455,7 +2889,8 @@ function wrapJournalForBreaker(journal, breaker) {
   };
 }
 async function drainLiveChildren(scope, controller) {
-  const hasLive = scope.view.inFlight > 0;
+  const view = scope.view;
+  const hasLive = view.inFlight > 0 || view.waiting > 0;
   if (!hasLive) return;
   if (!controller.signal.aborted) controller.abort();
   await Promise.allSettled([drainCursor(scope)]);
@@ -3072,6 +3507,15 @@ export {
   composeRuntimeHooks,
   notifyRuntimeHookEvent,
   notifyRuntimeDecisionPoint,
+  DEFAULT_STALL_AFTER_MS,
+  createActivityLog,
+  readWorkerProgress,
+  timerAt,
+  pollFor,
+  createWaitProbes,
+  isWaitOutcome,
+  waitUntil,
+  validateWaitSpec,
   createScope,
   settledToIteration,
   withDriverExecutor,
@@ -3079,4 +3523,4 @@ export {
   createBudgetPool,
   createSupervisor
 };
-//# sourceMappingURL=chunk-SQ3ZJH3Y.js.map
+//# sourceMappingURL=chunk-6WZZXQV5.js.map