eve-hub 0.16.37 → 0.16.39

package/bot-model.mjs

@@ -57,9 +57,14 @@ export const GATEWAY_PROVIDERS = Object.freeze({
 
 // Provider options that fit `model`, and only those. Reasoning text is opt-in
 // on current Anthropic and OpenAI models; ask for summaries so the UI can
-// interleave them with tool calls.
+// interleave them with tool calls. Gateway's automatic caching marks only the
+// latest messages, so a resumed session never finds the system prompt another
+// session already cached; anchoring message 0 lets it read that prefix.
 export function modelOptionsFor(model) {
-  if (model.startsWith("anthropic/")) return { providerOptions: { anthropic: { thinking: { type: "adaptive", display: "summarized" } } } };
+  if (model.startsWith("anthropic/")) return { providerOptions: {
+    anthropic: { thinking: { type: "adaptive", display: "summarized" } },
+    gateway: { cacheAnchorMessageIndex: 0 },
+  } };
   if (model.startsWith("openai/")) return { providerOptions: { openai: { reasoningSummary: "auto" } } };
   const order = GATEWAY_PROVIDERS[model];
   return order ? { providerOptions: { gateway: { order: [...order] } } } : undefined;

package/kit-modules.json

@@ -35,7 +35,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.37",
+  "version": "0.16.39",
   "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/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."],
@@ -61,7 +60,7 @@ export const DEPLOYED_KIT_FILES = new Set([
   "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,6 @@ declare const _default: import("eve/tools").ToolDefinition<{
     title?: string | undefined;
     path?: string | null | undefined;
     issueType?: string | undefined;
-    summary?: string | undefined;
     pathLabel?: string | undefined;
     projectLabel?: string | undefined;
     issueTypeLabel?: string | undefined;
@@ -18,7 +17,6 @@ declare const _default: import("eve/tools").ToolDefinition<{
         title?: string | undefined;
         path?: string | null | undefined;
         issueType?: string | undefined;
-        summary?: string | undefined;
         pathLabel?: string | undefined;
         projectLabel?: string | undefined;
         issueTypeLabel?: string | undefined;

package/tools/update_thread.js

@@ -1,22 +1,22 @@
 // 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";
 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 and issue type, 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."),
         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();
-    },
-});