@cmgmyr/hive 1.10.1 → 1.11.0

package/dist/tools/questions.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { currentActor, effectiveProjectId } from "../context.js";
+import { run } from "../result.js";
+import { answerQuestion, askQuestion, getQuestion, listQuestions, updateQuestion, } from "../questions.js";
+import { idParam } from "./params.js";
+const optionParam = z.strictObject({
+    label: z.string().describe("Short choice label; distinct within the question."),
+    description: z.string().describe("What choosing this means."),
+    recommended: z.boolean().describe("Exactly one option is recommended; it is the default."),
+});
+const refParam = z.strictObject({
+    kind: z.enum(["todo", "pr"]),
+    number: idParam.describe("A todo id or PR number. An identifier, not looked up."),
+});
+const stateParam = z.enum(["answered", "defaulted", "pending", "withdrawn"]);
+const noWrites = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+const writes = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+export function registerQuestions(server) {
+    server.registerTool("question_ask", {
+        description: "Record an open question for the human, keyed to this project and to you as the asker. kind=choice takes 2-4 options (each label, description, recommended; exactly one recommended) and a header of 12 characters or fewer; kind=free_text takes just the question and header. Every question carries default_answer: for a choice it is the recommended option's label. Pass ref (a todo id or PR number) to dedupe: asking again with a ref that already has a PENDING question in this project updates that row instead of adding one. The receipt lists other pending questions in this project that look similar (same normalized text, or at least half their longer words shared), so you can question_update one instead. The record is only stored: put the question to the human yourself, in your own turn. You must be a session an answer can be woken back to. When the question is answered, an ordinary wake carrying the answer is queued to you; read the record with question_get.",
+        annotations: writes,
+        inputSchema: {
+            kind: z.enum(["choice", "free_text"]),
+            question: z.string(),
+            header: z.string().describe("12 characters or fewer."),
+            options: z.array(optionParam).optional().describe("Required for choice, forbidden for free_text."),
+            default_answer: z.string().describe("What you do if unanswered. For a choice, the recommended label."),
+            ref: refParam.optional(),
+        },
+        outputSchema: {
+            question_id: idParam,
+            created: z.boolean(),
+            similar_question_ids: z.array(idParam),
+        },
+    }, (args) => run(() => {
+        const projectId = effectiveProjectId();
+        const input = {
+            kind: args.kind,
+            question: args.question,
+            header: args.header,
+            default_answer: args.default_answer,
+            ...(args.options !== undefined ? { options: args.options } : {}),
+            ...(args.ref !== undefined ? { ref: args.ref } : {}),
+        };
+        return askQuestion(projectId, currentActor(), input);
+    }));
+    server.registerTool("question_get", {
+        description: "Read one question in this project by id, in any state, with its answer and notes once answered.",
+        annotations: noWrites,
+        inputSchema: { question_id: idParam },
+    }, (args) => run(() => getQuestion(effectiveProjectId(), args.question_id)));
+    server.registerTool("question_list", {
+        description: "List this project's pending questions, then its defaulted ones (acted on by default, still open to reversal), oldest first within each group. Answered and withdrawn questions are not listed; read one by id with question_get.",
+        annotations: noWrites,
+        inputSchema: {},
+    }, () => run(() => ({ questions: listQuestions(effectiveProjectId()) })));
+    server.registerTool("question_update", {
+        description: "Edit a pending question's text (question, header, options, default_answer; the whole result is revalidated) or move it out of pending with state=defaulted (you acted on your default) or state=withdrawn (moot). A defaulted question can still be withdrawn. Moving state needs the asking session or the human; an answered or withdrawn question cannot be changed. The ref, asker and wake target never change.",
+        annotations: writes,
+        inputSchema: {
+            question_id: idParam,
+            question: z.string().optional(),
+            header: z.string().optional(),
+            options: z.array(optionParam).optional(),
+            default_answer: z.string().optional(),
+            state: z.enum(["defaulted", "withdrawn"]).optional(),
+        },
+        outputSchema: { question_id: idParam, state: stateParam },
+    }, (args) => run(() => {
+        const { question_id, ...patch } = args;
+        return updateQuestion(effectiveProjectId(), currentActor(), question_id, patch);
+    }));
+    server.registerTool("question_answer", {
+        description: "Record the human's answer to a pending or defaulted question in this project: a picked option label or free text (any nonblank text is accepted, including one outside the offered labels), plus optional notes. The answer commits first. It then queues one wake to the asking session carrying the question, answer and notes verbatim, unless you ARE the asker (you recorded the human's own pick) or the asker cannot be reached now; either way the receipt says wake_id null and why in wake_skipped, and the answer stays readable with question_get. wake_id means queued, not delivered. An answered or withdrawn question refuses with QUESTION_STATE_CONFLICT.",
+        annotations: writes,
+        inputSchema: {
+            question_id: idParam,
+            answer: z.string(),
+            notes: z.string().optional(),
+        },
+        outputSchema: {
+            question_id: idParam,
+            wake_id: idParam.nullable(),
+            wake_skipped: z.string().optional(),
+        },
+    }, (args) => run(() => answerQuestion(effectiveProjectId(), currentActor(), args.question_id, args.answer, args.notes)));
+}

