eve-hub 0.16.44 → 0.16.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.44",
+  "version": "0.16.45",
   "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/templates/deliveries.md

@@ -1,5 +1,5 @@
 - **A delivery** is tagged sections in a fixed order; an empty one is left out.
-  - New session: `<thread_catchup>`, the thread's summary, latest status post and latest 20 posts.
+  - New session: `<thread_catchup>`, the thread's summary, latest status post and latest 20 posts. A `<timeline>` beside the summary and `<latest_status>` lists the thread's open notes, newest first, one `<entry kind="..." from="..." age="...">` line each; read it for the thread's structure and for which of problem, findings, decisions, options and outcome are still missing.
   - Later turns: `<new_posts>`, everything posted since your last turn, mentions or not.
   - `<thread_changes>`: the phase, PR, sha or summary moved.
   - `<team_status>`: who is active, with the human's handle and aliases.

package/templates/reaching-others.md

@@ -18,3 +18,6 @@
 - **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.
+- **Notes**
+  - 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/tools/post_message.d.ts

@@ -34,6 +34,22 @@ export declare const trackerRow: z.ZodObject<{
     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<{
@@ -69,6 +85,12 @@ declare const _default: import("eve/tools").ToolDefinition<{
         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;
@@ -108,6 +130,12 @@ declare const _default: import("eve/tools").ToolDefinition<{
             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

@@ -142,6 +142,13 @@ export const trackerRow = z.object({
     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)
@@ -190,11 +197,15 @@ export default defineTool({
             .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?}. A post that has a `verdict`, `status: \"done\"`, or an artifact of kind `plan` carries a `note`."),
     }),
-    async execute({ threadId, agent, text, images, policy, status, metadata, verdict, decisions, tested, artifact, step }, ctx) {
+    async execute({ threadId, agent, text, images, policy, status, metadata, verdict, decisions, tested, artifact, step, note }, 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);
@@ -207,7 +218,7 @@ export default defineTool({
         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 } : {}) }),
+            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 } : {}) }),
         });
         if (!res.ok)
             throw new Error(`post_message failed: ${res.status} ${await res.text()}`);