eve-hub 0.7.1 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.8.1
+
+### Patch Changes
+
+- A turn whose last step is only comms actions (a plain post into its thread, react) posts no end-of-turn text. Tool results declare `comms: true` (post_message's `own` is now `comms`), so a bot that reacts and ends no longer posts a "nothing to do" message.
+
+## 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

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.1",
+  "version": "0.8.1",
   "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/templates/workspace-protocol.md

@@ -4,7 +4,7 @@ You are one named bot in a small workspace of long-lived bots. Work happens in t
 
 - Each message you receive starts with the thread name, the live workspace state (every bot, you included, with its role, model, status, the threads it's busy in and its last message), and everything posted since your last turn. The line marked `→` is the one addressed to you.
 - Talk in the thread with `post_message` (no `threadId`): each call is one message under your name, and posting doesn't end your turn. Post when you start work that takes a while, when you find something that matters, and when you're done (principle 1). Text you write between tool calls is not posted.
-- If your last step was only plain `post_message` calls into this thread, and each succeeded, end the turn without text: anything you write after it goes to your activity log, not the thread. A status post, a post to another thread or DM, a failed post, or a step that also called another tool doesn't count: then your final text is posted as your last message, so write the answer there. That way an answer you forget to post isn't lost.
+- If your last step was only comms actions (plain `post_message` calls into this thread, and `react`), and each succeeded, end the turn without text: anything you write after it goes to your activity log, not the thread. A status post, a post to another thread or DM, a failed call, or a step that also called any other tool doesn't count: then your final text is posted as your last message, so write the answer there. Never write a closing line that says you reacted or have nothing to do. That way an answer you forget to post isn't lost.
 - Every @-mention wakes that bot and costs a turn. Mention someone only when you need them to act **now**. At most one @-mention per message, in the message that hands off, once your work is ready: the one bot or human who should act next. A progress post ("looking now") mentions nobody. Refer to anyone else by plain name (no @). Never @-mention yourself.
 - `@all` wakes every participant in the thread; each bot's gate decides whether it replies, so news that asks nothing of a bot costs it no turn. A bot that's mid-turn gets it when that turn ends. It doesn't count toward the one-mention rule, and a named @-mention beside it still addresses that bot by name. Use it when everyone in the thread should hear something; when one bot should act, @-mention that bot.
 - Rows from `(hub)` in your log are hub events: who joined or left the thread. They wake nobody. A message marked `[status: …]` is a bot's status post: the thread's phase, its PR and sha, with the text as the summary.

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;
@@ -21,12 +22,13 @@ declare const _default: import("eve/tools").ToolDefinition<{
     threadId: string;
     title: string;
     deliveries: Record<string, string>;
-    own?: boolean;
+    comms?: boolean;
 }> & {
     execute(input: {
         threadId?: string | undefined;
         agent?: string | undefined;
         text: string;
+        policy?: "abort" | "queue" | "steer" | undefined;
         status?: "done" | "planning" | "reviewing" | "working" | undefined;
         metadata?: {
             pr?: string | undefined;
@@ -46,7 +48,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
         threadId: string;
         title: string;
         deliveries: Record<string, string>;
-        own?: boolean;
+        comms?: boolean;
     }>;
 };
 export default _default;

package/tools/post_message.js

@@ -4,21 +4,26 @@ import { registryFetch } from "../registry-fetch.mjs";
 // Posts as you into a thread or DM, from whichever session you're in. With no
 // target it posts into the thread you're in, as part of the running turn: it
 // carries the turn's id and the images collected so far,
-// and if it's your turn's last act, your end-of-turn text isn't posted. Into
+// and if it's your turn's last act (alone or with reactions), your end-of-turn text isn't posted. Into
 // another thread, mentions wake bots exactly as your replies do; posting into
 // a bot's DM wakes that bot; archived threads refuse it. Your session in the
 // 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 your turn's last step is only comms (a plain post into this thread, a reaction), 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/tools/react.d.ts

@@ -3,12 +3,14 @@ declare const _default: import("eve/tools").ToolDefinition<{
     emoji: string;
 }, {
     ok: boolean;
+    comms: boolean;
 }> & {
     execute(input: {
         messageId: string;
         emoji: string;
     }, ctx: import("eve/tools").ToolContext): Promise<{
         ok: boolean;
+        comms: boolean;
     }>;
 };
 export default _default;

package/tools/react.js

@@ -1,9 +1,9 @@
 import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
-// Reactions are the bot's own choice, not delivery bookkeeping.
+// Reactions are the bot's own choice, not delivery bookkeeping. `comms: true` declares it talks in the thread: a turn whose last step is only comms posts no end-of-turn text.
 export default defineTool({
-    description: "React to a message in this thread with an emoji (toggles). Use the [msg_…] id shown before each message. Good for light acknowledgement (👍 got it, 👀 looking, ✅ done, 🎉 nice) when a full reply isn't needed.",
+    description: "React to a message in this thread with an emoji (toggles). Use the [msg_…] id shown before each message. Good for light acknowledgement (👍 got it, 👀 looking, ✅ done, 🎉 nice) when a full reply isn't needed. A turn that ends on only reactions and posts posts no closing text, so never write one.",
     inputSchema: z.object({
         messageId: z.string().describe("The id in brackets before the message, e.g. msg_0012."),
         emoji: z.string().describe("A single emoji."),
@@ -16,6 +16,6 @@ export default defineTool({
         });
         if (!res.ok)
             throw new Error(`react failed: ${res.status} ${await res.text()}`);
-        return { ok: true };
+        return { ok: true, comms: true };
     },
 });