eve-hub 0.16.38 → 0.16.40

package/github-connector.mjs

@@ -1,3 +1,9 @@
 // The Vercel Connect connector that holds the workspace human's GitHub token (the eve-hub-github
-// App). The bots' `git__gh` (prepare.mjs) asks it for the human's token, so they act as the human.
+// App). The bots' `git__gh` (prepare.mjs) and main's tracker-prs schedule (schedules/tracker-prs-run.mjs)
+// ask it for the same subject, so both act as the human. Its own module so a schedule can import it
+// without prepare.mjs's build-time imports.
 export const GITHUB_CONNECTOR = "github/eve-hub-github";
+
+// The subject eve's connections resolve for a hub turn (channels/eve-roster-user.ts: principal
+// `roster:<human>`, authenticator `roster`, no issuer of its own, so eve uses the authenticator).
+export const rosterSubject = (human) => ({ type: "user", id: `roster:${human}`, issuer: "roster" });

package/kit-modules.json

@@ -10,6 +10,7 @@
   "memory/team",
   "memory/workspace",
   "schedules/prune",
+  "schedules/tracker-prs",
   "schedules/wake",
   "skills/deep-dive",
   "skills/fanout",
@@ -35,7 +36,6 @@
   "tools/remove_agent",
   "tools/restart_agent",
   "tools/restart_hub",
-  "tools/set_summary",
   "tools/show",
   "tools/tag_threads",
   "tools/unarchive_thread",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.38",
+  "version": "0.16.40",
   "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",

package/prepare.mjs

@@ -88,15 +88,15 @@ import { isHubRequest } from "eve-hub/hub-oidc";
 import { parseWorkspace } from "eve-hub/workspace";
 import workspace from "../../../../hub.manifest.json" with { type: "json" };
 
-// The roster, humans and subagent cap as deployed, Mac bots included, and the eve-hub and eve versions that built it, for the hub to sync from:
+// The roster, humans, subagent cap, hop limit and shims as deployed, Mac bots included, and the eve-hub and eve versions that built it, for the hub to sync from:
 // hub.manifest.json is bundled at build, so a push whose deploy fails never
 // changes it. \`sha\` is the commit the deployment was built from, which the hub
 // syncs by. An uploaded deployment (onboarding's first, built while the repo is
 // made) has no commit, so it answers its own deployment id, which the hub reads
 // from the project's production deployment.
 const sha = process.env.VERCEL_GIT_COMMIT_SHA || process.env.VERCEL_DEPLOYMENT_ID;