package/dist/tools/wakes.js

@@ -35,7 +35,7 @@ function refuseUnclassifiableTarget(agent) {
         "error you can read now. Drive this pane with agent_send(keys: [...]) instead, which is unguarded for " +
         "exactly this reason.");
 }
-function resolveDelivery(projectId, deliverTo) {
+export function resolveWakeDelivery(projectId, deliverTo) {
     if (deliverTo != null) {
         const agent = resolveAgentRef(projectId, deliverTo);
         // Before the liveness probe: the harness is a durable fact about the row, while liveness is a
@@ -130,7 +130,7 @@ function deliveredByNote(t) {
         : null;
 }
 export const truncateBody = (body) => body.length > 120 ? `${cutToUnitBudget(body, 120)}…` : body;
-function rejectUnsafeBody(body) {
+export function assertSafeWakeBody(body) {
     const bad = findUnsafeControlChar(body, TEXT_ALLOWED_CONTROL_CHARS);
     if (bad) {
         throw new Error(`body cannot contain ${bad.label} at offset ${bad.index}: it is typed literally into the target pane ` +
@@ -173,7 +173,7 @@ const openStandingWatch = db.transaction((projectId, owner, body, deliverActor,
     return row;
 });
 function createStandingWatch(projectId, args) {
-    const delivery = resolveDelivery(projectId, args.deliver_to);
+    const delivery = resolveWakeDelivery(projectId, args.deliver_to);
     const maxWait = args.max_wait_seconds ?? STANDING_WATCH_LIFETIME_SECONDS;
     const row = openStandingWatch.immediate(projectId, currentActor(), args.body, delivery.actor, delivery.pane, maxWait);
     const crew = db
@@ -261,7 +261,7 @@ function createLeadWatch(leadProjectId, args) {
             note: `Project ${leadProjectId}'s lead has already ended its turn; nothing was scheduled. Read it now.`,
         };
     }
-    const delivery = resolveDelivery(home);
+    const delivery = resolveWakeDelivery(home);
     const maxWait = args.max_wait_seconds ?? 900;
     const row = openLeadWatch.immediate(home, args.body, mode, delivery, maxWait, {
         projectId: leadProjectId,
@@ -329,9 +329,9 @@ export function registerWakes(server) {
             repeating: z.boolean(),
         },
     }, (args) => run(() => {
-        rejectUnsafeBody(args.body);
+        assertSafeWakeBody(args.body);
         const projectId = effectiveProjectId(args.project_id);
-        const delivery = resolveDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
         return commitQueenStateWrite("wake_set", projectId, args, () => {
             const row = db
                 .prepare(`INSERT INTO wakes (project_id, owner, body, kind, deliver_actor, deliver_pane, due_at, repeat_every_ms)
@@ -407,7 +407,7 @@ export function registerWakes(server) {
             note: z.string().optional(),
         },
     }, (args) => run(() => {
-        rejectUnsafeBody(args.body);
+        assertSafeWakeBody(args.body);
         const projectId = effectiveProjectId(args.project_id);
         const selectors = [
             args.agents != null && "agents",
@@ -441,7 +441,7 @@ export function registerWakes(server) {
                 "reported as a timeout instead of the failure it actually is. A lead's turn has its own channel, " +
                 "which only the queen may watch, with lead_project_id=<that lead's project id>.");
         }
-        const delivery = resolveDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
         const snapshot = liveTargets();
         if (mode === "all") {
             const allIdle = watched.every((a) => {
@@ -577,7 +577,7 @@ export function registerWakes(server) {
         const sets = [];
         const params = [];
         if (args.body != null) {
-            rejectUnsafeBody(args.body);
+            assertSafeWakeBody(args.body);
             sets.push("body = ?");
             params.push(args.body);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "Run a crew of Claude Code and Codex workers from one lead session: visible tmux panes, exact state from hooks, one local SQLite store.",
   "type": "module",
   "bin": {