eve-hub 0.4.2 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",
@@ -28,8 +28,6 @@
   },
   "peerDependencies": {
     "eve": "*",
-    "ai": "^7.0.105",
-    "@ai-sdk/gateway": "^4.0.100",
     "zod": "4.5.4",
     "@vercel/connect": "^2.4.1",
     "@vercel/oidc": "4.0.0"

package/roster-model.mjs

@@ -17,15 +17,6 @@ import { CONTEXT_WINDOW, selectModel } from "./bot-model.mjs";
 import { DEFAULT_SUBAGENT_CAP } from "./subagent-cap.mjs";
 import { sessionLimits } from "./session-limits.mjs";
 import { findWorkspaceRoot, loadWorkspace, parseWorkspace } from "./workspace.mjs";
-import { createGateway } from "ai";
-import { hubGatewayFetch } from "./model-credential.mjs";
-import { registryBase } from "./registry-fetch.mjs";
-
-// Hosted, a bot's model ids resolve through the owner's sign-in from the hub
-// (model-credential.mjs); elsewhere through the default gateway.
-if (process.env.HUB_TOKEN)
-  globalThis.AI_SDK_DEFAULT_PROVIDER = createGateway({ apiKey: "hub-owner-sign-in", fetch: hubGatewayFetch(`${registryBase().replace(/\/$/, "")}/api/model-credential`) });
-
 const real = process.env.ROSTER_MODELS !== "mock";
 
 export function createRosterModel({ agents, subagentCap }) {

package/schedules/classify.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/schedules/classify.js

@@ -0,0 +1,20 @@
+// main's classify schedule: gives each idle, non-deferred thread that moved
+// on a Dash entry (importance, delay) with openai/gpt-6-luna-decisions
+// through eve's `evaluate` (eve's gateway credentials). The pass: runClassify
+// in ./dash-classify.mjs; a thread whose basis hasn't changed costs nothing.
+// The hub fires it off-cron as soon as a bot's turn ends (registry/server.mjs,
+// schedules.runSoon), so a question shows on the sidebar within seconds; the
+// cron catches what that missed (a failed call, a hub restart). classifyPass
+// keeps one pass at a time in this process, whatever the hub's dispatches;
+// the pass's path filing (`filing`) runs on after it, unawaited, so neither
+// this dispatch nor the next pass waits on it.
+import { defineSchedule } from "eve/schedules";
+import { evaluate } from "eve/ai";
+import { createHub } from "./hub.mjs";
+import { classifyPass, modelClassify, runClassify } from "./dash-classify.mjs";
+export default defineSchedule({
+    cron: "*/10 * * * *",
+    async run() {
+        await classifyPass(() => runClassify(createHub(), { classify: modelClassify({ evaluate }) }));
+    },
+});

package/schedules/dash-classify.mjs

@@ -1,11 +1,12 @@
-// The classifier step of main's dash schedule (schedules/dash.ts): gives
+// main's classify schedule (schedules/classify.ts): gives
 // every idle thread a Dash entry (registry/dash.mjs: importance, delay) and
 // writes them back through POST /api/dash/entries.
 //
 //   targets   open threads (not DMs, schedule threads or archived) where no
 //             bot is working, that aren't deferred, and whose basis changed
 //             since their entry was written. An unchanged hub costs nothing.
-//   classify  (targets, snap) -> [{ threadId, importance, delay }].
+//   classify  (target, snap) -> { threadId, importance, delay } or null, all
+//             targets at once, each written as soon as it's decided.
 //             modelClassify: one evaluation per thread on the AI Gateway
 //             (openai/gpt-6-luna-decisions), two choice questions. Its
 //             answer is the classification. No model, a failed call or an
@@ -66,8 +67,11 @@ export function pathQuestion(paths) {
   return { type: "choice", instructions: "Which path covers this thread's work? Paths group threads by feature or effort at any depth. A bug, polish or follow-up belongs to its area's existing path. Prefer an existing path where it fits; choose new only when none fits.", criteria };
 }
 
-// The threads to (re)classify this tick, at most `max`: those the Dash needs
-// (no entry, or the thread moved on) first, oldest change first; then those
+// The threads to (re)classify this pass, at most `max`: those the Dash needs
+// (no entry, or the thread moved on) first, newest change first, so the
+// thread whose turn just ended (what fired this pass) is selected under the
+// cap whatever the backlog, and a thread whose answers keep failing sinks behind
+// fresh ones instead of holding the front; later passes drain the rest. Then those
 // asked only for a path, least recently classified first, so threads still
 // waiting on main's filing take turns and never crowd out the Dash.
 export function classifyTargets(snap, { max = CLASSIFY_MAX } = {}) {
@@ -87,7 +91,7 @@ export function classifyTargets(snap, { max = CLASSIFY_MAX } = {}) {
     (due ? out : pathOnly).push({ id: t.id, title: t.title, tags: t.tags ?? {}, status: t.status ?? {}, last, brief: threadBrief(t, snap), basis, entry: e ?? null, paths: path ? pathsInProject(t, snap) : null });
   }
   const at = (x) => String(x ?? "");
-  out.sort((a, b) => at(a.last.at).localeCompare(at(b.last.at)));
+  out.sort((a, b) => at(b.last.at).localeCompare(at(a.last.at)));
   pathOnly.sort((a, b) => at(a.entry?.updatedAt).localeCompare(at(b.entry?.updatedAt)) || at(a.last.at).localeCompare(at(b.last.at)));
   return [...out, ...pathOnly].slice(0, max);
 }
@@ -150,20 +154,16 @@ export async function decideThread(t, snap, { evaluate, model = DECISION_MODEL,
   return out;
 }
 
-// The schedule's classifier: per thread, the model's answer as is. No
-// `evaluate`, a failed call or an invalid answer: no entry for that thread.
-/** @param {{ evaluate?: (options: any) => Promise<any>, concurrency?: number, log?: any, model?: string, timeoutMs?: number }} [options] */
-export function modelClassify({ evaluate, concurrency = 4, log = console, ...opts } = {}) {
-  return async (targets, snap) => {
-    if (!evaluate) return [];
-    const one = async (t) => {
-      const a = await decideThread(t, snap, { evaluate, ...opts }).catch((err) => (log?.warn?.(`dash: decide ${t.id} failed, skipped: ${err?.message ?? err}`), undefined));
-      if (a === null) log?.warn?.(`dash: decide ${t.id}: invalid answer, skipped`);
-      return a ? { threadId: t.id, ...a } : null;
-    };
-    const out = [];
-    for (let i = 0; i < targets.length; i += concurrency) out.push(...(await Promise.all(targets.slice(i, i + concurrency).map(one))));
-    return out.filter(Boolean);
+// The schedule's classifier, one thread: the model's answer as is
+// ({ threadId, importance, delay, path? }), or null when there's no
+// `evaluate`, the call failed or the answer is invalid (no entry for it).
+/** @param {{ evaluate?: (options: any) => Promise<any>, log?: any, model?: string, timeoutMs?: number }} [options] */
+export function modelClassify({ evaluate, log = console, ...opts } = {}) {
+  return async (t, snap) => {
+    if (!evaluate) return null;
+    const a = await decideThread(t, snap, { evaluate, ...opts }).catch((err) => (log?.warn?.(`dash: decide ${t.id} failed, skipped: ${err?.message ?? err}`), undefined));
+    if (a === null) log?.warn?.(`dash: decide ${t.id}: invalid answer, skipped`);
+    return a ? { threadId: t.id, ...a } : null;
   };
 }
 
@@ -203,82 +203,117 @@ export function newPathNotice(threads, snap) {
 // not. The model's verdict on the brief decides; nothing here reads the
 // messages. (A pending request is posted by the rule scan, dash-rules.mjs.)
 const WAITS = { blocking: "waiting on your decision", land: "waiting on your sign-off" };
-export function askLines(entries, byId) {
-  const out = [];
-  for (const e of entries) {
-    const t = byId.get(e.threadId);
-    const was = t.entry?.delay;
-    if (was === e.delay) continue;
-    const link = `[${String(t.title ?? t.id).replace(/[[\]]/g, "")}](${t.id})`;
-    if (WAITS[e.delay]) out.push({ entry: e, line: `asks you: ${link}, ${WAITS[e.delay]}` });
-    else if (WAITS[was]) out.push({ entry: e, line: `no longer asking you: ${link}` });
-  }
-  return out;
-}
-// The notice for `entries`, or null: committed with them in one write
-// (hub.dashEntries), so a verdict and its notice are kept together or not
-// at all, and a failed write is judged afresh next pass against the entry
-// as it still is.
-export function asksNotice(entries, byId) {
-  const asks = askLines(entries, byId);
-  if (!asks.length) return null;
-  const lines = asks.map((a) => a.line);
-  const key = `asks-${createHash("sha256").update(asks.map(({ entry: e }) => `${e.threadId}:${e.delay}:${e.basis}`).sort().join(",")).digest("hex").slice(0, 32)}`;
-  return { schedule: "dash", text: `@main dash: ${lines.length === 1 ? lines[0] : `${lines.length} changes\n${lines.map((l) => `- ${l}`).join("\n")}`}`, clientId: key };
+// The notice for `e`, the new entry of target `t`, or null: committed with
+// it in one write (hub.dashEntries), so a verdict and its notice are kept
+// together or not at all, and a failed write is judged afresh next pass
+// against the entry as it still is.
+export function asksNotice(e, t) {
+  const was = t.entry?.delay;
+  if (was === e.delay) return null;
+  const link = `[${String(t.title ?? t.id).replace(/[[\]]/g, "")}](${t.id})`;
+  const line = WAITS[e.delay] ? `asks you: ${link}, ${WAITS[e.delay]}` : WAITS[was] ? `no longer asking you: ${link}` : null;
+  if (!line) return null;
+  const key = `asks-${createHash("sha256").update(`${e.threadId}:${e.delay}:${e.basis}`).digest("hex").slice(0, 32)}`;
+  return { schedule: "dash", text: `@main dash: ${line}`, clientId: key };
 }
 
-// File what the model filed: a path pick goes straight to the hub, `new`
-// goes to main in one notice (deduped by the set of threads). A failed
-// write is logged and retried next tick, as the thread is still unfiled.
-async function filePaths(hub, decided, byId, snap, log) {
-  const fresh = [];
-  const filedNow = new Set();
-  for (const d of decided) {
-    if (!d?.path) continue;
-    if (d.path === NEW_PATH) fresh.push(byId.get(d.threadId));
-    else await hub.fileThread?.(d.threadId, d.path).then(() => filedNow.add(d.threadId), (err) => log?.warn?.(`dash: file ${d.threadId} into ${d.path} failed: ${err?.message ?? err}`));
+// The `new` answers of a pass go to main in one notice per project (deduped
+// by the set of threads): not just these, every unfiled thread in their
+// projects, so main groups a project once instead of 30 at a time. Which
+// threads are unfiled is read from the hub now, after this pass's filing,
+// not from the pass's snapshot: another pass may have filed some meanwhile.
+// A failed read or post is logged; the threads are still unfiled, so they're
+// asked again.
+async function noticeNewPaths(hub, fresh, log) {
+  if (!fresh.length || !hub.post) return;
+  let snap;
+  try {
+    snap = await hub.snapshot();
+  } catch (err) {
+    return log?.warn?.(`dash: new-path notice skipped, no snapshot: ${err?.message ?? err}`);
   }
-  if (fresh.length && hub.post) {
-    // Not just this tick's `new` answers: every unfiled thread in their
-    // projects, so main groups a project once instead of 30 at a time.
-    const all = unfiledIn(snap, new Set(fresh.map((t) => t.tags?.project ?? ""))).filter((t) => !filedNow.has(t.id));
-    for (const project of new Set(all.map((t) => t.tags?.project ?? ""))) {
-      const threads = all.filter((t) => (t.tags?.project ?? "") === project);
-      const key = `paths-new-${createHash("sha256").update(threads.map((t) => t.id).sort().join(",")).digest("hex").slice(0, 32)}`;
-      await hub.post("dash", newPathNotice(threads, snap), key).catch((err) => log?.warn?.(`dash: new-path notice failed: ${err?.message ?? err}`));
-    }
+  const all = unfiledIn(snap, new Set(fresh.map((t) => t.tags?.project ?? "")));
+  for (const project of new Set(all.map((t) => t.tags?.project ?? ""))) {
+    const threads = all.filter((t) => (t.tags?.project ?? "") === project);
+    const key = `paths-new-${createHash("sha256").update(threads.map((t) => t.id).sort().join(",")).digest("hex").slice(0, 32)}`;
+    await hub.post("dash", newPathNotice(threads, snap), key).catch((err) => log?.warn?.(`dash: new-path notice failed: ${err?.message ?? err}`));
   }
-  return fresh.length;
 }
 
-// One classifier pass. Returns { written }. Each entry carries the basis its
-// target was classified from, so a thread that moved on meanwhile is looked
-// at again next tick, and clears any old reason line. Importance a human set
-// (entry.importanceBy) is never sent. classifiedAt is stamped when there was
-// nothing to do or every target was written; a skipped target or a failed
-// write leaves it, so "never classified" and "checked" stay distinct.
-/** @param {any} hub @param {{ classify?: (targets: any[], snap: any) => Promise<any[]>, max?: number, snap?: any, log?: any }} [opts] */
-export async function runClassify(hub, { classify = async () => [], max = CLASSIFY_MAX, snap = null, log = console } = {}) {
+// One classifier pass. Every target is decided at once, and each is written
+// (with its "asks you" notice) the moment its answer is in, so a thread's
+// entry never waits on another thread's call: the pass takes as long as its
+// slowest call (decideThread's timeoutMs), whatever the backlog, and the
+// thread whose turn just ended shows within its own call. Path picks are
+// filed after the pass (`filing`, see filePaths), outside it. Each entry
+// carries the basis its target was classified from, so a thread that moved
+// on meanwhile is looked at again next pass, and clears any old reason line.
+// Importance a human set (entry.importanceBy) is never sent. classifiedAt is
+// stamped when there was nothing to do or every target was written; a
+// skipped target or a failed write leaves it, so "never classified" and
+// "checked" stay distinct. Returns { written, filing }: `filing` settles when
+// the pass's path maintenance has (the schedule doesn't wait for it).
+/** @param {any} hub @param {{ classify?: (target: any, snap: any) => Promise<any>, max?: number, snap?: any, log?: any }} [opts] */
+export async function runClassify(hub, { classify = async () => null, max = CLASSIFY_MAX, snap = null, log = console } = {}) {
   const s = snap ?? (await hub.snapshot());
   const targets = classifyTargets(s, { max });
-  const byId = new Map(targets.map((t) => [t.id, t]));
   const humans = new Set((s?.humans ?? []).map((h) => h.name));
-  const decided = targets.length ? (await classify(targets, s)).filter((e) => e && byId.has(e.threadId)) : [];
-  await filePaths(hub, decided, byId, s, log);
-  const entries = decided.map(({ threadId, importance, delay }) => {
-    const own = humans.has(byId.get(threadId).entry?.importanceBy);
-    return { threadId, ...(own || importance === undefined ? {} : { importance }), delay, reason: null, basis: byId.get(threadId).basis };
-  });
-  const complete = new Set(entries.map((e) => e.threadId)).size === targets.length;
-  if (entries.length) {
-    const notice = asksNotice(entries, byId);
+  if (targets.length) log?.log?.(`dash: classifying ${targets.length} thread${targets.length === 1 ? "" : "s"}: ${targets.map((t) => t.id).join(", ")}`);
+  const picks = [];
+  const one = async (t) => {
+    const d = await classify(t, s);
+    if (!d) return 0;
+    if (d.path) picks.push([t, d.path]);
+    const own = humans.has(t.entry?.importanceBy);
+    const entry = { threadId: t.id, ...(own || d.importance === undefined ? {} : { importance: d.importance }), delay: d.delay, reason: null, basis: t.basis };
+    const notice = asksNotice(entry, t);
     try {
-      await (notice ? hub.dashEntries(entries, [], notice) : hub.dashEntries(entries));
+      await (notice ? hub.dashEntries([entry], [], notice) : hub.dashEntries([entry]));
+      return 1;
     } catch (err) {
-      log?.warn?.(`dash: classify write failed: ${err?.message ?? err}`);
-      return { written: 0 };
+      log?.warn?.(`dash: classify write for ${t.id} failed: ${err?.message ?? err}`);
+      return 0;
+    }
+  };
+  const written = (await Promise.all(targets.map(one))).reduce((a, b) => a + b, 0);
+  if (written === targets.length) await hub.dashClassified?.().catch((err) => log?.warn?.(`dash: classifiedAt not stamped: ${err?.message ?? err}`));
+  return { written, filing: filePaths(hub, picks, log) };
+}
+
+// Path maintenance after a pass, never part of it: the pass is over when its
+// entries are written and classifiedAt stamped, so the next one (a fresh
+// question) never waits on a filing request. Files each path pick, then sends the pass's `new` answers.
+// Never rejects; a failure is logged and the thread, still unfiled, is
+// asked again. A pass that starts meanwhile may ask the same thread again:
+// a second filing is refused (already filed), and the notice reads the hub's
+// state when it's built, so it never names a thread filed meanwhile.
+async function filePaths(hub, picks, log) {
+  await Promise.all(picks.filter(([, path]) => path !== NEW_PATH).map(([t, path]) => hub.fileThread?.(t.id, path).catch((err) => log?.warn?.(`dash: file ${t.id} into ${path} failed: ${err?.message ?? err}`))));
+  await noticeNewPaths(hub, picks.filter(([, path]) => path === NEW_PATH).map(([t]) => t), log);
+}
+
+// One pass at a time in this bot process, and none lost: the schedule runs
+// its pass through this. The hub can't know when a pass ends (a dispatch it
+// gave up on keeps running in eve; aborting the request doesn't stop it),
+// so the process that runs passes is the one that serializes them. A
+// dispatch that arrives during a pass returns at once and asks that pass for
+// one more round when it ends, which reads a fresh snapshot. The flag lives
+// on globalThis, which eve keeps across dispatches, and goes with the process.
+const RUNNING = Symbol.for("hub.dash.classify.running");
+/** @param {() => Promise<unknown>} pass */
+export async function classifyPass(pass) {
+  const g = /** @type {any} */ (globalThis);
+  if (g[RUNNING]) {
+    g[RUNNING].again = true;
+    return;
+  }
+  const run = (g[RUNNING] = { again: true });
+  try {
+    while (run.again) {
+      run.again = false;
+      await pass();
     }
+  } finally {
+    g[RUNNING] = undefined;
   }
-  if (complete) await hub.dashClassified?.().catch((err) => log?.warn?.(`dash: classifiedAt not stamped: ${err?.message ?? err}`));
-  return { written: entries.length };
 }

package/schedules/dash-rules.mjs

@@ -24,7 +24,7 @@ import { said, lastSaid } from "./thread-brief.mjs";
 //      approval a bot asked for). { threadId: "w:" + the pending request
 //      ids }. A bot's `waiting` status alone isn't one: it also means
 //      waiting on its own tasks. A thread that waits on the human in what was said is
-//      the classifier's call (the Dash model's verdict, see askLines in
+//      the classifier's call (the Dash model's verdict, see asksNotice in
 //      ./dash-classify.mjs), not this scan's. While a bot works there the
 //      previous entry is kept, so a request made meanwhile posts once the
 //      thread settles.

package/schedules/dash.js

@@ -9,24 +9,14 @@
 // with a note of what was skipped. Every scan whose PRs came back stamps the
 // Dash's checkedAt, so the sidebar shows "stale" while GitHub is unreachable
 // (gh logged out, offline). The tick: runDash in ./dash-run.mjs; the
-// decisions: dashScan in ./dash-rules.mjs. After the scan, the classifier
-// (./dash-classify.mjs) gives each idle, non-deferred thread that moved on a
-// Dash entry (importance, delay) with openai/gpt-6-luna-decisions through
-// eve's `evaluate` (eve's gateway credentials); its failure never fails the tick.
+// decisions: dashScan in ./dash-rules.mjs. The threads' Dash entries are
+// main's classify schedule (./classify.ts).
 import { defineSchedule } from "eve/schedules";
 import { createHub } from "./hub.mjs";
 import { runDash } from "./dash-run.mjs";
-import { evaluate } from "eve/ai";
-import { modelClassify, runClassify } from "./dash-classify.mjs";
 export default defineSchedule({
     cron: "*/10 * * * *",
     async run() {
-        const hub = createHub();
-        try {
-            await runDash(hub);
-        }
-        finally {
-            await runClassify(hub, { classify: modelClassify({ evaluate }) }).catch((err) => console.warn(`dash: classify skipped: ${err?.message ?? err}`));
-        }
+        await runDash(createHub());
     },
 });

package/tools/artifact_list.js

@@ -1,19 +1,17 @@
-// The `artifact_list` tool: the artifacts this session owns (its state), or,
-// with all: true, every artifact the registry knows and who owns each.
+// The `artifact_list` tool: the artifacts this session published, or, with
+// all: true, every artifact the hub knows and who owns each.
 import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
-import { artifacts } from "../artifacts/state.js";
 const brief = (a) => ({ id: a.id, version: a.version, status: a.status, title: a.card?.title, alias: a.alias, updatedAt: a.updatedAt, ...(a.owner ? { owner: a.owner } : {}) });
 export default defineTool({
     description: "List the artifacts you own (id, version, status, stable URL). all: true lists every artifact in the workspace with its owner.",
     inputSchema: z.object({ all: z.boolean().optional().describe("Every artifact the hub knows, not just yours.") }),
-    async execute({ all }) {
-        if (!all)
-            return { artifacts: Object.values(artifacts.get()).map(brief) };
-        const res = await registryFetch(`/api/artifacts`).catch(() => null);
-        if (!res?.ok)
-            throw new Error(`the registry didn't answer (${res?.status ?? "unreachable"})`);
-        return { artifacts: ((await res.json()).artifacts ?? []).map(brief) };
+    async execute({ all }, ctx) {
+        const res = await registryFetch(`/api/artifacts`);
+        if (!res.ok)
+            throw new Error(`GET /api/artifacts: ${(await res.json().catch(() => ({}))).error ?? res.status}`);
+        const every = ((await res.json()).artifacts ?? []);
+        return { artifacts: (all ? every : every.filter((a) => a.owner?.sessionId === ctx.session.id)).map(brief) };
     },
 });

package/tools/artifact_publish.js

@@ -1,23 +1,19 @@
-// The `artifact_publish` tool: builds and deploys the next version of an
-// artifact (artifacts/core.mjs) and moves its stable alias to it. The session
-// that publishes owns the artifact; the result carries the record, which the
-// registry folds into the thread's card and its artifact index.
+// The `artifact_publish` tool: builds the next version of an artifact in this
+// session's sandbox and has the hub deploy it and move its stable link
+// (artifacts/core.mjs). The result carries the hub's record; the hub puts its
+// card on this turn's reply.
 import { defineTool } from "eve/tools";
 import { z } from "zod";
-import { artifactId, latestRecord, publish, TYPES } from "../artifacts/core.mjs";
-import { artifacts } from "../artifacts/state.js";
+import { publish, TYPES } from "../artifacts/core.mjs";
 export default defineTool({
-    description: "Publish the next version of an artifact: a versioned static site you own and keep current, such as a change explainer for a PR or stack. Builds it from `source`, deploys it, moves its stable URL to the new version, and shows a card in this thread (the same card updates on every later version). Takes a few minutes. Types: change-explainer (source: { fixture: <fixture dir>, repo: <git checkout>, scip?: <index.scip>, branch?: <ref> }).",
+    description: "Publish the next version of an artifact: a versioned static site you own and keep current, such as a change explainer for a PR or stack. Builds it from `source` in your sandbox, deploys it, moves its stable URL to the new version, and shows a card in this thread (the same card updates on every later version). Takes a few minutes. Types: change-explainer (source: { fixture: <fixture dir>, repo: <git checkout>, scip?: <index.scip>, branch?: <ref> }).",
     inputSchema: z.object({
         type: z.enum(Object.keys(TYPES)).describe("Artifact type."),
         key: z.string().regex(/^[\w.-]{1,40}$/).describe("Stable key within the type, e.g. the fixture id `thr_05a3` or `eve-pr-4342`. Same key = same artifact, next version."),
         source: z.record(z.string(), z.unknown()).describe("What the type builds from (see the description)."),
     }),
-    async execute({ type, key, source }) {
-        const id = artifactId(type, key);
-        const prior = await latestRecord(id, artifacts.get());
-        const record = await publish({ type, key, source }, prior);
-        artifacts.update((all) => ({ ...all, [id]: record }));
-        return { artifact: record, note: `published ${id} v${record.version}: ${record.alias}` };
+    async execute({ type, key, source }, ctx) {
+        const record = await publish({ type, key, source }, { sandbox: await ctx.getSandbox(), sessionId: ctx.session.id });
+        return { artifact: record, note: `published ${record.id} v${record.version}: ${record.alias}` };
     },
 });

package/tools/artifact_status.js

@@ -1,22 +1,20 @@
 // The `artifact_status` tool: whether a published artifact still describes its
-// source (the type decides). Updates the record's status, so the card and the
-// registry's index show it too.
+// source (the type decides, reading the repo in this session's sandbox). The
+// hub applies the result to the version it checked, so the card shows it too.
 import { defineTool } from "eve/tools";
 import { z } from "zod";
-import { latestRecord, status } from "../artifacts/core.mjs";
-import { artifacts } from "../artifacts/state.js";
+import { registryRecord, status } from "../artifacts/core.mjs";
 export default defineTool({
     description: "Check whether an artifact you published is still current: after you push, rebase or force-push, when its base or a stacked parent moves, and before asking for review. Returns fresh or stale with reasons; when stale, publish again with artifact_publish.",
     inputSchema: z.object({
         id: z.string().describe("Artifact id, `<type>:<key>`, e.g. change-explainer:thr_05a3 (artifact_list shows yours)."),
     }),
-    async execute({ id }) {
-        const record = await latestRecord(id, artifacts.get());
+    async execute({ id }, ctx) {
+        const record = await registryRecord(id);
         if (!record)
             throw new Error(`no artifact ${id}; artifact_list shows the ones this session owns`);
-        const result = await status(record);
-        const next = { ...record, status: result.status, checkedAt: new Date().toISOString() };
-        artifacts.update((all) => ({ ...all, [id]: next }));
-        return { artifact: next, status: result.status, reasons: result.reasons };
+        const result = await status(record, { sandbox: await ctx.getSandbox() });
+        const checked = { id: record.id, version: record.version, status: result.status, checkedAt: new Date().toISOString() };
+        return { artifact: checked, status: result.status, reasons: result.reasons };
     },
 });

package/artifacts/state.d.ts

@@ -1 +0,0 @@
-export declare const artifacts: any;

package/artifacts/state.js

@@ -1,5 +0,0 @@
-// The owning session's artifact records, id -> latest record. Durable eve
-// session state: it survives restarts like the rest of the session.
-import { defineState } from "eve/context";
-import { STATE_NAME } from "./core.mjs";
-export const artifacts = defineState(STATE_NAME, () => ({}));

package/model-credential.mjs

@@ -1,44 +0,0 @@
-// Hosted bots resolve model ids through the owner's refreshable Vercel sign-in.
-// HUB_TOKEN identifies a hosted bot; the credential endpoint is on its registry.
-// The hub owns expiration and refresh; Gateway rejection invalidates our cache.
-import { createHash } from "node:crypto";
-import { GatewayAuthenticationError } from "@ai-sdk/gateway";
-import { registryHeaders } from "./registry-fetch.mjs";
-
-/**
- * The fetch the gateway sends through: the hub's current token and team on
- * each request, and on a 401, one more try with the token the hub hands out
- * after it is told (by sha256) which token Gateway refused.
- */
-export function hubGatewayFetch(credentialUrl, fetchFn = (...a) => globalThis.fetch(...a), now = Date.now) {
-  let current;
-  const credential = async (rejected) => {
-    if (!rejected && current && now() < current.expiresAt) return current;
-    const headers = registryHeaders();
-    if (rejected) headers["x-rejected-token-sha256"] = createHash("sha256").update(rejected).digest("hex");
-    const response = await fetchFn(credentialUrl, { headers });
-    if (response.status === 401) {
-      const { error } = await response.json();
-      throw new GatewayAuthenticationError({ message: error });
-    }
-    if (!response.ok) throw new Error(`model credential from the hub: HTTP ${response.status} ${await response.text()}`);
-    return (current = await response.json());
-  };
-  return async (input, init) => {
-    const headers = new Headers(init?.headers);
-    const send = async (c) => {
-      headers.set("authorization", `Bearer ${c.token}`);
-      headers.set("x-vercel-ai-gateway-team", c.teamId);
-      const response = await fetchFn(input, { ...init, headers });
-      if (response.status === 401) current = undefined;
-      return response;
-    };
-    const first = await credential();
-    const response = await send(first);
-    if (response.status !== 401) return response;
-    // A streamed body can't be sent twice, but its rejected token is dropped.
-    if (init?.body != null && typeof init.body !== "string") return response;
-    await response.body?.cancel();
-    return send(await credential(first.token));
-  };
-}