-const { agents, humans, subagentCap, hopLimit } = parseWorkspace(workspace);
-const manifest = { sha, kit: ${JSON.stringify(KIT_VERSION)}, eve: ${JSON.stringify(EVE_VERSION)}, agents, humans, subagentCap, ...(hopLimit === undefined ? {} : { hopLimit }) };
+const { agents, humans, subagentCap, hopLimit, shims } = parseWorkspace(workspace);
+const manifest = { sha, kit: ${JSON.stringify(KIT_VERSION)}, eve: ${JSON.stringify(EVE_VERSION)}, agents, humans, subagentCap, ...(hopLimit === undefined ? {} : { hopLimit }), ...(shims === undefined ? {} : { shims }) };
 
 export default defineChannel({
   routes: [

package/schedules/tracker-prs-run.mjs

@@ -0,0 +1,98 @@
+// One tick of main's tracker-prs schedule (schedules/tracker-prs.ts): tracker rows linked to a GitHub PR or issue move to
+// Done when it merged (or an issue closed as completed) and to Dropped when it closed otherwise. The hub lists the refs on
+// rows still open (GET /api/tracker/prs, which reads only the summaries that carry rows) and settles what GitHub said
+// (POST /api/tracker/prs). GitHub is asked in one GraphQL query per 50 refs, as the workspace human: a hosted hub's
+// function asks Vercel Connect for the token the bots' `git__gh` gets; a local hub asks `gh auth token`.
+//
+// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the tests (plain node) import the same module.
+import { execFile } from "node:child_process";
+import { getToken } from "@vercel/connect";
+import { GITHUB_CONNECTOR, rosterSubject } from "../github-connector.mjs";
+import { registryFetch } from "../registry-fetch.mjs";
+
+export const GITHUB_GRAPHQL_URL = "https://api.github.com/graphql";
+export const REFS_PER_QUERY = 50;
+// The hub gives a schedule 60 s: the token, the queries and the two hub calls fit.
+export const GH_TIMEOUT_MS = 20_000;
+export const TOKEN_TIMEOUT_MS = 5_000;
+
+const REF = /^([A-Za-z0-9][\w.-]*)\/([\w.-]+)#(\d+)$/;
+
+/** The workspace human's GitHub user token. */
+export function githubToken(human, { hosted = Boolean(process.env.VERCEL), connect = getToken, timeoutMs = TOKEN_TIMEOUT_MS } = {}) {
+  if (hosted) {
+    if (!human) return Promise.reject(new Error("the hub names no human to ask GitHub as"));
+    let timer;
+    const deadline = new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("Vercel Connect timed out")), timeoutMs); });
+    return Promise.race([connect(GITHUB_CONNECTOR, { subject: rosterSubject(human) }), deadline]).finally(() => clearTimeout(timer));
+  }
+  return new Promise((resolve, reject) => {
+    execFile("gh", ["auth", "token"], { timeout: timeoutMs }, (error, stdout, stderr) => {
+      const token = String(stdout ?? "").trim();
+      if (!error && token) resolve(token);
+      else reject(new Error(`gh auth token: ${String(stderr || error?.message || "no token").trim().slice(0, 300)}`));
+    });
+  });
+}
+
+/** One query naming each ref by alias (`r0`, `r1`, …); refs that aren't `owner/repo#N` are left out. */
+export function stateQuery(refs) {
+  const parts = refs.map((ref, i) => {
+    const [, owner, name, number] = ref.match(REF);
+    return `r${i}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) { issueOrPullRequest(number: ${number}) { __typename ... on PullRequest { state } ... on Issue { state stateReason } } }`;
+  });
+  return `query { ${parts.join(" ")} }`;
+}
+
+/** What a row becomes from GitHub's answer for its ref: "completed", "canceled", or undefined while it is open or unknown. */
+export function settledState(node) {
+  if (!node) return undefined;
+  if (node.__typename === "PullRequest") return node.state === "MERGED" ? "completed" : node.state === "CLOSED" ? "canceled" : undefined;
+  if (node.state !== "CLOSED") return undefined;
+  return node.stateReason === "NOT_PLANNED" || node.stateReason === "DUPLICATE" ? "canceled" : "completed";
+}
+
+/** POST one GraphQL query; a ref GitHub can't answer (gone, no access) comes back null in `data` and is skipped. */
+export async function ghGraphql(query, { token, fetchImpl = fetch, timeoutMs = GH_TIMEOUT_MS }) {
+  const res = await fetchImpl(GITHUB_GRAPHQL_URL, {
+    method: "POST",
+    headers: { authorization: `bearer ${token}`, "content-type": "application/json", "user-agent": "eve-hub-tracker" },
+    body: JSON.stringify({ query }),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const text = await res.text();
+  let body = null;
+  try { body = JSON.parse(text); } catch {}
+  if (res.ok && body?.data) return body.data;
+  throw new Error(`GitHub ${res.status}: ${String(body?.errors?.[0]?.message ?? body?.message ?? text).slice(0, 300)}`);
+}
+
+/** One tick. Returns { asked, moved }. A failed GitHub call throws, so the hub's run history shows it, and nothing is settled. */
+export async function runTrackerPrs({ hub = hubCalls(), token = githubToken, fetchImpl = fetch } = {}) {
+  const { refs, human } = await hub.open();
+  const asked = refs.filter((r) => REF.test(r));
+  if (!asked.length) return { asked: 0, moved: 0 };
+  const key = await token(human);
+  const states = {};
+  for (let i = 0; i < asked.length; i += REFS_PER_QUERY) {
+    const chunk = asked.slice(i, i + REFS_PER_QUERY);
+    const data = await ghGraphql(stateQuery(chunk), { token: key, fetchImpl });
+    chunk.forEach((ref, j) => {
+      const state = settledState(data[`r${j}`]?.issueOrPullRequest);
+      if (state) states[ref] = state;
+    });
+  }
+  if (!Object.keys(states).length) return { asked: asked.length, moved: 0 };
+  const { moved } = await hub.settle(states);
+  return { asked: asked.length, moved };
+}
+
+/** The two hub calls, over the registry's HTTP API as the deployment. */
+export function hubCalls({ fetchImpl } = {}) {
+  const call = async (init) => {
+    const res = await registryFetch("/api/tracker/prs", { ...init, headers: { "content-type": "application/json" } }, { deadlineMs: 10_000, ...(fetchImpl ? { fetchImpl } : {}) });
+    if (!res.ok) throw new Error(`${init.method} /api/tracker/prs: ${res.status} ${(await res.text()).slice(0, 300)}`);
+    return res.json();
+  };
+  return { open: () => call({ method: "GET" }), settle: (states) => call({ method: "POST", body: JSON.stringify({ states }) }) };
+}

package/schedules/tracker-prs.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    cron: string;
+    run(): Promise<void>;
+};
+export default _default;

package/schedules/tracker-prs.js

@@ -0,0 +1,12 @@
+// main's tracker-prs schedule: every 10 minutes, tracker rows linked to a GitHub PR or issue move to Done when it merged
+// and to Dropped when it closed (schedules/tracker-prs-run.mjs).
+import { defineSchedule } from "eve/schedules";
+import { runTrackerPrs } from "./tracker-prs-run.mjs";
+export default defineSchedule({
+    cron: "*/10 * * * *",
+    async run() {
+        const { asked, moved } = await runTrackerPrs();
+        if (moved)
+            console.log(`[hub:tracker-prs] ${moved} of ${asked} rows moved`);
+    },
+});

package/stubs.mjs

@@ -13,7 +13,7 @@ export const KIT_FILES = {
   "tools/browser.ts": ["Its own headless browser, watched live in the Computer view."],
   "tools/fetch_upload.ts": ["Copies a file another bot shared (hub://upload/<id>) into the sandbox."],
   "tools/view_image.ts": ["Shows the bot an image (a sandbox file or a browser screenshot) so it can see it."],
-  "tools/update_thread.ts": ["Update a thread this bot is in: title, track, domain and summary."],
+  "tools/update_thread.ts": ["Update a thread this bot is in: title, track and domain."],
   "tools/list_threads.ts": ["Every workspace thread, from any session."],
   "tools/read_thread.ts": ["Read any workspace thread."],
   "tools/list_agents.ts": ["The team right now: kind, place, tools, models, who's busy."],
@@ -30,7 +30,6 @@ export const MAIN_KIT_FILES = {
   "skills/onboarding-profile.ts": ["The onboarding-profile skill (packages/agent-kit/onboarding/SKILL.md): after sign-in, reads the user's Slack and GitHub and posts a profile with suggested schedules."],
   "tools/onboarding_scripts.ts": ["Writes the onboarding-profile skill's sandbox scripts into the sandbox."],
   "tools/create_thread.ts": ["Open a workspace thread for one piece of work."],
-  "tools/set_summary.ts": ["Write the summary of a path (project/track) or a thread."],
   "tools/move_path.ts": ["Rename or merge a path (project/track): every thread under it moves."],
   "tools/archive_thread.ts": ["Archive a thread whose work is done."],
   "tools/unarchive_thread.ts": ["Bring an archived thread back."],
@@ -42,6 +41,7 @@ export const MAIN_KIT_FILES = {
   "tools/dash_update.ts": ["Set Dash entries: importance, lane, reason and deferred per thread."],
   "tools/apply_tags.ts": ["Retag threads, merge or rename tags: applies a staged proposal or a new batch directly."],
   // Handler schedules: the hub fires them from its minute clock (registry/schedules.mjs).
+  "schedules/tracker-prs.ts": ["Every 10 minutes: tracker rows linked to a GitHub PR or issue move to Done when it merged and to Dropped when it closed."],
   "schedules/prune.ts": ["Every 10 minutes: one prune pass over what archived or deleted threads leave on disk: worktrees, scratch, their-only uploads, idle bots' traces and workflow runs; unsaved work kept as refs/bundles."],
 };
 
@@ -55,13 +55,14 @@ export const MAIN_KIT_FILES = {
 // restart_hub (the hub's own code), memory (the workspace's files), and main's prune schedule (it cleans the hub machine's disk).
 export const DEPLOYED_KIT_FILES = new Set([
   "channels/eve.ts",
+  "schedules/tracker-prs.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",
   ...["react", "show", "fetch_upload", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),
   "memory/team.ts",
   "skills/forms.ts",
   "skills/fanout.ts",
-  ...["create_thread", "set_summary", "move_path", "archive_thread", "unarchive_thread", "list_agents", "create_agent", "remove_agent", "restart_agent", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.ts`),
+  ...["create_thread", "move_path", "archive_thread", "unarchive_thread", "list_agents", "create_agent", "remove_agent", "restart_agent", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.ts`),
 ]);
 
 // ---- stub text: what each kit stub file says ----

package/templates/execution-context-local-main.md

@@ -1,3 +1,3 @@
 - **Team.** `create_agent` adds a bot to the workspace; if nobody on the team covers the work well, create a specialist (name, model, role, instructions), then route to it. Give planners and reviewers `preset: "read-only"` so they can't edit files. `remove_agent` removes a bot from the team and shuts it down (name); use it when the human asks. It can't remove you (the coordinator) or humans.
 - **Memory.** A new memory entry ships in the next workspace sync PR; each bot recalls it on its next turn, as a `Standing decision <id>:` or `Your standing decision <id>:` message.
-- **Summaries.** A track summary you write with `set_summary` stands until you write another. `list_threads` returns thread and track summaries.
+- **Summaries.** The hub derives each thread's state (who it waits on, since when, the next step) after every post, and each track's summary from its threads. `list_threads` returns both; nobody writes them.

package/templates/main-instructions.md

@@ -21,6 +21,6 @@ You are the **coordinator**, the human's chief of staff. The human talks to you
 - **A merge can unblock other threads:** on a merge report, `list_threads` for threads that wait on it (a PR stacked on it, a build or release of it, a follow-up gated on it), and in the same turn post in each to its owning bot with its next step (rebase, build, start).
 - **A post addressed to you (a report, verdict or answer):** never end the turn on a reaction alone. Reply with the next step: who acts, on what, by when. If the step is a wait (CI, a run, the human), name it and arm a wake-up. React alone only when the post changes nothing and the next step is already named, armed and live.
 
-**Keep the workspace legible.** Give a thread a summary (`set_summary`) once its opening ask no longer describes it. Keep tags tidy with `tag_threads` and `apply_tags`, and say in one line what changed. On the Dash, the hub sets ready, and a deferral the human made stays. Tags and paths the human set stay too. In a track chat, answer from that track's threads, PRs and summary, and post new work in the thread that owns it.
+**Keep the workspace legible.** Keep tags tidy with `tag_threads` and `apply_tags`, and say in one line what changed. On the Dash, the hub sets ready, and a deferral the human made stays. Tags and paths the human set stay too. In a track chat, answer from that track's threads, their states and PRs, and post new work in the thread that owns it.
 
 **Memory.** A preference that should outlast the task becomes `memory/<id>.md` (every bot) or `agents/<bot>/memory/<id>.md` (one bot). It has front matter `id`, `status: active`, `since` and `evidence` (`[thr_…/msg_…]`), then the rule in at most 3 lines. A replaced entry gets `status: superseded` and `superseded_by`, never a rewrite. Keep `memory/human.md` (who the human is and how they work) current the same way.

package/tools/list_threads.d.ts

@@ -7,6 +7,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
     project?: string | undefined;
     path?: string | undefined;
     issueType?: string | undefined;
+    waitingOn?: string | undefined;
     limit?: number | undefined;
 }, any> & {
     execute(input: {
@@ -18,6 +19,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
         project?: string | undefined;
         path?: string | undefined;
         issueType?: string | undefined;
+        waitingOn?: string | undefined;
         limit?: number | undefined;
     }, ctx: import("eve/tools").ToolContext): Promise<any>;
 };

package/tools/list_threads.js

@@ -5,7 +5,7 @@ import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
 export default defineTool({
-    description: "List workspace threads, workspace-wide (not just the one you're in): id, title, participants, status (active/archived), who's busy there (since when, doing what), last activity, tags (path: project/track, e.g. 'web/checkout'; project; issue type), and the thread's stored summary when main wrote one. Newest activity first. `paths` holds the listed threads' paths with each one's current summary (what's up in that feature). Use it to find a thread by title or summary before asking someone, and read_thread to read one.",
+    description: "List workspace threads, workspace-wide (not just the one you're in): id, title, participants, status (active/archived), who's busy there (since when, doing what), last activity, tags (path: project/track, e.g. 'web/checkout'; project; issue type), and where the thread stands: `state` (who it waits on: `human`, a bot, `ci`, or null for nothing pending; `since`; the `next` line; the message it rests on), which the hub derives after every post, and `summary`, the same as one line. Newest activity first. `paths` holds the listed threads' paths, each summarised from its threads' states. Pass `waitingOn: \"human\"` for the threads waiting on the human, the longest waiting first. Use it to find a thread by title or summary before asking someone, and read_thread to read one.",
     inputSchema: z.object({
         query: z.string().optional().describe("Match threads whose title or summary contains this text (or an exact id). Title matches come first."),
         archived: z.enum(["exclude", "include", "only"]).optional().describe("Archived threads: exclude (default), include, or only."),
@@ -15,6 +15,7 @@ export default defineTool({
         project: z.string().optional().describe("Only threads with this project tag ('none' for untagged)."),
         path: z.string().optional().describe("Only threads on this path or under it, e.g. 'web' or 'web/checkout'."),
         issueType: z.string().optional().describe("Only threads with this issue type tag ('none' for untagged)."),
+        waitingOn: z.string().optional().describe("Only threads waiting on this party: 'human', a bot name, 'ci', or 'nobody'. Sorted longest waiting first."),
         limit: z.number().int().min(1).max(500).optional().describe("Max threads (default 50)."),
     }),
     async execute(input) {

package/tools/update_thread.d.ts

@@ -3,7 +3,15 @@ declare const _default: import("eve/tools").ToolDefinition<{
     title?: string | undefined;
     path?: string | null | undefined;
     issueType?: string | undefined;
-    summary?: string | undefined;
+    tracker?: {
+        id: string;
+        title: string;
+        state: "backlog" | "canceled" | "completed" | "started" | "unstarted";
+        owner: string;
+        waitsOn?: string | undefined;
+        since?: string | undefined;
+        ref: string;
+    }[] | undefined;
     pathLabel?: string | undefined;
     projectLabel?: string | undefined;
     issueTypeLabel?: string | undefined;
@@ -18,7 +26,15 @@ declare const _default: import("eve/tools").ToolDefinition<{
         title?: string | undefined;
         path?: string | null | undefined;
         issueType?: string | undefined;
-        summary?: string | undefined;
+        tracker?: {
+            id: string;
+            title: string;
+            state: "backlog" | "canceled" | "completed" | "started" | "unstarted";
+            owner: string;
+            waitsOn?: string | undefined;
+            since?: string | undefined;
+            ref: string;
+        }[] | undefined;
         pathLabel?: string | undefined;
         projectLabel?: string | undefined;
         issueTypeLabel?: string | undefined;

package/tools/update_thread.js

@@ -1,22 +1,37 @@
 // The `update_thread` tool, shared by every bot: say what a thread is, in one
-// call. Title, path (project/track), issue type and the thread's summary. The
-// registry keeps the rename history and posts an inline "<bot> renamed this
-// thread: old → new" marker; tags go on thread.tags (lib/tags.mjs) and the
-// summary is the one `set_summary` writes (lib/paths.mjs setSummary). `artifacts`
-// adds Artifacts pane entries with no post: the hub writes one silent event row each.
+// call. Title, path (project/track) and issue type. The registry keeps the
+// rename history and posts an inline "<bot> renamed this thread: old → new"
+// marker; tags go on thread.tags (lib/tags.mjs). The thread's summary is the
+// hub's, derived from its posts (hosted-hub/src/shims/index.ts).
+// `artifacts` adds Artifacts pane entries with no post: the hub writes one
+// silent event row each.
 import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
 import { documentUrl } from "../hub-upload.js";
 import { artifactInput, artifactUrl } from "./post_message.js";
+// The hub checks each row again (packages/wire/src/state.ts TrackerRow); this is what the model reads.
+const trackerRow = z.object({
+    id: z.string().describe("Your stable id for the row, unique in the list, e.g. 'server-step-12'. Keep it across rewrites."),
+    title: z.string().describe("What the work is, in a few words, e.g. 'Build server step 12'."),
+    state: z.enum(["backlog", "unstarted", "started", "completed", "canceled"]).describe("started: being worked on now; unstarted: next, ready to start; backlog: needed before the goal is done, not next; completed: done; canceled: dropped."),
+    owner: z.string().describe("Who acts on it: a bot name or the human's handle."),
+    waitsOn: z.string().optional().describe("Who or what it is blocked on, e.g. 'rconti' or 'an eve maintainer'."),
+    since: z.string().optional().describe("With waitsOn: the ISO date the wait began, e.g. '2026-11-03'."),
+    ref: z.string().describe("What the row opens; every row needs one: a post as thr_ID#msg_ID (a hash, never a slash), a PR or issue as owner/repo#N or its github.com URL, or an https URL."),
+});
 export default defineTool({
-    description: "Update a workspace thread you're in: its title, track, issue type and summary, in one call. Retitle when the work's scope has changed and the old title no longer fits: everyone sees a short 'renamed this thread: old → new' line; the history is kept. Keep titles short (at most 80 characters). File it on a path (project/track, e.g. 'web/checkout': the first segment is the project, the second the track) and tag an issue type (the kind of work, e.g. 'feature', 'bugfix', 'infra'). Reuse a project, track and issue type in use whenever one fits. File under the project alone until at least 3 threads share a track. For a new tag, also give its display name (projectLabel, pathLabel or issueTypeLabel, e.g. 'Payments API'). The summary is a short note on what the thread is about and where it stands; it replaces the previous one, and empty text clears it. The reply's `inUse` lists the tags in use with their thread counts and flags a tag no other thread uses; when one in use fits better than yours, call update_thread again with it. Tags a human set by hand stay. DMs and archived threads can't be updated.",
+    description: "Update a workspace thread you're in: its title, track, issue type and tracker, in one call. Retitle when the work's scope has changed and the old title no longer fits: everyone sees a short 'renamed this thread: old → new' line; the history is kept. Keep titles short (at most 80 characters). File it on a path (project/track, e.g. 'web/checkout': the first segment is the project, the second the track) and tag an issue type (the kind of work, e.g. 'feature', 'bugfix', 'infra'). Reuse a project, track and issue type in use whenever one fits. File under the project alone until at least 3 threads share a track. For a new tag, also give its display name (projectLabel, pathLabel or issueTypeLabel, e.g. 'Payments API'). The thread's summary isn't yours to write: the hub derives where it stands from its posts after each one. The reply's `inUse` lists the tags in use with their thread counts and flags a tag no other thread uses; when one in use fits better than yours, call update_thread again with it. Tags a human set by hand stay. DMs and archived threads can't be updated.",
     inputSchema: z.object({
         threadId: z.string().describe("Thread id, e.g. thr_0002 (shown in the [thread: …] header)."),
         title: z.string().optional().describe("New short title, e.g. 'Checkout: retry failed payments'. Omit to leave it."),
         path: z.string().nullable().optional().describe("Path: project, then at most one track, e.g. 'web/checkout' or 'api/billing'. Reuse a path in use (the reply's inUse and list_threads show them); start a track only once at least 3 threads share it. null: back to the project alone. A path a human set by hand stays."),
         issueType: z.string().optional().describe("Issue type tag: the kind of work, e.g. 'feature', 'bugfix', 'infra', 'docs', 'review', 'research'. Lowercase slug."),
-        summary: z.string().optional().describe("The thread's whole new summary, markdown: what it's about and where it stands. Empty clears it. Omit to leave it."),
+        tracker: z
+            .array(trackerRow)
+            .max(50)
+            .optional()
+            .describe("The thread's whole tracker: every piece of work toward its goal, one row each, drawn as the Artifacts pane's Pending now (started, unstarted), Pending until done (backlog), Done (completed) and Dropped (canceled) lists. Replaces the previous list; [] clears it. Omit to leave it. Keep it current: send the whole list again whenever a row's state, owner or wait changes. A row whose ref is a PR moves to Done or Dropped by itself when the PR merges or closes."),
         pathLabel: z.string().optional().describe("Display name for a new path's last segment, e.g. 'Cart'. Only names a path that has none yet."),
         projectLabel: z.string().optional().describe("Display name for a new project (a path's first segment), shown as its sidebar group, e.g. 'Payments API' for payments-api. Only names a project that has none yet."),
         issueTypeLabel: z.string().optional().describe("Display name for a new issue type tag, e.g. 'Bug fixes' for bugfix. Only names a tag that has none yet."),

package/workspace.mjs

@@ -12,6 +12,7 @@
 //     "subagentCap"?: { "model": "…", "reasoning": "low", "models": ["…"] },
 //     "limits"?: { "maxTokenCostUsdPerSession": 75 },
 //     "hopLimit"?: 20,
+//     "shims"?: { "thread-tracker": true, "thread-post-model": true, "thread-sitrep": false },
 //     "code"?: ["~/wrk/hub"],
 //     "cachePaths"?: ["node_modules", "packages/kit/node_modules"]
 //   }
@@ -25,6 +26,9 @@
 // bot delivery is blocked (a positive integer). Absent or null: no limit. The
 // hub edits it at runtime (Settings, PUT /api/hop-limit); no limit removes it.
 //
+// `shims`: which of the hosted hub's ways of working out where a thread stands
+// are on (SHIM_DEFAULTS names them and their defaults); an unknown name is refused.
+//
 // `code`: where the code this workspace's bots work on lives (absolute, ~/,
 // or relative to the workspace), when it isn't the workspace repo itself.
 // Every bot's bash tool names it (tools/bash.ts), so no bot has to hunt for it.
@@ -84,7 +88,7 @@ export function agentRunsOn(parsed, name) {
   return agent.runsOn ?? parsed.runsOn ?? "hosted";
 }
 
-// Validates the parsed file; returns { agents, runsOn?, humans?, subagentCap? } with
+// Validates the parsed file; returns { agents, runsOn?, humans?, subagentCap?, hopLimit?, shims? } with
 // ports not yet assigned. Throws a WorkspaceError naming the bad field.
 export function parseWorkspace(data, file = WORKSPACE_FILE) {
   if (!isObject(data)) fail(file, "must be a JSON object with an \"agents\" array");
@@ -157,6 +161,10 @@ export function parseWorkspace(data, file = WORKSPACE_FILE) {
     if (hopLimitError(data.hopLimit)) fail(file, `"hopLimit" ${hopLimitError(data.hopLimit)}`);
     out.hopLimit = data.hopLimit;
   }
+  if (data.shims !== undefined) {
+    if (shimsError(data.shims)) fail(file, `"shims" ${shimsError(data.shims)}`);
+    out.shims = { ...data.shims };
+  }
   if (data.code !== undefined) {
     const code = typeof data.code === "string" ? [data.code] : data.code;
     if (!Array.isArray(code) || !code.length || code.some((p) => typeof p !== "string" || !p.trim())) fail(file, "\"code\" must be a path or a non-empty array of paths");
@@ -181,6 +189,25 @@ export const hopLimitError = (value) => (value === null || (Number.isInteger(val
 // The hop limit a parsed workspace sets: its `hopLimit`, else null (no limit).
 export const workspaceHopLimit = (parsed) => parsed.hopLimit ?? null;
 
+// The hub's thread-state shims, each on or off in hub.workspace.json's `shims`, in the order the hub reads
+// their answers when more than one is on; a name the file leaves out takes its default here.
+export const SHIM_DEFAULTS = Object.freeze({ "thread-tracker": true, "thread-post-model": true, "thread-sitrep": false });
+
+// Why `value` isn't a valid shims map (known shim names to booleans), or null when it is.
+export const shimsError = (value) => {
+  if (!isObject(value)) return `must be an object of shim names to true or false (got ${JSON.stringify(value)})`;
+  const unknown = Object.keys(value).filter((name) => !(name in SHIM_DEFAULTS));
+  if (unknown.length) return `names unknown shims: ${unknown.join(", ")} (known: ${Object.keys(SHIM_DEFAULTS).join(", ")})`;
+  const bad = Object.entries(value).filter(([, on]) => typeof on !== "boolean");
+  return bad.length ? `must map each shim to true or false (${bad.map(([name]) => name).join(", ")})` : null;
+};
+
+// Every shim with whether it is on: the file's in its order, then the defaults of those it leaves out.
+export const workspaceShims = (parsed) => {
+  const given = parsed?.shims ?? {};
+  return { ...given, ...Object.fromEntries(Object.entries(SHIM_DEFAULTS).filter(([name]) => !(name in given))) };
+};
+
 // Deterministic ports: explicit `port`s are kept; every other agent gets the
 // first base port from `base` (in file order) that no agent has taken.
 // `offset` is added to every port.

package/tools/set_summary.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("eve/tools").ToolDefinition<{
-    scope: string;
-    text: string;
-}, any> & {
-    execute(input: {
-        scope: string;
-        text: string;
-    }, ctx: import("eve/tools").ToolContext): Promise<any>;
-};
-export default _default;

package/tools/set_summary.js

@@ -1,25 +0,0 @@
-// The `set_summary` tool (main's): write the free-form summary of a path
-// (project/track) or a thread, one markdown note a model keeps current. A track's says what's up
-// in that feature (the human sees it above the track's threads); a thread's
-// says what it's about and where it stands. The classifier files threads by
-// these, and list_threads returns them. lib/paths.mjs setSummary.
-import { defineTool } from "eve/tools";
-import { z } from "zod";
-import { registryFetch } from "../registry-fetch.mjs";
-export default defineTool({
-    description: "Write the summary of a path (project/track) or a thread: a short free-form markdown note, kept current. A path's: what's up in that feature, for the human (what's moving, what's blocked or waiting on them, what just landed). A thread's: what it's about and where it stands. You decide what's worth saying. It replaces the previous summary; empty text clears it. list_threads returns both.",
-    inputSchema: z.object({
-        scope: z.string().describe("What it summarizes: 'path:<path>' (e.g. 'path:web/checkout') or 'thread:<id>' (e.g. 'thread:thr_0d00')."),
-        text: z.string().describe("The whole new summary, markdown. Empty clears it."),
-    }),
-    async execute({ scope, text }, ctx) {
-        const res = await registryFetch(`/api/summaries`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ sessionId: ctx.session.id, scope, text }),
-        });
-        if (!res.ok)
-            throw new Error(`set_summary failed: ${res.status} ${await res.text()}`);
-        return await res.json();
-    },
-});