eve-hub 0.16.55 → 0.16.56

package/package.json

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

@@ -13,11 +13,11 @@ 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 and domain."],
+  "tools/update_thread.ts": ["Update a thread this bot is in: its phase, notes, tracker, artifacts, title and track."],
   "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."],
-  "tools/post_message.ts": ["Post into an existing thread or a bot's DM; with `status`, report the thread's phase."],
+  "tools/post_message.ts": ["Post a message into an existing thread or a bot's DM; a thread post @-mentions its receiver."],
   "skills/forms.ts": ["The forms skill (packages/agent-kit/forms/SKILL.md): how to draw a flow, sequence, chart or ask the app renders."],
   "skills/brief.ts": ["The brief skill (packages/agent-kit/brief/SKILL.md): how to write a brief for the human's yes and read it cold before posting."],
   "skills/fanout.ts": ["The fanout skill (packages/agent-kit/fanout/SKILL.md): the contract for handing work to the reader, editor and verifier subagents."],

package/templates/main-instructions.md

@@ -19,7 +19,7 @@ You are the **coordinator**, the human's chief of staff. The human talks to you
 - **Cross-thread chores (merge, rebase, close out, restart):** post in each owning thread to the bot that built it. Never collect them into one bot or your own session.
 - **A builder reports a merge sha:** archive the thread (`archive_thread`) in that turn.
 - **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.
