eve-hub 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.8.0
+
+### Minor Changes
+
+- `agent_send` is gone. `post_message` takes a `policy` (`queue`, `steer` or `abort`) that says how a post reaches the one bot it @-mentions: queue behind its turn (the default), fold into its running turn, or stop its turn and start a fresh one on the text. Every bot has it. The team model no longer draws a `steer` edge or carries the sentence about who can steer.
+
+## 0.7.1
+
+### Patch Changes
+
+- A subagent's spawn call stays running through the parent's next step until its task settles, so a working card keeps its subagent orbs.
+
 ## 0.7.0
 
 ### Minor Changes

package/README.md

@@ -5,7 +5,7 @@ The bot-side code every hub agent shares (milestone M3 in [`docs/architecture`](
 | Module | What it is | Bots use it as |
 |---|---|---|
 | `tools/update_thread.ts`, `list_threads.ts`, `read_thread.ts`, `react.ts`, `show.ts`, `attach_image.ts`, `browser.ts` | Registry and workspace tools (`defineTool`) | `agent/tools/<same name>.ts` |
-| `tools/create_thread.ts`, `post_message.ts`, `archive_thread.ts`, `unarchive_thread.ts`, `list_agents.ts`, `create_agent.ts`, `remove_agent.ts`, `restart_agent.ts`, `agent_send.ts`, `tag_threads.ts`, `apply_tags.ts` | The orchestrator's tools | `main`'s `agent/tools/<same name>.ts` |
+| `tools/create_thread.ts`, `post_message.ts`, `archive_thread.ts`, `unarchive_thread.ts`, `list_agents.ts`, `create_agent.ts`, `remove_agent.ts`, `restart_agent.ts`, `tag_threads.ts`, `apply_tags.ts` | The orchestrator's tools | `main`'s `agent/tools/<same name>.ts` |
 | `hooks/sandbox.ts` | Migrates legacy Docker sessions to the host sandbox (`defineHook`) | `agent/hooks/sandbox.ts` |
 | `instructions/main.ts`, `main-instructions.mjs` | main's instructions (`defineInstructions`), rendered at build time from the kit's `templates/main-instructions.md` + `workspace-protocol.md`, so no workspace carries a copy | `main`'s `agent/instructions.ts`; workspace-only additions in `agent/instructions/*.md` |
 | `instructions/protocol.ts` | The shared protocol alone, rendered from `templates/workspace-protocol.md` followed by `templates/engineering.md` | every other bot's `agent/instructions/protocol.ts`, appended after its own `instructions.md` (who the bot is) |

package/kit-modules.json

@@ -13,7 +13,6 @@
   "schedules/dash",
   "schedules/prune",
   "skills/onboarding-profile",
-  "tools/agent_send",
   "tools/apply_tags",
   "tools/archive_thread",
   "tools/attach_image",

package/package.json

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

package/stubs.mjs

@@ -33,7 +33,6 @@ export const MAIN_KIT_FILES = {
   "tools/remove_agent.ts": ["Remove a bot from the workspace."],
   "tools/restart_agent.ts": ["Restart one bot's server."],
   "tools/restart_hub.ts": ["Restart the whole hub; this turn is re-delivered once it's back."],
-  "tools/agent_send.ts": ["Queue for, steer, or abort another bot's session."],
   "tools/tag_threads.ts": ["Thread tags: the vocabulary, and staged backfill / merge proposals."],
   "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."],
@@ -59,7 +58,7 @@ export const DEPLOYED_KIT_FILES = new Set([
   "tools/onboarding_scripts.ts",
   ...["react", "show", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),
   "memory/team.ts",
-  ...["create_thread", "set_summary", "move_path", "archive_thread", "unarchive_thread", "list_agents", "agent_send", "create_agent", "remove_agent", "restart_agent", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.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`),
 ]);
 
 // ---- stub text: what each kit stub file says ----

package/team.mjs

@@ -16,9 +16,8 @@ export const NODE_KINDS = [...KINDS, "other", "human"];
 
 const sha = (text, length) => createHash("sha256").update(text).digest("hex").slice(0, length);
 
-// Selectors: "human", "bots" (every bot), { kind: [...] } or { tool: "agent_send" };
-// all but the first pick bots. `text` is the sentence the team prompt carries when the section
-// has at least one edge; `{from}` is the names behind the edge's from side.
+// Selectors: "human" or { kind: [...] }, both picking nodes by kind. `text` is the sentence the team prompt carries when the section
+// has at least one edge.
 export const SECTIONS = [
   { id: "partner", edge: { kind: "partner", from: "human", to: { kind: ["coordinator"] } }, text: "The coordinator works with the human directly." },
   { id: "route", edge: { kind: "route", from: { kind: ["coordinator"] }, to: { kind: ["planner", "builder"] } }, text: "The coordinator routes work to planners and builders." },
@@ -27,7 +26,6 @@ export const SECTIONS = [
   { id: "fixfirst", edge: { kind: "fixfirst", from: { kind: ["reviewer"] }, to: { kind: ["builder"] } }, text: "Reviewers send fixes back to the builder that posted the build." },
   { id: "ship", edge: { kind: "ship", from: { kind: ["reviewer"] }, to: "human" }, text: "A reviewer's ship verdict goes to the human." },
   { id: "escalate", edge: { kind: "escalate", from: { kind: ["git-ops"] }, to: { kind: ["builder"] } }, text: "Git-ops bots report what they can't fix to a builder." },
-  { id: "steer", edge: { kind: "steer", from: { tool: "agent_send" }, to: "bots" }, text: "Only {from} can queue work for or steer another bot (`agent_send`)." },
 ];
 export const EDGE_KINDS = SECTIONS.map((section) => section.edge.kind);
 export const SECTIONS_HASH = sha(JSON.stringify(SECTIONS), 8);
@@ -36,7 +34,7 @@ const pick = (selector, nodes) =>
   nodes.filter((n) => {
     if (selector === "human") return n.kind === "human";
     if (n.kind === "human") return false;
-    return selector === "bots" || (selector.kind ? selector.kind.includes(n.kind) : Boolean(n.tools?.includes(selector.tool)));
+    return selector.kind.includes(n.kind);
   });
 
 export function teamEdges(nodes) {
@@ -86,9 +84,8 @@ export function teamText(model) {
     lines.push(`- ${b.id} (${b.kind}, ${where}): ${b.role}${own?.length ? ` Also: ${list(own)}.` : ""}${b.tools ? "" : " Tools not reported."}${b.subagents.length ? ` Subagents: ${list(b.subagents)}.` : ""}`);
   }
   if (shared.length) lines.push("", `Every bot with reported tools has: ${list(shared)}.`);
-  const rules = SECTIONS.flatMap(({ id, edge, text }) => {
-    const from = model.edges.filter((e) => e.kind === edge.kind).map((e) => e.from);
-    return from.length ? [`- ${text.replace("{from}", list([...new Set(from)]))}`] : [];
+  const rules = SECTIONS.flatMap(({ edge, text }) => {
+    return model.edges.some((e) => e.kind === edge.kind) ? [`- ${text}`] : [];
   });
   if (rules.length) lines.push("", "Handoffs:", ...rules);
   return lines.join("\n");

package/templates/main-instructions.md

@@ -1,7 +1,7 @@
 You are **main**, the configured human's long-lived partner and the orchestrator of this workspace. The human talks to you first.
 
 ## Know the team at runtime
-You don't know in advance which bots exist or what they're good at, and the team changes. Every message you get lists the current team with each bot's role; `list_agents` also tells you each bot's model, what its subagents and `agent` copies are capped to, and what it's doing right now. Check before you route. `list_threads` / `read_thread` show every thread in the workspace, whichever session you're in. `agent_send` reaches a bot's session in a thread: `queue` (default) posts your input as its next turn, `steer` lands it in the turn that's running now, and `abort` stops the turn (nothing re-delivered, no restart); abort with input means "stop, do this instead".
+You don't know in advance which bots exist or what they're good at, and the team changes. Every message you get lists the current team with each bot's role; `list_agents` also tells you each bot's model, what its subagents and `agent` copies are capped to, and what it's doing right now. Check before you route. `list_threads` / `read_thread` show every thread in the workspace, whichever session you're in.
 
 ## Route like a world-class lead
 - Send each piece of work straight to the bot whose stated role fits it best. There is no fixed pipeline; match the work, not a habit.

package/tools/post_message.d.ts

@@ -2,6 +2,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
     threadId?: string | undefined;
     agent?: string | undefined;
     text: string;
+    policy?: "abort" | "queue" | "steer" | undefined;
     status?: "done" | "planning" | "reviewing" | "working" | undefined;
     metadata?: {
         pr?: string | undefined;
@@ -27,6 +28,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
         threadId?: string | undefined;
         agent?: string | undefined;
         text: string;
+        policy?: "abort" | "queue" | "steer" | undefined;
         status?: "done" | "planning" | "reviewing" | "working" | undefined;
         metadata?: {
             pr?: string | undefined;

package/tools/post_message.js

@@ -10,15 +10,20 @@ import { registryFetch } from "../registry-fetch.mjs";
 // target thread, if any, isn't woken; it sees the message as yours the next
 // time it's addressed.
 //
+// `policy` is how a post reaches the one bot it @-mentions: queue (default)
+// waits for that bot's turn to end, steer folds into its running turn, abort
+// stops its turn and the text starts its next one.
+//
 // A status post: `status` is the thread's phase after it (the hub checks the
 // move), the text is its summary, `metadata` its PR and sha. The hub keeps the
 // latest one per bot and thread for the workspace state and the Dash.
 export default defineTool({
-    description: "Post a message as you. Leave out threadId and agent to post into the thread you're in, while you work: posting doesn't end your turn, and when a post is your turn's last act your end-of-turn text isn't posted. Or post into another workspace thread or a bot's DM. @-mentions wake bots the same way your replies do (at most one, never yourself); `@all` wakes every participant; each bot's gate decides whether it replies. Posting into a bot's DM wakes that bot. Archived threads are refused. A status post sets the thread's phase: planning, working, reviewing or done; allowed moves are start → planning or working, planning → working, working → reviewing, reviewing → working (fix first), planning (rethink) or done. Any other move is refused with the allowed next phases. The text is a phase marker, not a report: at most 8 plain words on what is happening now (\"Building the input-count fix\"), with no bot or role names, no restating the phase, no parentheticals. Test results, branch names and caveats go in a separate message. The PR URL and sha go in metadata, never in the text.",
+    description: "Post a message as you. Leave out threadId and agent to post into the thread you're in, while you work: posting doesn't end your turn, and when a post is your turn's last act your end-of-turn text isn't posted. Or post into another workspace thread or a bot's DM. @-mentions wake bots the same way your replies do (at most one, never yourself); `@all` wakes every participant; each bot's gate decides whether it replies. Posting into a bot's DM wakes that bot. Archived threads are refused. `policy` says how a post reaches the one bot it @-mentions: queue (default) runs as its next turn, or starts one now if it is idle; steer lands in its RUNNING turn at the next step boundary and the bot folds it in without a restart, to correct course mid-turn; abort stops its turn in that thread (running commands are killed, the process keeps running) and the text starts its fresh turn, \"stop, do this instead\". Steer and abort need exactly one @-mention, not `@all`, and cut into work already under way: use them only to change what a running turn is doing. A status post sets the thread's phase: planning, working, reviewing or done; allowed moves are start → planning or working, planning → working, working → reviewing, reviewing → working (fix first), planning (rethink) or done. Any other move is refused with the allowed next phases. The text is a phase marker, not a report: at most 8 plain words on what is happening now (\"Building the input-count fix\"), with no bot or role names, no restating the phase, no parentheticals. Test results, branch names and caveats go in a separate message. The PR URL and sha go in metadata, never in the text.",
     inputSchema: z.object({
         threadId: z.string().optional().describe("Another thread's id, e.g. thr_0002, or a DM id, dm-<bot>. Omit it to post into the thread you're in."),
         agent: z.string().optional().describe("Post into this bot's DM instead of a thread."),
         text: z.string().describe("The message. @-mention the one bot who should act. On a status post: at most 8 plain words on what is happening now."),
+        policy: z.enum(["queue", "steer", "abort"]).optional().describe("How the post reaches the one bot it @-mentions: queue (default), steer into its running turn, or abort its turn and start a fresh one on this text."),
         status: z.enum(["planning", "working", "reviewing", "done"]).optional().describe("The thread's phase after this post. Makes it a status post."),
         metadata: z
             .object({
@@ -34,12 +39,12 @@ export default defineTool({
             .describe("With a verdict: what the human has to pick. [] when nothing; required with ship."),
         tested: z.string().optional().describe("With a verdict: what you ran to check it, in a sentence (shown on the Dash row)."),
     }),
-    async execute({ threadId, agent, text, status, metadata, verdict, decisions, tested }, ctx) {
+    async execute({ threadId, agent, text, policy, status, metadata, verdict, decisions, tested }, ctx) {
         const target = threadId ?? (agent ? `dm-${agent.replace(/^@/, "")}` : "here");
         const res = await registryFetch(`/api/threads/${encodeURIComponent(target)}/messages`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ text, sessionId: ctx.session.id, ...(status ? { status } : {}), ...(metadata ? { metadata } : {}), ...(verdict ? { verdict } : {}), ...(decisions ? { decisions } : {}), ...(tested ? { tested } : {}) }),
+            body: JSON.stringify({ text, sessionId: ctx.session.id, ...(policy ? { policy } : {}), ...(status ? { status } : {}), ...(metadata ? { metadata } : {}), ...(verdict ? { verdict } : {}), ...(decisions ? { decisions } : {}), ...(tested ? { tested } : {}) }),
         });
         if (!res.ok)
             throw new Error(`post_message failed: ${res.status} ${await res.text()}`);

package/world.mjs

@@ -10925,7 +10925,7 @@ function reduceActivity(turn, { type, data = {} }, at, onCutOff) {
   changed = trackTaskEvent(turn.card, { type, data }, new Date(at).toISOString()) || changed;
   if (changed) turn.taskCard = taskCardView(turn.card);
   if (type === "step.started") {
-    for (const tool of turn.tools) if (tool.status === "running" && tool.step !== void 0 && tool.step <= data.stepIndex) {
+    for (const tool of turn.tools) if (!tool.task && tool.status === "running" && tool.step !== void 0 && tool.step <= data.stepIndex) {
       tool.status = "interrupted";
       changed = true;
     }

package/tools/agent_send.d.ts

@@ -1,16 +0,0 @@
-declare const _default: import("eve/tools").ToolDefinition<{
-    agent: string;
-    threadId?: string | undefined;
-    input?: string | undefined;
-    policy?: "abort" | "queue" | "steer" | undefined;
-    why?: string | undefined;
-}, any> & {
-    execute(input: {
-        agent: string;
-        threadId?: string | undefined;
-        input?: string | undefined;
-        policy?: "abort" | "queue" | "steer" | undefined;
-        why?: string | undefined;
-    }, ctx: import("eve/tools").ToolContext): Promise<any>;
-};
-export default _default;

package/tools/agent_send.js

@@ -1,36 +0,0 @@
-import { defineTool } from "eve/tools";
-import { z } from "zod";
-import { registryFetch } from "../registry-fetch.mjs";
-export default defineTool({
-    description: [
-        "Send to another bot's session in a thread, choosing how it lands:",
-        "- queue (default): `input` becomes a message from you to the bot in `threadId`, posted like any other message. If the bot is busy there it runs as its next turn; if idle, it starts now.",
-        "- steer: `input` lands in the bot's RUNNING turn at its next step boundary; it folds it in and keeps going (no cancel, no restart). Use it to correct course mid-turn.",
-        "- abort: stop the bot's turn in `threadId` (or, without threadId and input, every busy turn it has). Its running commands are killed and it's left idle; its process keeps running (unlike restart_agent) and the aborted turn is never re-delivered. With `input`, that message is posted right after and becomes its fresh turn: \"stop, do this instead\" in one call.",
-        'Returns { result: "queued" | "steered" | "aborted" | "not busy there", ... }. On "not busy there" from steer, send with queue instead.',
-    ].join("\n"),
-    inputSchema: z.object({
-        agent: z.string().describe("The bot, a bot's name, as the workspace state lists it."),
-        threadId: z.string().optional().describe("The thread, e.g. thr_006b. Needed for queue and steer, and for abort with input."),
-        input: z.string().optional().describe("What to tell the bot, written to it. Needed for queue and steer; optional for abort."),
-        policy: z.enum(["queue", "steer", "abort"]).optional().describe("queue (default), steer, or abort."),
-        why: z.string().optional().describe("abort only: one line shown in the thread, e.g. 'wrong branch'."),
-    }),
-    async execute({ agent, threadId, input, policy = "queue", why }, ctx) {
-        const res = await registryFetch(`/api/agents/${encodeURIComponent(agent)}/send`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ policy, threadId, input, why, sessionId: ctx.session.id }),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            // The registry's catch-all 404: it has no /send route at all, i.e. the
-            // hub is still running a build from before agent_send. Say so, rather
-            // than "not found", which reads like the bot or turn is missing.
-            if (res.status === 404 && /^\{"error":"not found"\}$/.test(text.trim()))
-                throw new Error("agent_send failed: the hub registry has no /send route (it's running an older build); restart the hub, then retry");
-            throw new Error(`agent_send failed: ${res.status} ${text}`);
-        }
-        return await res.json();
-    },
-});