eve-hub 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.8.2
+
+### Patch Changes
+
+- The per-bot mention gate is gone: the hub decides who a bot's message wakes (wake router), so the `hooks/mention-gate` hook is removed from the kit.
+
+## 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

package/kit-modules.json

@@ -2,7 +2,6 @@
   "channels/eve",
   "channels/eve-roster-user",
   "connections/vercel-kit",
-  "hooks/mention-gate",
   "hooks/sandbox",
   "instructions/engineering",
   "instructions/main",

package/mention-gate.d.mts

@@ -2,5 +2,4 @@ export type GateConfig = { enabled: boolean; model: string; api: 'chat' | 'decis
 export function gateConfig(env?: Record<string, string | undefined>, file?: unknown): GateConfig;
 export function opensWithHandle(text: string, agent: string): boolean;
 export function cleanReason(reason: unknown): string;
-export function screenInbound(input: { text: string; sessionId: string; agent?: string; registryUrl: string; credential: (opts?: { refresh?: boolean }) => Promise<{ token: string; teamId?: string | null } | null>; instructions?: string; fetchImpl?: typeof fetch; log?: ((line: string) => void) | null }): Promise<{ cancel: boolean; result?: unknown }>;
 export function hubCredentialLoader(fetchHub: (path: string, init: { headers?: Record<string, string> }) => Promise<Response>): (opts?: { refresh?: boolean }) => Promise<{ ok: boolean; token?: string; error?: string }>;

package/mention-gate.mjs

@@ -1,19 +1,7 @@
-// Mention gate: when a bot's turn is woken by an @-mention or a DM, the bot
-// itself (its message.received hook, hooks/mention-gate.ts) asks a cheap
-// model, through AI Gateway, whether a reply is needed, before its main model
-// runs. The model reads the bot's own instructions and the delivery the bot
-// just received. A handle inside code (codeRanges) is dropped by
-// parseMentions before it joins or wakes anyone; the gate catches the other
-// incidental ones: a quote or a recap, or an ack that asks nothing.
-//
-// The hub decides which wakes are gated (gatedWake, registry/server.mjs) and
-// owns the outcome: the hook asks it first (POST /api/mention-gate/check),
-// then reports the decision (POST /api/mention-gate/report); on a skip the
-// hub posts the system line and records the usage, and the hook cancels the
-// turn. Biased to answering: the model only classifies the message (how the
-// handle is used, what it asks of the bot); skipFor decides, and any error,
-// timeout or unreadable verdict answers. Only bots' messages are gated: the
-// human's always wake.
+// The decision-model helpers the registry's mention gate (registry/server.mjs, frozen until its removal) and the hosted hub's wake
+// router and closing check share: the gateway config (gateConfig), the Mac bot credential loader and the response parsing. The bot-side
+// hook is gone; the hosted hub decides who a message wakes (hosted-hub/src/store/wake-router.ts). A handle inside code (codeRanges)
+// is dropped by parseMentions before it joins or wakes anyone.
 //
 // Config (the hub's, sent to the hook with each check): `mentionGate` in
 // hub.workspace.json ({ enabled, model, reasoningEffort, timeoutMs }),
@@ -21,7 +9,6 @@
 // HUB_MENTION_GATE_REASONING, HUB_MENTION_GATE_TIMEOUT_MS and
 // HUB_MENTION_GATE_URL (tests).
 import { codeRanges } from "./mention-tokens.mjs";
-import { hubHeaders } from "./registry-fetch.mjs";
 import { createHash } from "node:crypto";
 
 export { codeRanges };
@@ -395,45 +382,6 @@ export function credentialCache(load, { ttlMs = 10 * 60e3, failMs = 60e3, now =
   return get;
 }
 
-// --- The bot's side (hooks/mention-gate.ts).
-
-const HUB_CALL_MS = 2000;
-
-async function hubCall(fetchImpl, url, body) {
-  const res = await fetchImpl(url, { method: "POST", headers: await hubHeaders({ "content-type": "application/json" }), body: JSON.stringify(body), signal: AbortSignal.timeout(HUB_CALL_MS) });
-  if (!res.ok) throw new Error(`hub ${res.status}`);
-  return res.json();
-}
-
-// One inbound delivery, screened. Never throws; { cancel: true } only when the
-// hub accepted a skip (it posted the system line and expects the turn to
-// end cancelled). Anything that fails on the way answers.
-//   text: the delivery (message.received's data.message)
-//   credential: ({ refresh }) → { token, teamId? } | null (credentialCache)
-// `agent` is optional: left out, the hub names the bot from its session and sends its instructions.
-export async function screenInbound({ text, sessionId, agent, registryUrl, instructions = "", credential, fetchImpl = fetch, log = console.warn }) {
-  const messageId = triggerId(text);
-  if (!registryUrl || !messageId) return { cancel: false };
-  let check;
-  try {
-    check = await hubCall(fetchImpl, `${registryUrl}/api/mention-gate/check`, { ...(agent ? { agent } : {}), messageId, sessionId });
-  } catch (error) {
-    log?.(`[mention-gate] check for ${messageId} failed, answering: ${error?.message ?? error}`);
-    return { cancel: false };
-  }
-  if (!check?.gate || !check.config) return { cancel: false };
-  agent ??= check.agent;
-  instructions ||= check.instructions ?? "";
-  const r = await decide({ config: check.config, credential, prompt: promptFor(check.config, { agent, human: check.humanName ?? "the human", instructions, envelope: text, broadcast: Boolean(check.broadcast) }), addressed: Boolean(check.addressed), fetchImpl });
-  try {
-    const ack = await hubCall(fetchImpl, `${registryUrl}/api/mention-gate/report`, { ...(agent ? { agent } : {}), messageId, sessionId, skip: r.skip, reason: r.reason, verdict: r.verdict ?? null, usage: r.usage ?? null, ms: r.ms, error: r.error ?? null });
-    return { cancel: Boolean(r.skip && ack?.skip), result: r };
-  } catch (error) {
-    log?.(`[mention-gate] report for ${messageId} failed, answering: ${error?.message ?? error}`);
-    return { cancel: false, result: r };
-  }
-}
-
 // A Mac bot's AI Gateway credential: the hub mints an OIDC token for the workspace's bots project, asked for with the bot's HUB_TOKEN.
 // `fetchHub(path, init)` is registryFetch. On a refresh it names the token AI Gateway refused, as eve's served credential does.
 export function hubCredentialLoader(fetchHub) {

package/package.json

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

@@ -4,7 +4,6 @@
 export const KIT_FILES = {
   "channels/eve.ts": ["Queued eve channel that resolves the registry's human as a user.", "channels/eve-roster-user.ts"],
   "hooks/sandbox.ts": ["Migrates legacy Docker sessions to the host sandbox."],
-  "hooks/mention-gate.ts": ["Mention gate: a cheap model decides whether an inbound @-mention or DM needs a turn."],
   "tools/bash.ts": ["eve's bash with a default time limit (kills the process group) and the workspace's code location."],
   "tools/react.ts": ["React to a message with an emoji."],
   "tools/show.ts": ["Move the human's screen to a thread, DM, or message."],
@@ -52,7 +51,6 @@ export const MAIN_KIT_FILES = {
 // main's dash schedule stays: off the hub's machine it has no PR data (its lookup runs `gh`).
 export const DEPLOYED_KIT_FILES = new Set([
   "channels/eve.ts",
-  "hooks/mention-gate.ts",
   "schedules/dash.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",

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

@@ -22,7 +22,7 @@ declare const _default: import("eve/tools").ToolDefinition<{
     threadId: string;
     title: string;
     deliveries: Record<string, string>;
-    own?: boolean;
+    comms?: boolean;
 }> & {
     execute(input: {
         threadId?: string | undefined;
@@ -48,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,7 +4,7 @@ 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
@@ -18,7 +18,7 @@ import { registryFetch } from "../registry-fetch.mjs";
 // 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. `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.",
+    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."),

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 };
     },
 });