+- **A post addressed to you (a report, review 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.
 
 **What the human decides.** Scope: the owner of a thread posts a brief and the human confirms it before anything is built. After that, only merge approval and anything that needs their eyes wait on them.
 

package/templates/reaching-others.md

@@ -5,7 +5,8 @@
 - **Mentions wake**
   - `@<name>` wakes one bot or person; `@all` wakes every participant in the thread.
   - Each wake costs that bot a turn, so mention at most one name per message: whoever acts next, in the message that hands off.
-  - Name everyone else in plain text. A progress post mentions nobody. Never mention yourself.
+  - Name everyone else in plain text. Never mention yourself.
+  - Every thread post @-mentions its receiver: a bot, `@all` or the human. The hub refuses a post that names none, and an @-name that is not a bot or the human. Progress that is for no one is a `tracker` row through `update_thread`, not a post.
   - When a post names you but asks someone else to act (you're named for a later step, or only in passing), `react` to it and end the turn: no post and no closing text. A "nothing for me yet" reply wakes the sender and adds a post the human reads.
 - **The human**
   - Their handle and aliases are in `<team_status>` (e.g. `me: rconti, Rui`); any of them reaches the same person.
@@ -14,8 +15,9 @@
 - **DMs**
   - In a DM, mentions are links and wake nobody, so tag every bot you refer to.
 - **Phase**
-  - When the thread's phase changes (planning, working, reviewing, done), add a status post: at most 8 plain words, no @-mention.
-  - The brief, question or handoff is its own post, without `status`: the app draws a status post as a grey phase row, and the hub refuses one that carries more.
+  - When the thread's phase changes (planning, working, reviewing, done), call `update_thread` with `status {phase, text}`: the text is at most 8 plain words, no @-mention. It wakes no one, and the app draws it as a grey phase row.
+  - The brief, question or handoff is its own `post_message` that @-mentions whoever acts next; the hub refuses a phase marker that carries more than a marker.
 - **Notes**
+  - A note goes through `update_thread`'s `note`, together with a `status` (the current phase, to stay in it), and the hub refuses a verdict, a done status or a plan artifact without one.
   - Coordinator writes `problem` and `goal` when the human opens a thread; `decision`, `cleared` or `question`, with `about`, when the human answers or corrects something; and a `summary` (2 to 3 plain sentences: the goal, where it stands, what is next) after each human decision and each merge report.
   - Planner writes a `finding` on a brief. Reviewer writes an `adjustment` on fix-first and an `outcome` on ship. Builder writes an `outcome` on a merge and on real-path checks, and an `adjustment` when CI or a check changes the plan.

package/templates/writing.md

@@ -2,7 +2,7 @@
   - Your messages land in a chat feed, like Slack or iMessage. The human runs many threads and gives each a few minutes, so every message is read cold, often only its first line.
   - The reader has none of your context.
 - **Who these rules are for**
-  - A post that @-mentions no bot is one the human reads: a result, a status report, a question. Every rule below applies to it.
+  - A post that @-mentions the human is one the human reads: a result, a status report, a question. Every rule below applies to it.
   - A post that @-mentions a bot is a handoff. The app folds bot-to-bot chatter, so a handoff keeps the dense format `<team_architecture>` asks for, ids and shas included. Only the length cap and the layout rules apply to it.
 - **Sound like a person** (core principle)
   - Write in the first person, the way a colleague texts you: what you did, what you found, and what happens next. "I fixed the late-link bug and pushed it. The reviewer has it now."
@@ -24,7 +24,7 @@
   - Never draw with characters: no arrows, boxes, numbered timelines or tables in a code fence.
 - **Disclose one step at a time**
   - A post is at most 2 sentences (the point or the question; the inbox shows only its first line), then at most 3 bullets or one small table: what the reader needs to act, and nothing more.
-  - Supporting detail for the same message can follow a `---` line, with a blank line on each side; it becomes a second bubble, and each bubble holds up to 700 characters. The first bubble must stand alone: a bot the post doesn't name sees only it. A new update, a separate ask or handoff, or anything that needs its own recipient or status is another `post_message`. Most posts are one bubble.
+  - Supporting detail for the same message can follow a `---` line, with a blank line on each side; it becomes a second bubble, and each bubble holds up to 700 characters. The first bubble must stand alone: a bot the post doesn't name sees only it. A new update, a separate ask or handoff, or anything that needs its own recipient is another `post_message`; a phase or status goes through `update_thread`, never another post. Most posts are one bubble.
   - Depth (evidence, analysis, options, a long table) goes in a doc: write a markdown file in your sandbox and link it in the post, `[the analysis](/workspace/notes/analysis.md)`; `post_message` uploads it and the link opens it beside the thread, already styled. Never paste it. Write HTML only for a layout markdown can't hold, following the `vercel-design` skill when you have it.
   - Images go in `post_message`'s `images` (sandbox paths), never in the text.
   - A file reaches the human only as a markdown link in a post or through `show`, which upload it. A raw sandbox path in text is a file they can't open.

package/tools/post_message.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 export declare const MAX_CHARS = 700;
 /** The characters the cap counts: the text without its links' targets. */
 export declare const postLength: (text: string) => number;
@@ -8,89 +7,12 @@ export declare function textError(text: string): string | null;
 export declare function voiceError(text: string): string | null;
 /** The text with each sandbox-path link target replaced by where the human's app opens it; a `#…` fragment stays on it. Each file is opened once. */
 export declare function rewriteDocLinks(text: string, open: (path: string) => Promise<string>): Promise<string>;
-export declare const artifactInput: z.ZodObject<{
-    kind: z.ZodEnum<{
-        decision: "decision";
-        doc: "doc";
-        plan: "plan";
-        pr: "pr";
-        review: "review";
-        sitrep: "sitrep";
-        walkthrough: "walkthrough";
-    }>;
-    title: z.ZodString;
-}, z.core.$strip>;
-export declare const trackerRow: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    state: z.ZodEnum<{
-        backlog: "backlog";
-        canceled: "canceled";
-        completed: "completed";
-        started: "started";
-        unstarted: "unstarted";
-    }>;
-    owner: z.ZodString;
-    waitsOn: z.ZodOptional<z.ZodString>;
-    ref: z.ZodString;
-}, z.core.$strip>;
-export declare const noteInput: z.ZodObject<{
-    kind: z.ZodEnum<{
-        adjustment: "adjustment";
-        cleared: "cleared";
-        decision: "decision";
-        finding: "finding";
-        goal: "goal";
-        outcome: "outcome";
-        problem: "problem";
-        question: "question";
-        summary: "summary";
-    }>;
-    text: z.ZodString;
-    key: z.ZodOptional<z.ZodBoolean>;
-    about: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** An artifact's link: the one given (a sandbox path uploaded), else the post's first link, else its PR. */
-export declare function artifactUrl(given: string | undefined, text: string, pr: string | undefined, open: (path: string) => Promise<string>): Promise<string>;
 declare const _default: import("eve/tools").ToolDefinition<{
     threadId?: string | undefined;
     agent?: string | undefined;
     text: string;
     images?: string[] | undefined;
     policy?: "abort" | "queue" | "steer" | undefined;
-    status?: "done" | "planning" | "reviewing" | "working" | undefined;
-    metadata?: {
-        pr?: string | undefined;
-        sha?: string | undefined;
-    } | undefined;
-    verdict?: "fix-first" | "rethink" | "ship" | undefined;
-    decisions?: {
-        question: string;
-        options: {
-            label: string;
-            pickedBy?: string | undefined;
-        }[];
-    }[] | undefined;
-    tested?: string | undefined;
-    artifact?: {
-        kind: "decision" | "doc" | "plan" | "pr" | "review" | "sitrep" | "walkthrough";
-        title: string;
-        url?: string | undefined;
-    } | undefined;
-    step?: {
-        id: string;
-        title: string;
-        state: "backlog" | "canceled" | "completed" | "started" | "unstarted";
-        owner: string;
-        waitsOn?: string | undefined;
-        ref?: string | undefined;
-    } | undefined;
-    note?: {
-        kind: "adjustment" | "cleared" | "decision" | "finding" | "goal" | "outcome" | "problem" | "question" | "summary";
-        text: string;
-        key?: boolean | undefined;
-        about?: string | undefined;
-    } | undefined;
 }, {
     messageId: string;
     threadId: string;
@@ -103,39 +25,6 @@ declare const _default: import("eve/tools").ToolDefinition<{
         text: string;
         images?: string[] | undefined;
         policy?: "abort" | "queue" | "steer" | undefined;
-        status?: "done" | "planning" | "reviewing" | "working" | undefined;
-        metadata?: {
-            pr?: string | undefined;
-            sha?: string | undefined;
-        } | undefined;
-        verdict?: "fix-first" | "rethink" | "ship" | undefined;
-        decisions?: {
-            question: string;
-            options: {
-                label: string;
-                pickedBy?: string | undefined;
-            }[];
-        }[] | undefined;
-        tested?: string | undefined;
-        artifact?: {
-            kind: "decision" | "doc" | "plan" | "pr" | "review" | "sitrep" | "walkthrough";
-            title: string;
-            url?: string | undefined;
-        } | undefined;
-        step?: {
-            id: string;
-            title: string;
-            state: "backlog" | "canceled" | "completed" | "started" | "unstarted";
-            owner: string;
-            waitsOn?: string | undefined;
-            ref?: string | undefined;
-        } | undefined;
-        note?: {
-            kind: "adjustment" | "cleared" | "decision" | "finding" | "goal" | "outcome" | "problem" | "question" | "summary";
-            text: string;
-            key?: boolean | undefined;
-            about?: string | undefined;
-        } | undefined;
     }, ctx: import("eve/tools").ToolContext): Promise<{
         messageId: string;
         threadId: string;

package/tools/post_message.js

@@ -26,9 +26,10 @@ import { registryFetch } from "../registry-fetch.mjs";
 // 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.
+// A thread post names its receiver: an @-mention of a bot, `@all` or the human.
+// The hub checks it against the roster and the human's names. A phase, tracker
+// row, note, artifact or verdict is the thread's state, not a message: it goes
+// through update_thread.
 export const MAX_CHARS = 700;
 const SCREENSHOT = "screenshot";
 // The markdown parser finds the links and where each destination starts, so a path in code is never read as a
@@ -129,35 +130,6 @@ function decode(path) {
         return path;
     }
 }
-export const artifactInput = z.object({
-    kind: z.enum(["walkthrough", "sitrep", "plan", "review", "pr", "decision", "doc"]).describe("What the artifact is."),
-    title: z.string().min(1).max(80).describe("Names the thing, at most 80 characters, e.g. 'First-sync walk-through'. A newer post under the same kind and title is marked as the latest version; older versions stay listed."),
-});
-// The hub checks each row again (packages/wire/src/state.ts TrackerRow); this is what the model reads.
-export const trackerRow = z.object({
-    id: z.string().describe("Your stable id for the row, e.g. 'review'. Send the same id again to move the row; the hub merges by id."),
-    title: z.string().describe("What the work is, in a few words, e.g. 'Review the fix'."),
-    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'."),
-    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."),
-});
-// The hub checks the note again (packages/wire/src/state.ts); this is what the model reads.
-export const noteInput = z.object({
-    kind: z.enum(["problem", "goal", "finding", "decision", "question", "cleared", "adjustment", "outcome", "summary"]).describe("What the note records: problem (the problem and its prior context), goal, finding (what research found), decision, question, cleared (a misconception corrected), adjustment (the plan changed, and why), outcome (how it worked out), summary (2 to 3 plain sentences: the goal, where it stands, what is next)."),
-    text: z.string().min(1).max(200).describe("One sentence, 1 to 200 characters, plain words, no glyph separators. It stands alone: it names the thing and never says 'it', 'this' or 'the fix' for something in an earlier entry, because the newest entry is shown above the ones that led to it."),
-    key: z.boolean().optional().describe("true keeps this entry open in the Artifacts pane; the others fold into 'N more steps'. Problem, goal and decision are always open. Set it when the human would lose the story if this entry were folded."),
-    about: z.string().optional().describe("A `thr_ID#msg_ID` ref (a hash, never a slash), for a note that records someone else's post, e.g. the human's decision; the entry then opens that post."),
-});
-/** An artifact's link: the one given (a sandbox path uploaded), else the post's first link, else its PR. */
-export async function artifactUrl(given, text, pr, open) {
-    if (given)
-        return isSandboxPath(given) ? open(given) : given;
-    const first = destinations(text).find((d) => d.kind !== "image")?.url ?? pr;
-    if (!first)
-        throw new Error("artifact needs a url: give artifact.url, link the document in the text, or set metadata.pr");
-    return first;
-}
 async function screenshot(sessionId) {
     if (hostedHub())
         throw new Error("a browser screenshot needs the hub's machine: on a hosted hub save the image to a sandbox file and pass its path in `images`");
@@ -168,44 +140,18 @@ async function screenshot(sessionId) {
     return browser.screenshot();
 }
 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 once your turn has posted into this thread, its end-of-turn text isn't posted, so put your result in a post. Or post into another workspace thread or a bot's DM. Each bubble is at most 700 characters (link targets don't count); a `---` line with blank lines around it starts a new bubble. Lead with the point in 2 sentences, then at most 3 bullets or one small table. A post that @-mentions no bot is one the human reads, and it is refused for a bullet that opens with a bold label and a colon, or an em dash. Depth goes in a document: write it to a file and link it in the text by its sandbox path, `[the plan](/workspace/plan.md)`; the file is uploaded and the link opens it beside the thread. Images go in `images` (sandbox paths; `screenshot` for your browser's page on a local hub) and show inline; never write `![]()`. @-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 once your turn has posted into this thread, its end-of-turn text isn't posted, so put your result in a post. Or post into another workspace thread or a bot's DM. Each bubble is at most 700 characters (link targets don't count); a `---` line with blank lines around it starts a new bubble. Lead with the point in 2 sentences, then at most 3 bullets or one small table. A thread post must @-mention its receiver: a bot, `@all` or the human; a post that only @-mentions the human is one the human reads, and it is refused for a bullet that opens with a bold label and a colon, or an em dash. Depth goes in a document: write it to a file and link it in the text by its sandbox path, `[the plan](/workspace/plan.md)`; the file is uploaded and the link opens it beside the thread. Images go in `images` (sandbox paths; `screenshot` for your browser's page on a local hub) and show inline; never write `![]()`. @-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. Phase, tracker rows, notes, artifacts and verdicts are the thread's state: set them with update_thread, not a post. `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.",
     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, at most 700 characters per bubble (link targets don't count); a `---` line with blank lines around it starts a new bubble. A markdown link to a sandbox path uploads that document. @-mention the one bot who should act. On a status post: at most 8 plain words on what is happening now."),
+        text: z.string().describe("The message, at most 700 characters per bubble (link targets don't count); a `---` line with blank lines around it starts a new bubble. A markdown link to a sandbox path uploads that document. @-mention the one bot, `@all` or the human who should act."),
         images: z.array(z.string()).optional().describe("Images to show inline on this post: sandbox paths (PNG, JPEG, GIF or WebP, up to 3 MB each), or `screenshot` for your browser's current page (local hub only)."),
         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({
-            pr: z.string().optional().describe("The PR's full URL, e.g. https://github.com/o/r/pull/188."),
-            sha: z.string().optional().describe("The head (or merge) commit sha, 7–40 hex characters."),
-        })
-            .optional()
-            .describe("With status: the PR and sha it's about."),
-        verdict: z.enum(["ship", "fix-first", "rethink"]).optional().describe("A reviewer's verdict on metadata.pr at metadata.sha (needs both, and a status). A ship needs decisions."),
-        decisions: z
-            .array(z.object({ question: z.string(), options: z.array(z.object({ label: z.string(), pickedBy: z.string().optional().describe("The bot that picked this option.") })) }))
-            .optional()
-            .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)."),
-        artifact: artifactInput
-            .extend({ url: z.string().optional().describe("What a tap opens: a sandbox path (uploaded), hub://upload link or https URL. Default: the post's first link, else metadata.pr.") })
-            .optional()
-            .describe("Tags this post as one of the thread's artifacts, shown in the thread's Artifacts pane: a walk-through, sitrep, plan, review, PR, decision or doc. The pane lists every version and marks the newest per kind and title as latest, so post a new version under the same title to supersede the old one."),
-        step: trackerRow
-            .extend({ ref: z.string().optional().describe("What the row opens. Default: this post.") })
-            .optional()
-            .describe("The thread's tracker row this post marks, written with the post: e.g. on a status post handing a PR to review, {id: 'review', title: 'Review the fix', state: 'started', owner: 'reviewer'}. The hub merges it by id, so the same id on a later post moves the same row, and stamps the time and your name when its state, owner or wait changes. Optional."),
-        note: noteInput.optional().describe("One entry in the thread's timeline of notes, the Artifacts pane's list, newest first: {kind, text, key?, about?}. The hub refuses a post that has a `verdict`, `status: \"done\"`, or an artifact of kind `plan` and no `note`."),
     }),
-    async execute({ threadId, agent, text, images, policy, status, metadata, verdict, decisions, tested, artifact, step, note }, ctx) {
+    async execute({ threadId, agent, text, images, policy }, ctx) {
         const bad = textError(text);
         if (bad)
             throw new Error(bad);
-        const noteVoice = note && voiceError(note.text);
-        if (noteVoice)
-            throw new Error(`note.text: ${noteVoice}`);
         const voice = voiceError(text);
         if (voice && !(await mentionsBot(text)))
             throw new Error(voice);
@@ -213,12 +159,11 @@ export default defineTool({
         let sandbox;
         const files = async () => (sandbox ??= await ctx.getSandbox());
         const posted = await rewriteDocLinks(text, async (path) => documentUrl(await files(), path, "post_message"));
-        const tagged = artifact && { ...artifact, url: await artifactUrl(artifact.url, posted, metadata?.pr, async (path) => documentUrl(await files(), path, "post_message")) };
         const attachments = await Promise.all((images ?? []).map(async (image) => image === SCREENSHOT ? uploadBytes(await screenshot(ctx.session.id), "screenshot.png", "post_message") : uploadFile(await files(), image, "post_message")));
         const res = await registryFetch(`/api/threads/${encodeURIComponent(target)}/messages`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ text: posted, sessionId: ctx.session.id, ...(attachments.length ? { attachments: attachments.map(({ id, name }) => ({ id, name })) } : {}), ...(policy ? { policy } : {}), ...(status ? { status } : {}), ...(metadata ? { metadata } : {}), ...(verdict ? { verdict } : {}), ...(decisions ? { decisions } : {}), ...(tested ? { tested } : {}), ...(tagged ? { artifact: tagged } : {}), ...(step ? { step } : {}), ...(note ? { note } : {}) }),
+            body: JSON.stringify({ text: posted, sessionId: ctx.session.id, ...(attachments.length ? { attachments: attachments.map(({ id, name }) => ({ id, name })) } : {}), ...(policy ? { policy } : {}) }),
         });
         if (!res.ok)
             throw new Error(`post_message failed: ${res.status} ${await res.text()}`);

package/tools/update_thread.d.ts

@@ -14,6 +14,29 @@ declare const _default: import("eve/tools").ToolDefinition<{
     pathLabel?: string | undefined;
     projectLabel?: string | undefined;
     issueTypeLabel?: string | undefined;
+    status?: {
+        phase: "done" | "planning" | "reviewing" | "working";
+        text: string;
+    } | undefined;
+    metadata?: {
+        pr?: string | undefined;
+        sha?: string | undefined;
+    } | undefined;
+    verdict?: "fix-first" | "rethink" | "ship" | undefined;
+    decisions?: {
+        question: string;
+        options: {
+            label: string;
+            pickedBy?: string | undefined;
+        }[];
+    }[] | undefined;
+    tested?: string | undefined;
+    note?: {
+        kind: "adjustment" | "cleared" | "decision" | "finding" | "goal" | "outcome" | "problem" | "question" | "summary";
+        text: string;
+        key?: boolean | undefined;
+        about?: string | undefined;
+    } | undefined;
     artifacts?: {
         kind: "decision" | "doc" | "plan" | "pr" | "review" | "sitrep" | "walkthrough";
         title: string;
@@ -36,6 +59,29 @@ declare const _default: import("eve/tools").ToolDefinition<{
         pathLabel?: string | undefined;
         projectLabel?: string | undefined;
         issueTypeLabel?: string | undefined;
+        status?: {
+            phase: "done" | "planning" | "reviewing" | "working";
+            text: string;
+        } | undefined;
+        metadata?: {
+            pr?: string | undefined;
+            sha?: string | undefined;
+        } | undefined;
+        verdict?: "fix-first" | "rethink" | "ship" | undefined;
+        decisions?: {
+            question: string;
+            options: {
+                label: string;
+                pickedBy?: string | undefined;
+            }[];
+        }[] | undefined;
+        tested?: string | undefined;
+        note?: {
+            kind: "adjustment" | "cleared" | "decision" | "finding" | "goal" | "outcome" | "problem" | "question" | "summary";
+            text: string;
+            key?: boolean | undefined;
+            about?: string | undefined;
+        } | undefined;
         artifacts?: {
             kind: "decision" | "doc" | "plan" | "pr" | "review" | "sitrep" | "walkthrough";
             title: string;

package/tools/update_thread.js

@@ -4,14 +4,37 @@
 // 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.
+// silent event row each. `status`, `verdict`, `note` and `metadata` are the
+// thread's state (its phase, a reviewer's verdict on a PR, a timeline note): the
+// hub writes them as one grey phase row authored by the calling bot, with no
+// @-mention, so it wakes and notifies no one. A message to someone is post_message.
 import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
-import { documentUrl } from "../hub-upload.js";
-import { artifactInput, artifactUrl, trackerRow } from "./post_message.js";
+import { documentUrl, isSandboxPath } from "../hub-upload.js";
+import { voiceError } from "./post_message.js";
+const artifactInput = z.object({
+    kind: z.enum(["walkthrough", "sitrep", "plan", "review", "pr", "decision", "doc"]).describe("What the artifact is."),
+    title: z.string().min(1).max(80).describe("Names the thing, at most 80 characters, e.g. 'First-sync walk-through'. A newer entry under the same kind and title is marked as the latest version; older versions stay listed."),
+});
+// 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, e.g. 'review'. Send the same id again to move the row; the hub merges by id."),
+    title: z.string().describe("What the work is, in a few words, e.g. 'Review the fix'."),
+    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'."),
+    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."),
+});
+// The hub checks the note again (packages/wire/src/state.ts); this is what the model reads.
+const noteInput = z.object({
+    kind: z.enum(["problem", "goal", "finding", "decision", "question", "cleared", "adjustment", "outcome", "summary"]).describe("What the note records: problem (the problem and its prior context), goal, finding (what research found), decision, question, cleared (a misconception corrected), adjustment (the plan changed, and why), outcome (how it worked out), summary (2 to 3 plain sentences: the goal, where it stands, what is next)."),
+    text: z.string().min(1).max(200).describe("One sentence, 1 to 200 characters, plain words, no glyph separators. It stands alone: it names the thing and never says 'it', 'this' or 'the fix' for something in an earlier entry, because the newest entry is shown above the ones that led to it."),
+    key: z.boolean().optional().describe("true keeps this entry open in the Artifacts pane; the others fold into 'N more steps'. Problem, goal and decision are always open. Set it when the human would lose the story if this entry were folded."),
+    about: z.string().optional().describe("A `thr_ID#msg_ID` ref (a hash, never a slash), for a note that records someone else's post, e.g. the human's decision; the entry then opens that post."),
+});
 export default defineTool({
-    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.",
+    description: "Update a workspace thread you're in: its phase, tracker, notes, artifacts, title, track and issue type, in one call. This is where a thread's state goes; post_message is only for messages to someone. `status` sets the 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. Its `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 @-mention, no bot or role names, no restating the phase. Test results, branch names and caveats go in a post. The PR URL and sha go in `metadata`. A reviewer's `verdict` (with `decisions` and `tested`) is on `metadata.pr` at `metadata.sha`. A `note` and a verdict ride on the status row, so send them with a `status` (the current phase to stay in it). The hub refuses a `verdict`, a `done` status or a `plan` artifact with no `note`. The state wakes no one: to hand work to someone, post_message and @-mention them. 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."),
@@ -21,21 +44,39 @@ export default defineTool({
             .array(trackerRow)
             .max(50)
             .optional()
-            .describe("Tracker rows to add or change: the thread's pieces of work toward its goal, one row each, drawn as the Artifacts pane's Done (completed), Pending now (started, unstarted), Pending until done (backlog) and Dropped (canceled) lists. The hub merges them by id: a row with a known id is replaced, a new id is added, and rows you don't send stay as they are, so send only the rows that changed. To drop a row, send it as canceled. The hub stamps the time and your name on each row whose state, owner or wait changes. For a step that has its own post, prefer post_message's `step`. A row whose ref is a PR moves to Done or Dropped by itself when the PR merges or closes."),
+            .describe("Tracker rows to add or change: the thread's pieces of work toward its goal, one row each, drawn as the Artifacts pane's Done (completed), Pending now (started, unstarted), Pending until done (backlog) and Dropped (canceled) lists. The hub merges them by id: a row with a known id is replaced, a new id is added, and rows you don't send stay as they are, so send only the rows that changed. To drop a row, send it as canceled. The hub stamps the time and your name on each row whose 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."),
+        status: z.object({ phase: z.enum(["planning", "working", "reviewing", "done"]), text: z.string().describe("The phase marker: at most 8 plain words on what is happening now, no @-mention.") }).optional().describe("The thread's phase after this call, shown as a grey phase row. Wakes no one."),
+        metadata: z
+            .object({
+            pr: z.string().optional().describe("The PR's full URL, e.g. https://github.com/o/r/pull/188."),
+            sha: z.string().optional().describe("The head (or merge) commit sha, 7–40 hex characters."),
+        })
+            .optional()
+            .describe("With status: the PR and sha it's about."),
+        verdict: z.enum(["ship", "fix-first", "rethink"]).optional().describe("A reviewer's verdict on metadata.pr at metadata.sha (needs both, and a status). A ship needs decisions."),
+        decisions: z
+            .array(z.object({ question: z.string(), options: z.array(z.object({ label: z.string(), pickedBy: z.string().optional().describe("The bot that picked this option.") })) }))
+            .optional()
+            .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)."),
+        note: noteInput.optional().describe("One entry in the thread's timeline of notes, the Artifacts pane's list, newest first: {kind, text, key?, about?}. It rides on the status row, so send it with a `status`. The hub refuses a `verdict`, a done status, or a plan artifact with no `note`."),
         artifacts: z
             .array(artifactInput.extend({ url: z.string().describe("What a tap opens: a sandbox path (uploaded), hub://upload link or https URL.") }))
             .min(1)
             .max(10)
             .optional()
-            .describe("Adds artifacts to the thread's Artifacts pane without posting a message; each shows as a silent line in the thread that wakes nobody. When the artifact comes with a post, use post_message's `artifact` instead."),
+            .describe("Adds artifacts to the thread's Artifacts pane without posting a message; each shows as a silent line in the thread that wakes nobody."),
     }),
     async execute({ threadId, artifacts, ...fields }, ctx) {
+        const noteVoice = fields.note && voiceError(fields.note.text);
+        if (noteVoice)
+            throw new Error(`note.text: ${noteVoice}`);
         let sandbox;
         const open = async (path) => documentUrl((sandbox ??= await ctx.getSandbox()), path, "update_thread");
-        const added = artifacts && (await Promise.all(artifacts.map(async (a) => ({ ...a, url: await artifactUrl(a.url, "", undefined, open) }))));
+        const added = artifacts && (await Promise.all(artifacts.map(async (a) => ({ ...a, url: isSandboxPath(a.url) ? await open(a.url) : a.url }))));
         const res = await registryFetch(`/api/threads/${encodeURIComponent(threadId)}/rename`, {
             method: "POST",
             headers: { "content-type": "application/json" },