bazilion 0.14.2 → 0.15.0

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { defineCommand as defineCommand28, runCommand, showUsage } from "citty";
+import { defineCommand as defineCommand33, runCommand, showUsage } from "citty";
 
 // package.json
 var package_default = {
   name: "bazilion",
-  version: "0.14.2",
+  version: "0.15.0",
   description: "Multi-agent runtime CLI \u2014 spawn LLM agents, manage profiles/teams/skills, and run the local daemon.",
   license: "MIT",
   repository: {
@@ -165,7 +165,70 @@ function createClient(cfg) {
     }
     if (buffer.trim()) yield JSON.parse(buffer);
   }
+  async function binary(path) {
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      headers: await authHeaders(),
+      redirect: "error"
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new ApiClientError(res.status, err);
+    }
+    return new Uint8Array(await res.arrayBuffer());
+  }
   return {
+    notifications: {
+      settings: () => request("GET", "/api/notifications"),
+      configure: (input) => request("PUT", "/api/notifications", input),
+      preview: (kinds) => request("POST", "/api/notifications/preview", { kinds }),
+      list: (options = {}) => {
+        const params = new URLSearchParams();
+        if (options.cursor) params.set("cursor", options.cursor);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        return request("GET", `/api/notifications/receipts?${params}`);
+      },
+      get: (id) => request(
+        "GET",
+        `/api/notifications/receipts/${encodeURIComponent(id)}`
+      ),
+      retry: (id, input) => request(
+        "POST",
+        `/api/notifications/receipts/${encodeURIComponent(id)}/retry`,
+        input
+      )
+    },
+    questions: (agentId) => {
+      const base = `/api/agents/${encodeURIComponent(agentId)}/questions`;
+      return {
+        list: (conversationId) => request(
+          "GET",
+          conversationId ? `${base}?conversationId=${encodeURIComponent(conversationId)}` : base
+        ),
+        get: (id) => request("GET", `${base}/${encodeURIComponent(id)}`),
+        answer: (id, input) => request("POST", `${base}/${encodeURIComponent(id)}/answer`, input)
+      };
+    },
+    queue: (agentId) => {
+      const base = `/api/agents/${encodeURIComponent(agentId)}/queue`;
+      const item = (id) => `${base}/${encodeURIComponent(id)}`;
+      return {
+        list: (all = false, offset = 0) => request("GET", `${base}?all=${all ? 1 : 0}&offset=${offset}`),
+        get: (id) => request("GET", item(id)),
+        input: (id) => request("GET", `${item(id)}/input`),
+        enqueue: (input) => request("POST", base, input),
+        edit: (id, input) => request("PATCH", item(id), input),
+        remove: (id, expectedRevision) => request("DELETE", item(id), { expectedRevision }),
+        pause: (paused, expectedRevision) => request("POST", `${base}/control`, { paused, expectedRevision }),
+        stop: (expectedRevision) => request("POST", `${base}/stop`, {
+          expectedRevision
+        }),
+        reconcile: (id, expectedRevision) => request("POST", `${item(id)}/reconcile`, {
+          expectedRevision,
+          acknowledged: true
+        })
+      };
+    },
+    binary,
     get: (p) => request("GET", p),
     post: (p, b) => request("POST", p, b),
     postMultipart,
@@ -220,11 +283,8 @@ function createClient2(cfg = loadClientConfig()) {
   return createClient({ serverUrl: cfg.serverUrl, token: cfg.token });
 }
 
-// src/commands/agent.ts
-import { readFileSync as readFileSync2, writeFileSync } from "fs";
-import { basename, extname } from "path";
-import { stdin, stdout } from "process";
-import { createInterface } from "readline/promises";
+// src/commands/conversation.ts
+import { randomUUID } from "crypto";
 import { defineCommand } from "citty";
 
 // src/columnize.ts
@@ -247,6 +307,520 @@ function columnize(rows, gap = "  ") {
   );
 }
 
+// src/commands/conversation.ts
+var positional = { type: "positional", required: true };
+var pathFor = (agent) => `/api/agents/${encodeURIComponent(agent)}/conversations`;
+var list = defineCommand({
+  meta: { name: "list", description: "List retained conversations and active selection" },
+  args: {
+    agent: positional,
+    limit: { type: "string", default: "20" },
+    offset: { type: "string", default: "0" },
+    json: { type: "boolean" }
+  },
+  async run({ args }) {
+    const query = new URLSearchParams({ limit: args.limit, offset: args.offset });
+    const body = await createClient2().get(
+      `${pathFor(args.agent)}?${query}`
+    );
+    if (args.json) return console.log(JSON.stringify(body, null, 2));
+    if (!body.total) return console.log("(no conversations)");
+    for (const line of columnize([
+      ["id", "title", "active"],
+      ...body.conversations.map((item) => [
+        item.id,
+        item.title,
+        item.id === body.selection.conversationId ? "yes" : ""
+      ])
+    ]))
+      console.log(line);
+    console.log(`Selection revision: ${body.selection.revision}`);
+  }
+});
+var show = defineCommand({
+  meta: { name: "show", description: "Read retained history without selecting it" },
+  args: { agent: positional, id: positional, json: { type: "boolean" } },
+  async run({ args }) {
+    const body = await createClient2().get(`${pathFor(args.agent)}/${encodeURIComponent(args.id)}`);
+    if (args.json) return console.log(JSON.stringify(body, null, 2));
+    console.log(body.conversation.title);
+    for (const message of body.messages) console.log(`[${message.role}] ${message.content}`);
+  }
+});
+var newConversation = defineCommand({
+  meta: {
+    name: "new",
+    description: "Start a new conversation, retaining existing history and files"
+  },
+  args: {
+    agent: positional,
+    title: { type: "string" },
+    "request-id": { type: "string", description: "UUID for reconciling a lost response" },
+    "expected-revision": {
+      type: "string",
+      description: "Original selection revision for an exact retry"
+    },
+    "expected-conversation": {
+      type: "string",
+      description: "Original selected ID, or none for an empty selection"
+    },
+    json: { type: "boolean" }
+  },
+  async run({ args }) {
+    const client = createClient2();
+    const state = await client.get(`${pathFor(args.agent)}?limit=1`);
+    const requestId = args["request-id"] ?? randomUUID();
+    const revision = args["expected-revision"] === void 0 ? state.selection.revision : Number(args["expected-revision"]);
+    if (!Number.isSafeInteger(revision) || revision < 0)
+      throw new Error("Invalid expected revision");
+    if (args["request-id"] && (args["expected-revision"] === void 0 || args["expected-conversation"] === void 0)) {
+      throw new Error(
+        "--request-id requires --expected-revision and --expected-conversation for an exact retry"
+      );
+    }
+    const expectedSelection = {
+      revision,
+      conversationId: args["expected-conversation"] === void 0 ? state.selection.conversationId : args["expected-conversation"] === "none" ? null : args["expected-conversation"]
+    };
+    console.error(
+      `Create request: ${requestId}; retry with --request-id ${requestId} --expected-revision ${revision} --expected-conversation ${expectedSelection.conversationId ?? "none"} and the same title.`
+    );
+    const body = await client.post(pathFor(args.agent), {
+      requestId,
+      expectedSelection,
+      ...args.title ? { title: args.title } : {}
+    });
+    console.log(
+      args.json ? JSON.stringify(body, null, 2) : `Conversation ${body.conversation.id}: ${body.conversation.title} (active: ${body.selection.conversationId})`
+    );
+  }
+});
+var rename = defineCommand({
+  meta: {
+    name: "rename",
+    description: "Rename a conversation without changing its selection or history"
+  },
+  args: { agent: positional, id: positional, title: positional, json: { type: "boolean" } },
+  async run({ args }) {
+    const client = createClient2();
+    const path = `${pathFor(args.agent)}/${encodeURIComponent(args.id)}`;
+    const current = await client.get(path);
+    const body = await client.patch(path, {
+      title: args.title,
+      expectedTitleRevision: current.conversation.titleRevision
+    });
+    console.log(args.json ? JSON.stringify(body, null, 2) : body.conversation.title);
+  }
+});
+var conversationCommand = defineCommand({
+  meta: { name: "conversation", description: "List, read, create and rename Agent conversations" },
+  subCommands: { list, show, new: newConversation, rename }
+});
+
+// src/commands/notification.ts
+import { defineCommand as defineCommand2 } from "citty";
+var output = (value) => console.log(JSON.stringify(value, null, 2));
+var positional2 = { type: "positional", required: true };
+var notificationCommand = defineCommand2({
+  meta: {
+    name: "notification",
+    description: "Configure opt-in Telegram Attention notices and inspect delivery receipts"
+  },
+  subCommands: {
+    settings: defineCommand2({
+      async run() {
+        output(await createClient2().notifications.settings());
+      }
+    }),
+    preview: defineCommand2({
+      args: {
+        kinds: {
+          type: "string",
+          description: "Comma-separated Attention kinds; defaults to current selection"
+        }
+      },
+      async run({ args }) {
+        const api = createClient2().notifications;
+        const kinds = args.kinds ? args.kinds.split(",") : (await api.settings()).settings.kinds;
+        output(await api.preview(kinds));
+      }
+    }),
+    configure: defineCommand2({
+      args: {
+        enable: { type: "boolean" },
+        disable: { type: "boolean" },
+        "destination-id": {
+          type: "string",
+          description: "Explicit verified service destination ID from settings; required with --enable"
+        },
+        kinds: { type: "string", description: "Comma-separated Attention kinds" },
+        timezone: { type: "string", description: "IANA timezone, for example Europe/Warsaw" },
+        "quiet-start": { type: "string", description: "Quiet start, HH:mm" },
+        "quiet-end": { type: "string", description: "Quiet end, HH:mm" },
+        "clear-quiet-hours": { type: "boolean" },
+        "include-open-preview": {
+          type: "string",
+          description: "Explicitly include the captured preview; restored history may duplicate Telegram messages"
+        },
+        "expected-revision": { type: "string" }
+      },
+      async run({ args }) {
+        if (args.enable && args.disable) throw new Error("Choose --enable or --disable");
+        if (args.enable && !args["destination-id"])
+          throw new Error("--enable requires --destination-id from notification settings");
+        if (Boolean(args["quiet-start"]) !== Boolean(args["quiet-end"]))
+          throw new Error("Provide both --quiet-start and --quiet-end");
+        if (args["clear-quiet-hours"] && args["quiet-start"])
+          throw new Error("Choose a quiet window or --clear-quiet-hours");
+        const api = createClient2().notifications;
+        const { settings } = await api.settings();
+        output(
+          await api.configure({
+            expectedRevision: args["expected-revision"] === void 0 ? settings.revision : Number(args["expected-revision"]),
+            enabled: args.enable ? true : args.disable ? false : settings.enabled,
+            destinationId: args["destination-id"] ?? settings.destination?.id,
+            kinds: args.kinds ? args.kinds.split(",") : settings.kinds,
+            timezone: args.timezone ?? settings.timezone,
+            quietHours: args["clear-quiet-hours"] ? null : args["quiet-start"] && args["quiet-end"] ? { start: args["quiet-start"], end: args["quiet-end"] } : settings.quietHours,
+            includeOpenPreview: args["include-open-preview"]
+          })
+        );
+      }
+    }),
+    list: defineCommand2({
+      args: { cursor: { type: "string" }, limit: { type: "string" } },
+      async run({ args }) {
+        output(
+          await createClient2().notifications.list({
+            cursor: args.cursor,
+            limit: args.limit === void 0 ? void 0 : Number(args.limit)
+          })
+        );
+      }
+    }),
+    show: defineCommand2({
+      args: { id: positional2 },
+      async run({ args }) {
+        output(await createClient2().notifications.get(args.id));
+      }
+    }),
+    retry: defineCommand2({
+      args: {
+        id: positional2,
+        "acknowledge-possible-duplicate": {
+          type: "boolean",
+          description: "Telegram may already have received this notice"
+        }
+      },
+      async run({ args }) {
+        if (!args["acknowledge-possible-duplicate"])
+          throw new Error("Explicit retry requires --acknowledge-possible-duplicate");
+        const api = createClient2().notifications;
+        const receipt = await api.get(args.id);
+        output(
+          await api.retry(args.id, {
+            expectedUpdatedAt: receipt.updatedAt,
+            acknowledgePossibleDuplicate: true
+          })
+        );
+      }
+    })
+  }
+});
+
+// src/commands/question.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { defineCommand as defineCommand3 } from "citty";
+var positional3 = { type: "positional", required: true };
+var output2 = (value) => console.log(JSON.stringify(value, null, 2));
+function questionAnswer(args) {
+  const count = Number(args.choice !== void 0) + Number(args.text !== void 0) + Number(args.skip === true);
+  if (count !== 1) throw new Error("Specify exactly one of --choice, --text, or --skip");
+  if (args.skip) return { kind: "skip" };
+  if (args.text !== void 0) {
+    if (!args.text.trim() || Buffer.byteLength(args.text, "utf8") > 4096)
+      throw new Error("Answer text must contain 1\u20134096 UTF-8 bytes");
+    return { kind: "text", text: args.text };
+  }
+  if (!/^[1-4]$/.test(args.choice ?? "")) throw new Error("--choice must be a number from 1 to 4");
+  return { kind: "choice", index: Number(args.choice) - 1 };
+}
+var questionCommand = defineCommand3({
+  meta: {
+    name: "question",
+    description: "Inspect and answer an Agent clarification; answers grant no permissions"
+  },
+  subCommands: {
+    list: defineCommand3({
+      args: { agent: positional3, conversation: { type: "string" } },
+      async run({ args }) {
+        output2(await createClient2().questions(args.agent).list(args.conversation));
+      }
+    }),
+    show: defineCommand3({
+      args: { agent: positional3, id: positional3 },
+      async run({ args }) {
+        output2(await createClient2().questions(args.agent).get(args.id));
+      }
+    }),
+    answer: defineCommand3({
+      args: {
+        agent: positional3,
+        id: positional3,
+        choice: { type: "string", description: "Choice number, starting at 1" },
+        text: { type: "string", description: "Free-text answer" },
+        skip: { type: "boolean", description: "Continue without an answer" },
+        "request-id": { type: "string", description: "Reuse the original UUID for an exact retry" },
+        conversation: {
+          type: "string",
+          description: "Original conversation ID; required for retries"
+        }
+      },
+      async run({ args }) {
+        const answer = questionAnswer(args);
+        if (args["request-id"] && !args.conversation)
+          throw new Error("Retry requires the original --conversation and identical answer");
+        const client = createClient2().questions(args.agent);
+        const observed = await client.get(args.id);
+        const conversationId = args.conversation ?? observed.conversationId;
+        if (conversationId !== observed.conversationId)
+          throw new Error("Question conversation differs");
+        if (answer.kind === "choice" && answer.index >= observed.question.choices.length)
+          throw new Error("That choice does not exist for this question");
+        const requestId = args["request-id"] ?? randomUUID2();
+        console.error(
+          `Question request: ${requestId}; exact retry uses --request-id ${requestId} --conversation ${conversationId} and the same answer. Acceptance does not prove consumption or task completion.`
+        );
+        output2(await client.answer(args.id, { requestId, conversationId, answer }));
+      }
+    })
+  }
+});
+
+// src/commands/queue.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename, extname } from "path";
+import { defineCommand as defineCommand4 } from "citty";
+var positional4 = { type: "positional", required: true };
+var output3 = (value) => console.log(JSON.stringify(value, null, 2));
+var common = { agent: positional4 };
+var entry = { ...common, id: positional4 };
+var expected = {
+  type: "string",
+  required: true,
+  description: "Revision observed in queue list/show"
+};
+var list2 = defineCommand4({
+  args: { ...common, all: { type: "boolean" }, offset: { type: "string", default: "0" } },
+  async run({ args }) {
+    output3(await createClient2().queue(args.agent).list(args.all, Number(args.offset)));
+  }
+});
+var show2 = defineCommand4({
+  args: entry,
+  async run({ args }) {
+    output3(await createClient2().queue(args.agent).get(args.id));
+  }
+});
+var enqueueArgs = {
+  ...common,
+  message: { type: "string" },
+  files: {
+    type: "string",
+    description: "JSON array of local file paths, at most 16 and 25 MiB combined"
+  },
+  "request-id": { type: "string" },
+  "expected-conversation": {
+    type: "string",
+    description: "Original target ID, or none; required for retries"
+  },
+  "expected-selection-revision": {
+    type: "string",
+    description: "Original selection revision; required for retries"
+  }
+};
+async function submit(args, replacement) {
+  const client = createClient2();
+  const agentId = String(args.agent);
+  if (args["request-id"] && (args["expected-conversation"] === void 0 || args["expected-selection-revision"] === void 0))
+    throw new Error(
+      "Exact retry requires --expected-conversation and --expected-selection-revision"
+    );
+  const observed = await client.get(
+    `/api/agents/${encodeURIComponent(agentId)}/conversations?limit=1`
+  );
+  const requestId = typeof args["request-id"] === "string" ? args["request-id"] : randomUUID3();
+  const expectedSelection = {
+    conversationId: args["expected-conversation"] === void 0 ? observed.selection.conversationId : args["expected-conversation"] === "none" ? null : String(args["expected-conversation"]),
+    revision: args["expected-selection-revision"] === void 0 ? observed.selection.revision : Number(args["expected-selection-revision"])
+  };
+  const paths = args.files ? JSON.parse(String(args.files)) : [];
+  if (!Array.isArray(paths) || paths.length > 16 || paths.some((p) => typeof p !== "string"))
+    throw new Error("--files must be a JSON array of at most 16 paths");
+  let bytes = 0;
+  const original = replacement && (args.files === void 0 || args.message === void 0) ? await client.queue(agentId).input(replacement.id) : void 0;
+  const attachments = args.files === void 0 && original ? original.attachments : paths.map((path) => {
+    const stat = statSync(path);
+    bytes += stat.size;
+    if (!stat.isFile() || bytes > 25 * 1024 * 1024)
+      throw new Error("Files must total at most 25 MiB");
+    const mime = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".webp": "image/webp",
+      ".gif": "image/gif",
+      ".txt": "text/plain",
+      ".pdf": "application/pdf"
+    };
+    return {
+      name: basename(path),
+      mimeType: mime[extname(path).toLowerCase()] ?? "application/octet-stream",
+      data: readFileSync2(path).toString("base64")
+    };
+  });
+  console.error(
+    `Queue request: ${requestId}; retry with --request-id ${requestId} --expected-conversation ${expectedSelection.conversationId ?? "none"} --expected-selection-revision ${expectedSelection.revision} and identical message/files${replacement ? " and original --expected-revision" : ""}.`
+  );
+  const input = {
+    requestId,
+    expectedSelection,
+    message: String(args.message ?? original?.message ?? ""),
+    attachments
+  };
+  output3(
+    replacement ? await client.queue(agentId).edit(replacement.id, { ...input, expectedRevision: replacement.expectedRevision }) : await client.queue(agentId).enqueue(input)
+  );
+}
+var add = defineCommand4({
+  args: enqueueArgs,
+  async run({ args }) {
+    await submit(args);
+  }
+});
+var edit = defineCommand4({
+  args: { ...enqueueArgs, id: positional4, "expected-revision": expected },
+  async run({ args }) {
+    await submit(args, { id: args.id, expectedRevision: Number(args["expected-revision"]) });
+  }
+});
+var remove = defineCommand4({
+  args: { ...entry, "expected-revision": expected },
+  async run({ args }) {
+    output3(
+      await createClient2().queue(args.agent).remove(args.id, Number(args["expected-revision"]))
+    );
+  }
+});
+var control = (paused) => defineCommand4({
+  args: { ...common, "expected-revision": expected },
+  async run({ args }) {
+    output3(
+      await createClient2().queue(args.agent).pause(paused, Number(args["expected-revision"]))
+    );
+  }
+});
+var stop = defineCommand4({
+  args: { ...common, "expected-revision": expected },
+  async run({ args }) {
+    output3(await createClient2().queue(args.agent).stop(Number(args["expected-revision"])));
+  }
+});
+var reconcile = defineCommand4({
+  args: {
+    ...entry,
+    "expected-revision": expected,
+    acknowledge: {
+      type: "boolean",
+      description: "Acknowledge this input may already have acted; close without replay"
+    }
+  },
+  async run({ args }) {
+    if (!args.acknowledge)
+      throw new Error("--acknowledge is required; this input may already have acted");
+    output3(
+      await createClient2().queue(args.agent).reconcile(args.id, Number(args["expected-revision"]))
+    );
+  }
+});
+var queueCommand = defineCommand4({
+  meta: {
+    name: "queue",
+    description: "Retain follow-ups, inspect delivery and control future claims"
+  },
+  subCommands: {
+    list: list2,
+    show: show2,
+    add,
+    edit,
+    remove,
+    pause: control(true),
+    resume: control(false),
+    stop,
+    reconcile
+  }
+});
+
+// src/commands/agent.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync } from "fs";
+import { basename as basename2, extname as extname2 } from "path";
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/question-prompt.ts
+function safe(text2) {
+  return Array.from(text2, (character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 && code !== 10 || code >= 127 && code <= 159 ? `\\x${code.toString(16).padStart(2, "0")}` : character;
+  }).join("");
+}
+function hasAnswerControl(text2) {
+  return Array.from(text2).some((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 && ![9, 10, 13].includes(code) || code >= 127 && code <= 159;
+  });
+}
+async function promptForQuestion(item, prompt) {
+  if (item.status !== "pending" || item.expiresAt <= Date.now()) return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1, item.expiresAt - Date.now()));
+  timer.unref();
+  try {
+    prompt.write(`Question ${item.id} (conversation ${item.conversationId})`);
+    prompt.write(safe(item.question.prompt));
+    item.question.choices.forEach((choice, index) => {
+      prompt.write(
+        `${index + 1}. ${safe(choice.label)}${index === item.question.recommendedIndex ? " (Recommended)" : ""}`
+      );
+      if (choice.description) prompt.write(`   ${safe(choice.description)}`);
+    });
+    prompt.write("Choose a number, o for Other, or s to Skip. Answers do not grant permission.");
+    while (!controller.signal.aborted) {
+      const value = (await prompt.question("Answer: ", controller.signal)).trim();
+      if (controller.signal.aborted) return null;
+      if (value.toLowerCase() === "s") return { kind: "skip" };
+      if (/^[1-4]$/.test(value) && Number(value) <= item.question.choices.length)
+        return { kind: "choice", index: Number(value) - 1 };
+      if (value.toLowerCase() === "o") {
+        const text2 = await prompt.question("Your answer: ", controller.signal);
+        if (controller.signal.aborted) return null;
+        if (text2.trim() && Buffer.byteLength(text2, "utf8") <= 4096 && !hasAnswerControl(text2))
+          return { kind: "text", text: text2 };
+        prompt.write("Enter 1\u20134096 UTF-8 bytes without control characters.");
+      } else prompt.write("Choose an explicit number, o, or s; no answer is selected by default.");
+    }
+    return null;
+  } catch {
+    prompt.write("Question prompt closed or expired. No answer was submitted.");
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/commands/agent.ts
 var IMAGE_MIME = {
   ".png": "image/png",
@@ -257,9 +831,9 @@ var IMAGE_MIME = {
 };
 function loadImages(paths) {
   return paths.map((p) => {
-    const mimeType = IMAGE_MIME[extname(p).toLowerCase()];
+    const mimeType = IMAGE_MIME[extname2(p).toLowerCase()];
     if (!mimeType) throw new Error(`unsupported image type: ${p} (png/jpg/gif/webp only)`);
-    return { name: basename(p), mimeType, data: readFileSync2(p).toString("base64") };
+    return { name: basename2(p), mimeType, data: readFileSync3(p).toString("base64") };
   });
 }
 var FILE_MIME = {
@@ -273,15 +847,15 @@ var FILE_MIME = {
 };
 function loadFiles(paths) {
   return paths.map((p) => ({
-    name: basename(p),
-    mimeType: FILE_MIME[extname(p).toLowerCase()] ?? "application/octet-stream",
-    data: readFileSync2(p).toString("base64")
+    name: basename2(p),
+    mimeType: FILE_MIME[extname2(p).toLowerCase()] ?? "application/octet-stream",
+    data: readFileSync3(p).toString("base64")
   }));
 }
 function asPaths(v) {
   return v ? Array.isArray(v) ? v : [v] : [];
 }
-var spawnCmd = defineCommand({
+var spawnCmd = defineCommand5({
   meta: { name: "spawn", description: "Spawn an agent from a profile into a team" },
   args: {
     profile: { type: "string", required: true, description: "Profile id" },
@@ -317,7 +891,7 @@ var spawnCmd = defineCommand({
     console.log(`dir: ${agent.dir}`);
   }
 });
-var editCmd = defineCommand({
+var editCmd = defineCommand5({
   meta: {
     name: "edit",
     description: "Edit agent settings (name, model override, reasoning level, telegram mirror)"
@@ -367,7 +941,7 @@ var editCmd = defineCommand({
     console.log(`updated agent ${agent.id} (${agent.name})`);
   }
 });
-var listCmd = defineCommand({
+var listCmd = defineCommand5({
   meta: { name: "list", description: "List agents" },
   args: {
     all: { type: "boolean", description: "Include archived agents" },
@@ -376,12 +950,12 @@ var listCmd = defineCommand({
   async run({ args }) {
     const client = createClient2();
     const q = args.all ? "?includeArchived=true" : "";
-    const list5 = await client.get(`/api/agents${q}`);
-    if (list5.length === 0) {
+    const list8 = await client.get(`/api/agents${q}`);
+    if (list8.length === 0) {
       console.log("(no agents)");
       return;
     }
-    const rows = list5.map(
+    const rows = list8.map(
       (a) => args.long ? [a.id, a.status, a.name, a.profileId] : (
         // Short UUID prefix — all CLI commands accept 4+ char prefixes now.
         [a.id.slice(0, 8), a.status, a.name]
@@ -390,7 +964,7 @@ var listCmd = defineCommand({
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var showCmd = defineCommand({
+var showCmd = defineCommand5({
   meta: { name: "show", description: "Show agent details" },
   args: {
     id: { type: "positional", required: true }
@@ -413,7 +987,7 @@ var showCmd = defineCommand({
     }
   }
 });
-var archiveCmd = defineCommand({
+var archiveCmd = defineCommand5({
   meta: { name: "archive", description: "Archive an agent" },
   args: {
     id: { type: "positional", required: true }
@@ -424,7 +998,7 @@ var archiveCmd = defineCommand({
     console.log(`archived agent ${args.id}`);
   }
 });
-var unarchiveCmd = defineCommand({
+var unarchiveCmd = defineCommand5({
   meta: { name: "unarchive", description: "Restore an archived agent to idle" },
   args: {
     id: { type: "positional", required: true }
@@ -435,7 +1009,7 @@ var unarchiveCmd = defineCommand({
     console.log(`unarchived agent ${args.id}`);
   }
 });
-var deleteCmd = defineCommand({
+var deleteCmd = defineCommand5({
   meta: { name: "delete", description: "Permanently delete an agent and its data" },
   args: {
     id: { type: "positional", required: true }
@@ -463,13 +1037,13 @@ function buildChatRequest(message, attachments, bashApprovalMode) {
   };
 }
 function terminalSafe(value) {
-  let safe = "";
+  let safe2 = "";
   for (const character of value) {
     const code = character.charCodeAt(0);
     const isControl = code <= 9 || code >= 11 && code <= 31 || code >= 127 && code <= 159;
-    safe += isControl ? `\\x${code.toString(16).padStart(2, "0")}` : character;
+    safe2 += isControl ? `\\x${code.toString(16).padStart(2, "0")}` : character;
   }
-  return safe;
+  return safe2;
 }
 async function promptForCommandApproval(approval, prompt) {
   prompt.write("  [shell command approval required]");
@@ -552,7 +1126,7 @@ function printEvent(e, state) {
         process.stdout.write("\n");
         state.inDeltaStream = false;
       }
-      const out = basename(e.name).replace(/[^\w.-]/g, "_") || "file";
+      const out = basename2(e.name).replace(/[^\w.-]/g, "_") || "file";
       writeFileSync(out, Buffer.from(e.data, "base64"));
       console.log(`  [file received: saved to ./${out} (${e.mimeType})]`);
       break;
@@ -567,13 +1141,15 @@ function printEvent(e, state) {
   }
 }
 async function streamTurn(client, agentId, message, attachments, options = { bashApprovalMode: "auto_deny" }) {
+  const head = await client.get(`/api/agents/${agentId}/sessions/head`);
   const state = { inDeltaStream: false };
   const respondedApprovalIds = /* @__PURE__ */ new Set();
-  for await (const frame of client.stream(
-    "POST",
-    `/api/agents/${agentId}/chat`,
-    buildChatRequest(message, attachments, options.bashApprovalMode)
-  )) {
+  const promptedQuestionIds = /* @__PURE__ */ new Set();
+  for await (const frame of client.stream("POST", `/api/agents/${agentId}/chat`, {
+    ...buildChatRequest(message, attachments, options.bashApprovalMode),
+    ...options.questionPrompt ? { questionMode: "tty" } : {},
+    expectedSelection: options.expectedSelection ?? head.selection
+  })) {
     if (frame.kind === "event") {
       const event = frame.event;
       if (event.type === "command_approval") {
@@ -587,6 +1163,33 @@ async function streamTurn(client, agentId, message, attachments, options = { bas
         } else {
           printCommandApprovalStatus(approval);
         }
+      } else if (event.type === "agent_question") {
+        closeDeltaLine(state);
+        const item = event.question;
+        if (item.agentId !== agentId || promptedQuestionIds.has(item.id)) continue;
+        promptedQuestionIds.add(item.id);
+        if (!options.questionPrompt) {
+          console.log(
+            `Question ${item.id}: use bazilion question show ${agentId} ${item.id} in a separate terminal.`
+          );
+          continue;
+        }
+        const answer = await promptForQuestion(item, options.questionPrompt);
+        if (!answer) continue;
+        const requestId = randomUUID4();
+        console.error(
+          `Question request ${requestId}; exact retry uses bazilion question answer ${agentId} ${item.id} --request-id ${requestId} --conversation ${item.conversationId} and the same answer option.`
+        );
+        try {
+          const result = await client.questions(agentId).answer(item.id, { requestId, conversationId: item.conversationId, answer });
+          console.log(
+            result.kind === "held" ? "Answer awaits communication approval; it has not reached the Agent." : "Answer accepted; consumption and task completion are separate."
+          );
+        } catch {
+          console.error(
+            "Answer acknowledgement unavailable. Inspect the question before retrying the exact request above."
+          );
+        }
       } else if (event.type !== "user_message") {
         printEvent(event, state);
       }
@@ -596,7 +1199,7 @@ async function streamTurn(client, agentId, message, attachments, options = { bas
     }
   }
 }
-var chatCmd = defineCommand({
+var chatCmd = defineCommand5({
   meta: { name: "chat", description: "Chat with an agent" },
   args: {
     id: { type: "positional", required: true },
@@ -630,6 +1233,10 @@ var chatCmd = defineCommand({
             approvalPrompt: {
               question: (question) => rl2.question(question),
               write: (line) => console.log(line)
+            },
+            questionPrompt: {
+              question: (text2, signal) => rl2.question(text2, { signal }),
+              write: (line) => console.log(line)
             }
           } : {}
         });
@@ -643,10 +1250,19 @@ var chatCmd = defineCommand({
     const rl = createInterface({ input: stdin, output: stdout });
     try {
       if (bashApprovalMode === "interactive") {
+        let retryDraft = "";
         while (true) {
+          const observed = await client.get(
+            `/api/agents/${resolved.agent.id}/sessions/head`
+          );
           let line;
           try {
-            line = await rl.question("> ");
+            const answer = rl.question("> ");
+            if (retryDraft) {
+              rl.write(retryDraft);
+              retryDraft = "";
+            }
+            line = await answer;
           } catch {
             break;
           }
@@ -656,13 +1272,21 @@ var chatCmd = defineCommand({
           try {
             await streamTurn(client, resolved.agent.id, trimmed, void 0, {
               bashApprovalMode,
+              expectedSelection: observed.selection,
+              questionPrompt: {
+                question: (text2, signal) => rl.question(text2, { signal }),
+                write: (line2) => console.log(line2)
+              },
               approvalPrompt: {
                 question: (question) => rl.question(question),
-                write: (output) => console.log(output)
+                write: (output4) => console.log(output4)
               }
             });
           } catch (err) {
-            console.error(`error: ${err.message}`);
+            retryDraft = trimmed;
+            console.error(
+              `error: ${err.message}. Review the preserved draft before retrying.`
+            );
           }
         }
       } else {
@@ -690,29 +1314,7 @@ var chatCmd = defineCommand({
     }
   }
 });
-var chatResetCmd = defineCommand({
-  meta: { name: "chat-reset", description: "Reset an agent's chat history to empty" },
-  args: {
-    id: { type: "positional", required: true },
-    force: { type: "boolean", description: "Skip the y/N prompt" }
-  },
-  async run({ args }) {
-    if (!args.force) {
-      process.stdout.write(`reset all chat history for ${args.id}? [y/N] `);
-      const answer = await new Promise((resolve5) => {
-        process.stdin.once("data", (d) => resolve5(String(d).trim().toLowerCase()));
-      });
-      if (answer !== "y" && answer !== "yes") {
-        console.log("aborted");
-        return;
-      }
-    }
-    const client = createClient2();
-    await client.post(`/api/agents/${args.id}/chat/reset`);
-    console.log(`reset chat history for ${args.id}`);
-  }
-});
-var chatTrimCmd = defineCommand({
+var chatTrimCmd = defineCommand5({
   meta: {
     name: "chat-trim",
     description: "Keep the first N messages of an agent's chat history; drop the rest"
@@ -727,7 +1329,8 @@ var chatTrimCmd = defineCommand({
       throw new Error("--keep must be a non-negative integer");
     }
     const client = createClient2();
-    const body = { keepCount: n };
+    const head = await client.get(`/api/agents/${args.id}/sessions/head`);
+    const body = { keepCount: n, expectedSelection: head.selection };
     const res = await client.post(
       `/api/agents/${args.id}/chat/truncate`,
       body
@@ -742,7 +1345,7 @@ function formatBytes(n) {
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
   return `${(n / (1024 * 1024)).toFixed(2)} MiB`;
 }
-var chatContextCmd = defineCommand({
+var chatContextCmd = defineCommand5({
   meta: {
     name: "chat-context",
     description: "Break down what consumes the agent's context window"
@@ -826,7 +1429,7 @@ var chatContextCmd = defineCommand({
 function estimate(chars) {
   return Math.ceil(Math.max(0, chars) / 4);
 }
-var chatCompactCmd = defineCommand({
+var chatCompactCmd = defineCommand5({
   meta: {
     name: "chat-compact",
     description: "Summarize the head of an agent's chat log, preserving the tail verbatim"
@@ -866,6 +1469,8 @@ var chatCompactCmd = defineCommand({
     if (keepTailNum !== void 0) body.keepTail = Math.floor(keepTailNum);
     if (args.instructions) body.customInstructions = args.instructions;
     const client = createClient2();
+    const head = await client.get(`/api/agents/${args.id}/sessions/head`);
+    body.expectedSelection = head.selection;
     const res = await client.post(`/api/agents/${args.id}/chat/compact`, body);
     console.log(
       `compacted: ${res.before} \u2192 ${res.after} entries (${res.summarized} summarized, ${res.keptTail} tail kept verbatim)`
@@ -878,7 +1483,7 @@ var chatCompactCmd = defineCommand({
     console.log(res.summary);
   }
 });
-var skillAddCmd = defineCommand({
+var skillAddCmd = defineCommand5({
   meta: { name: "add", description: "Attach a skill to an agent" },
   args: {
     agent: { type: "positional", required: true },
@@ -914,7 +1519,7 @@ function printSkillFindings(findings) {
     console.error(`  ${f.severity}: ${f.code}${line} - ${f.message}`);
   }
 }
-var skillRmCmd = defineCommand({
+var skillRmCmd = defineCommand5({
   meta: { name: "rm", description: "Detach a skill from an agent" },
   args: {
     agent: { type: "positional", required: true },
@@ -926,14 +1531,14 @@ var skillRmCmd = defineCommand({
     console.log(`detached skill ${args.skill} from ${args.agent}`);
   }
 });
-var skillCmd = defineCommand({
+var skillCmd = defineCommand5({
   meta: { name: "skill", description: "Attach/detach skills on an agent" },
   subCommands: {
     add: skillAddCmd,
     rm: skillRmCmd
   }
 });
-var moveCmd = defineCommand({
+var moveCmd = defineCommand5({
   meta: { name: "move", description: "Move an agent to a different team" },
   args: {
     agent: { type: "positional", required: true },
@@ -958,7 +1563,7 @@ var moveCmd = defineCommand({
     console.log(`moved ${args.agent} to team ${args.team}`);
   }
 });
-var sessionHeadCmd = defineCommand({
+var sessionHeadCmd = defineCommand5({
   meta: {
     name: "session-head",
     description: "Print the agent's current session file head (for stale-tab checks)"
@@ -977,7 +1582,7 @@ var sessionHeadCmd = defineCommand({
     console.log(head.file ? `${head.file} (${head.size} bytes)` : "(no session yet)");
   }
 });
-var cancelCmd = defineCommand({
+var cancelCmd = defineCommand5({
   meta: { name: "cancel", description: "Abort the agent's currently-running turn" },
   args: {
     id: { type: "positional", required: true }
@@ -988,7 +1593,7 @@ var cancelCmd = defineCommand({
     console.log(`cancelled active turn for ${args.id}`);
   }
 });
-var reviewConfigCmd = defineCommand({
+var reviewConfigCmd = defineCommand5({
   meta: { name: "review-config", description: "Inspect or configure reviewed learning" },
   args: {
     id: { type: "positional", required: true, description: "Agent id or prefix" },
@@ -1023,7 +1628,7 @@ var reviewConfigCmd = defineCommand({
     console.log(`turns since last review: ${config.turnsSinceLast}`);
   }
 });
-var reviewCmd = defineCommand({
+var reviewCmd = defineCommand5({
   meta: { name: "review", description: "Enqueue a reviewed-learning pass" },
   args: { id: { type: "positional", required: true, description: "Agent id or prefix" } },
   async run({ args }) {
@@ -1033,7 +1638,7 @@ var reviewCmd = defineCommand({
     console.log(`review ${response.review.id} ${response.review.status}`);
   }
 });
-var reviewsCmd = defineCommand({
+var reviewsCmd = defineCommand5({
   meta: { name: "reviews", description: "List reviewed-learning history" },
   args: {
     id: { type: "positional", required: true, description: "Agent id or prefix" },
@@ -1058,7 +1663,7 @@ var reviewsCmd = defineCommand({
     }
   }
 });
-var lessonsCmd = defineCommand({
+var lessonsCmd = defineCommand5({
   meta: { name: "lessons", description: "List reviewed lesson proposals" },
   args: {
     id: { type: "positional", required: true, description: "Agent id or prefix" },
@@ -1096,7 +1701,7 @@ async function locateProposal(id) {
   throw new Error(`lesson proposal not found: ${id}`);
 }
 function lessonDecisionCmd(decision2) {
-  return defineCommand({
+  return defineCommand5({
     meta: { name: decision2, description: `${decision2} a reviewed lesson proposal` },
     args: {
       id: { type: "positional", required: true, description: "Proposal id or prefix" },
@@ -1113,7 +1718,7 @@ function lessonDecisionCmd(decision2) {
     }
   });
 }
-var lessonEditCmd = defineCommand({
+var lessonEditCmd = defineCommand5({
   meta: { name: "edit", description: "Edit a pending reviewed lesson proposal" },
   args: {
     id: { type: "positional", required: true, description: "Proposal id or prefix" },
@@ -1132,7 +1737,7 @@ var lessonEditCmd = defineCommand({
     console.log(`updated ${response.proposal.id} v${response.proposal.version}`);
   }
 });
-var lessonCmd = defineCommand({
+var lessonCmd = defineCommand5({
   meta: { name: "lesson", description: "Edit or decide a reviewed lesson proposal" },
   subCommands: {
     edit: lessonEditCmd,
@@ -1141,7 +1746,7 @@ var lessonCmd = defineCommand({
     revoke: lessonDecisionCmd("revoke")
   }
 });
-var agentCommand = defineCommand({
+var agentCommand = defineCommand5({
   meta: { name: "agent", description: "Manage agent instances" },
   subCommands: {
     spawn: spawnCmd,
@@ -1152,7 +1757,6 @@ var agentCommand = defineCommand({
     unarchive: unarchiveCmd,
     delete: deleteCmd,
     chat: chatCmd,
-    "chat-reset": chatResetCmd,
     "chat-trim": chatTrimCmd,
     "chat-context": chatContextCmd,
     "chat-compact": chatCompactCmd,
@@ -1169,8 +1773,8 @@ var agentCommand = defineCommand({
 });
 
 // src/commands/approval.ts
-import { defineCommand as defineCommand2 } from "citty";
-var list = defineCommand2({
+import { defineCommand as defineCommand6 } from "citty";
+var list3 = defineCommand6({
   meta: { name: "list", description: "List communication approval queue/history" },
   args: {
     status: { type: "string", default: "pending" },
@@ -1198,7 +1802,7 @@ var list = defineCommand2({
       console.log(line);
   }
 });
-var show = defineCommand2({
+var show3 = defineCommand6({
   meta: { name: "show", description: "Show one approval including payload and audit events" },
   args: { id: { type: "positional", required: true }, json: { type: "boolean" } },
   async run({ args }) {
@@ -1219,7 +1823,7 @@ var show = defineCommand2({
   }
 });
 function decision(name) {
-  return defineCommand2({
+  return defineCommand6({
     meta: {
       name,
       description: name === "approve" ? "Approve and deliver one captured attempt" : `${name === "deny" ? "Deny" : "Cancel"} one pending attempt`
@@ -1244,11 +1848,11 @@ function decision(name) {
 function endpoint(value) {
   return value.kind === "agent" ? `agent:${value.id}` : value.kind === "user" ? `user:${value.teamId}` : `outside:${value.teamId}`;
 }
-var approvalCommand = defineCommand2({
+var approvalCommand = defineCommand6({
   meta: { name: "approval", description: "Manage communication approval queue and history" },
   subCommands: {
-    list,
-    show,
+    list: list3,
+    show: show3,
     approve: decision("approve"),
     deny: decision("deny"),
     cancel: decision("cancel")
@@ -1256,8 +1860,8 @@ var approvalCommand = defineCommand2({
 });
 
 // src/commands/attention.ts
-import { defineCommand as defineCommand3 } from "citty";
-var list2 = defineCommand3({
+import { defineCommand as defineCommand7 } from "citty";
+var list4 = defineCommand7({
   meta: { name: "list", description: "List operator attention items" },
   args: {
     state: { type: "string", default: "open" },
@@ -1286,7 +1890,7 @@ var list2 = defineCommand3({
       console.error(`warning: ${source.kind} unavailable: ${source.error}`);
   }
 });
-var summary = defineCommand3({
+var summary = defineCommand7({
   meta: { name: "summary", description: "Summarize open attention items" },
   args: { json: { type: "boolean" } },
   async run({ args }) {
@@ -1299,7 +1903,7 @@ var summary = defineCommand3({
   }
 });
 function mutation(name) {
-  return defineCommand3({
+  return defineCommand7({
     meta: { name, description: `${name} one informational attention item` },
     args: {
       key: { type: "positional", required: true },
@@ -1315,7 +1919,7 @@ function mutation(name) {
     }
   });
 }
-var acknowledgeAll = defineCommand3({
+var acknowledgeAll = defineCommand7({
   meta: { name: "acknowledge-all", description: "Acknowledge all open informational items" },
   args: { yes: { type: "boolean" }, json: { type: "boolean" } },
   async run({ args }) {
@@ -1330,10 +1934,10 @@ var acknowledgeAll = defineCommand3({
 function context(item) {
   return [item.agentName, item.teamName].filter(Boolean).join(" / ") || "system";
 }
-var attentionCommand = defineCommand3({
+var attentionCommand = defineCommand7({
   meta: { name: "attention", description: "Inspect the operator attention center" },
   subCommands: {
-    list: list2,
+    list: list4,
     summary,
     acknowledge: mutation("acknowledge"),
     unacknowledge: mutation("unacknowledge"),
@@ -1343,7 +1947,7 @@ var attentionCommand = defineCommand3({
 
 // src/commands/auth.ts
 import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
-import { defineCommand as defineCommand4 } from "citty";
+import { defineCommand as defineCommand8 } from "citty";
 var CLI_OPENAI_LOGIN_TIMEOUT_MS = 10 * 6e4;
 function createCliOpenAILoginLifetime(timeoutMs = CLI_OPENAI_LOGIN_TIMEOUT_MS) {
   const controller = new AbortController();
@@ -1365,7 +1969,7 @@ function createCliOpenAILoginLifetime(timeoutMs = CLI_OPENAI_LOGIN_TIMEOUT_MS) {
 function promptAbortError(signal) {
   return signal.reason instanceof Error ? signal.reason : new DOMException("OAuth prompt cancelled", "AbortError");
 }
-function answerCliOpenAIPrompt(prompt, input = process.stdin, output = process.stdout, loginMethod = "browser", loginSignal) {
+function answerCliOpenAIPrompt(prompt, input = process.stdin, output4 = process.stdout, loginMethod = "browser", loginSignal) {
   if (prompt.type === "select") {
     const option = prompt.options.find((candidate) => candidate.id === loginMethod);
     return option ? Promise.resolve(option.id) : Promise.reject(
@@ -1374,7 +1978,7 @@ function answerCliOpenAIPrompt(prompt, input = process.stdin, output = process.s
       )
     );
   }
-  output.write(`${prompt.message}: `);
+  output4.write(`${prompt.message}: `);
   return new Promise((resolve5, reject) => {
     let settled = false;
     const signal = prompt.signal;
@@ -1434,7 +2038,7 @@ function formatExpiry(ms) {
   const d = new Date(ms);
   return d.toISOString().replace(/\.\d+Z$/, "Z");
 }
-var openaiLoginCmd = defineCommand4({
+var openaiLoginCmd = defineCommand8({
   meta: {
     name: "login",
     description: "Connect your ChatGPT account via OAuth"
@@ -1501,7 +2105,7 @@ var openaiLoginCmd = defineCommand4({
     console.log("  bazilion provider models-set openai-codex gpt-5.3-codex-spark");
   }
 });
-var openaiLogoutCmd = defineCommand4({
+var openaiLogoutCmd = defineCommand8({
   meta: {
     name: "logout",
     description: "Forget the stored ChatGPT OAuth credentials"
@@ -1512,7 +2116,7 @@ var openaiLogoutCmd = defineCommand4({
     console.log("disconnected ChatGPT OAuth credentials");
   }
 });
-var openaiStatusCmd = defineCommand4({
+var openaiStatusCmd = defineCommand8({
   meta: {
     name: "status",
     description: "Show ChatGPT OAuth connection status"
@@ -1529,7 +2133,7 @@ var openaiStatusCmd = defineCommand4({
     console.log(`access token expires: ${formatExpiry(status.expiresAt)}`);
   }
 });
-var openaiCmd = defineCommand4({
+var openaiCmd = defineCommand8({
   meta: {
     name: "openai",
     description: "Manage ChatGPT (OAuth) authentication"
@@ -1540,7 +2144,7 @@ var openaiCmd = defineCommand4({
     status: openaiStatusCmd
   }
 });
-var authCommand = defineCommand4({
+var authCommand = defineCommand8({
   meta: {
     name: "auth",
     description: "OAuth-based provider authentication (ChatGPT account, etc.)"
@@ -1557,7 +2161,7 @@ import {
   createHash as createHash3,
   pbkdf2Sync,
   randomBytes,
-  randomUUID as randomUUID2
+  randomUUID as randomUUID7
 } from "crypto";
 import {
   chmodSync as chmodSync2,
@@ -1573,26 +2177,112 @@ import {
   mkdtempSync,
   openSync as openSync2,
   readdirSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readSync,
   renameSync as renameSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename3, dirname as dirname2, isAbsolute, parse, posix, relative, resolve as resolve2 } from "path";
-import { DatabaseSync, backup as sqliteBackup } from "node:sqlite";
+import { basename as basename4, dirname as dirname2, isAbsolute, parse, posix, relative, resolve as resolve2 } from "path";
+import { DatabaseSync as DatabaseSync2, backup as sqliteBackup } from "node:sqlite";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { Decrypter, Encrypter } from "age-encryption";
-import { defineCommand as defineCommand5 } from "citty";
-import { extract, list as list3 } from "tar";
+import { defineCommand as defineCommand9 } from "citty";
+import { extract, list as list5 } from "tar";
+
+// src/backup-queue-recovery.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { DatabaseSync } from "node:sqlite";
+function pauseRestoredUserQueue(database) {
+  const db = new DatabaseSync(database);
+  try {
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec("PRAGMA journal_mode = DELETE");
+    db.exec("PRAGMA synchronous = FULL");
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const unresolved = "status IN ('pending','claimed','running','held','uncertain')";
+      db.exec(`INSERT OR IGNORE INTO user_queue_controls (agent_id)
+        SELECT DISTINCT agent_id FROM user_queue_items WHERE ${unresolved}`);
+      db.exec(`UPDATE user_queue_controls SET paused = 1, revision = revision + 1,
+        reason = 'restored_backup' WHERE agent_id IN
+        (SELECT agent_id FROM user_queue_items WHERE ${unresolved})`);
+      const now = Date.now();
+      db.prepare(`INSERT INTO notification_settings
+        (singleton, restore_paused, restore_history_uncertain, kinds_json, updated_at) VALUES (1, 1, 1, ?, ?)
+        ON CONFLICT(singleton) DO UPDATE SET enabled=0, restore_paused=1, restore_history_uncertain=1,
+          revision=revision+1, updated_at=MAX(updated_at+1, excluded.updated_at)`).run(
+        JSON.stringify([
+          "communication_approval",
+          "lesson_proposal",
+          "review_failure",
+          "trigger_failure",
+          "agent_loop_break"
+        ]),
+        now
+      );
+      db.prepare(`UPDATE notification_receipts SET state='uncertain', diagnostic='restored_backup',
+        updated_at=MAX(updated_at+1, ?) WHERE state='sending'`).run(now);
+      db.prepare(`UPDATE notification_receipts SET state='suppressed', diagnostic='restore_paused',
+        updated_at=MAX(updated_at+1, ?) WHERE state='deferred'`).run(now);
+      db.prepare(`UPDATE agent_questions SET status = 'cancelled', no_answer_reason = 'restored_backup',
+        settled_at = ?, continuation = 'interrupted', revision = revision + 1 WHERE status = 'pending'`).run(
+        now
+      );
+      db.exec(`UPDATE agent_questions SET continuation = 'interrupted', revision = revision + 1
+        WHERE continuation = 'unconfirmed'`);
+      const questionApprovals = db.prepare(`SELECT DISTINCT a.id FROM communication_approvals a
+        JOIN agent_questions q ON a.id IN (q.delivery_approval_id, q.answer_approval_id)
+        WHERE q.status != 'pending' AND a.status = 'pending'
+          AND a.payload_kind IN ('question_delivery', 'question_answer')`).all();
+      for (const approval of questionApprovals) {
+        db.prepare(`UPDATE communication_approvals SET status = 'cancelled', decided_at = ?,
+          decided_by = 'system', decision_reason = 'Restored question has no live continuation',
+          updated_at = ? WHERE id = ? AND status = 'pending'`).run(now, now, approval.id);
+        db.prepare(`INSERT INTO communication_approval_events (id, approval_id, event, actor, detail, created_at)
+          VALUES (?, ?, 'cancelled', 'system', 'Restored question has no live continuation', ?)`).run(
+          randomUUID5(),
+          approval.id,
+          now
+        );
+      }
+      db.prepare(`UPDATE user_queue_items SET status = 'uncertain', revision = revision + 1,
+        diagnostic = 'Restored backup: this input may already have acted; reconcile before resuming',
+        updated_at = ?, finished_at = ? WHERE ${unresolved}`).run(now, now);
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  } finally {
+    db.close();
+  }
+}
 
 // src/backup-schema.ts
 import { createHash } from "crypto";
 var CANONICAL_MIGRATION = "0001_init";
-var CANONICAL_SCHEMA_HASH = "4bde209eb0bf9851bf1f01fc96263f165a1799c81e720ddea463169a0d6c0d51";
+var CANONICAL_SCHEMA_HASH = "278a7649d6017011b97405306760af3fdd337f068693e24b18cab43421a0c723";
 var CANONICAL_OBJECTS = [
+  ["table", "notification_settings"],
+  ["table", "notification_receipts"],
+  ["index", "notification_receipts_state"],
+  ["index", "notification_receipts_time"],
+  ["table", "agent_questions"],
+  ["table", "question_receipt_key"],
+  ["index", "agent_questions_one_pending"],
+  ["index", "agent_questions_agent_time"],
+  ["table", "user_queue_controls"],
+  ["table", "user_queue_items"],
+  ["table", "user_queue_attachments"],
+  ["index", "user_queue_agent_order"],
+  ["index", "user_queue_status"],
+  ["index", "agent_conversations_agent_time"],
+  ["table", "agent_conversations"],
+  ["table", "agent_conversation_selection"],
+  ["index", "agent_results_team_time"],
   ["index", "agent_triggers_agent"],
   ["index", "agent_triggers_enabled"],
   ["index", "agent_loop_break_events_agent_time"],
@@ -1618,6 +2308,7 @@ var CANONICAL_OBJECTS = [
   ["index", "web_tokens_active"],
   ["index", "web_sessions_active"],
   ["index", "web_sessions_device"],
+  ["table", "agent_results"],
   ["table", "agent_skills"],
   ["table", "agent_loop_break_events"],
   ["table", "agent_lesson_proposals"],
@@ -1700,10 +2391,16 @@ function assertCanonicalBackupSchema(db) {
       "canonical schema fingerprint does not match this Bazilion release; restore a backup created from the current clean-install schema"
     );
   }
+  for (const row2 of db.prepare("SELECT id, bytes, byte_length, sha256 FROM agent_results WHERE deleted_at IS NULL").iterate()) {
+    const bytes = row2.bytes;
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== row2.byte_length || createHash("sha256").update(bytes).digest("hex") !== row2.sha256) {
+      throw new Error(`Result snapshot integrity verification failed: ${row2.id}`);
+    }
+  }
 }
 
 // src/daemon-liveness.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID6 } from "crypto";
 import {
   chmodSync,
   closeSync,
@@ -1714,13 +2411,13 @@ import {
   lstatSync,
   mkdirSync,
   openSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   realpathSync,
   renameSync,
   rmSync,
   writeSync
 } from "fs";
-import { basename as basename2, dirname, join as join2, resolve } from "path";
+import { basename as basename3, dirname, join as join2, resolve } from "path";
 var DAEMON_LIVENESS_FILENAME = "daemon-runtime.json";
 var STALE_AFTER_MS = 6e4;
 var PROBE_TIMEOUT_MS = 750;
@@ -1732,7 +2429,7 @@ function canonicalHomeIdentity(home) {
     if (errorCode(error) !== "ENOENT") throw error;
     const parent = dirname(absolute);
     if (parent === absolute) throw error;
-    return join2(canonicalHomeIdentity(parent), basename2(absolute));
+    return join2(canonicalHomeIdentity(parent), basename3(absolute));
   }
 }
 function daemonLivenessPath(home) {
@@ -1776,7 +2473,7 @@ function parseRecord(raw) {
 function readRecord(path) {
   try {
     const stat = lstatSync(path);
-    const raw = stat.isFile() ? readFileSync3(path, "utf8") : "";
+    const raw = stat.isFile() ? readFileSync4(path, "utf8") : "";
     return { raw, stat, record: stat.isFile() ? parseRecord(raw) : null };
   } catch (error) {
     if (errorCode(error) === "ENOENT") return null;
@@ -1867,7 +2564,7 @@ async function acquireHomeRestoreLock(home, operation = "restoring") {
   mkdirSync(dirname(targetHome), { recursive: true });
   const path = daemonLivenessPath(targetHome);
   mkdirSync(dirname(path), { recursive: true });
-  const instanceId = randomUUID();
+  const instanceId = randomUUID6();
   let fd = null;
   let reclaimClaim = null;
   for (let attempt = 0; attempt < 8 && fd === null; attempt++) {
@@ -2032,7 +2729,7 @@ async function acquireHomeRestoreLock(home, operation = "restoring") {
 }
 
 // src/commands/backup.ts
-var createCmd = defineCommand5({
+var createCmd = defineCommand9({
   meta: { name: "create", description: "Create a client-side encrypted backup of ~/.bazilion" },
   args: {
     output: {
@@ -2112,7 +2809,7 @@ var createCmd = defineCommand5({
         if (!(error instanceof Error) || !("code" in error) || error.code !== "EXDEV") throw error;
         const installPartial = resolve2(
           dirname2(outAbs),
-          `.${basename3(outAbs)}.${randomUUID2()}.installing`
+          `.${basename4(outAbs)}.${randomUUID7()}.installing`
         );
         try {
           copyFileSync(partial, installPartial);
@@ -2219,37 +2916,37 @@ function validateArchiveSymbolicLink(path, rawTarget) {
 }
 async function validateArchive(file) {
   const entries = [];
-  await list3({
+  await list5({
     file,
     strict: true,
-    onentry(entry2) {
-      if (entry2.meta) return;
-      const path = normalizeArchivePath(entry2.path);
+    onentry(entry3) {
+      if (entry3.meta) return;
+      const path = normalizeArchivePath(entry3.path);
       if (!path) return;
-      if (!EXTRACTABLE_ENTRY_TYPES.has(entry2.type)) {
-        throw new Error(`backup contains unsupported ${entry2.type} entry: ${path}`);
+      if (!EXTRACTABLE_ENTRY_TYPES.has(entry3.type)) {
+        throw new Error(`backup contains unsupported ${entry3.type} entry: ${path}`);
       }
-      if (entry2.type === "SymbolicLink") {
-        validateArchiveSymbolicLink(path, entry2.linkpath);
+      if (entry3.type === "SymbolicLink") {
+        validateArchiveSymbolicLink(path, entry3.linkpath);
       }
-      entries.push({ path, type: entry2.type, linkpath: entry2.linkpath });
+      entries.push({ path, type: entry3.type, linkpath: entry3.linkpath });
     }
   });
   return validateArchiveEntries(entries);
 }
 async function validateArchiveReadable(stream) {
   const entries = [];
-  const parser = list3({
+  const parser = list5({
     strict: true,
-    onentry(entry2) {
-      if (entry2.meta) return;
-      const path = normalizeArchivePath(entry2.path);
+    onentry(entry3) {
+      if (entry3.meta) return;
+      const path = normalizeArchivePath(entry3.path);
       if (!path) return;
-      if (!EXTRACTABLE_ENTRY_TYPES.has(entry2.type)) {
-        throw new Error(`backup contains unsupported ${entry2.type} entry: ${path}`);
+      if (!EXTRACTABLE_ENTRY_TYPES.has(entry3.type)) {
+        throw new Error(`backup contains unsupported ${entry3.type} entry: ${path}`);
       }
-      if (entry2.type === "SymbolicLink") validateArchiveSymbolicLink(path, entry2.linkpath);
-      entries.push({ path, type: entry2.type, linkpath: entry2.linkpath });
+      if (entry3.type === "SymbolicLink") validateArchiveSymbolicLink(path, entry3.linkpath);
+      entries.push({ path, type: entry3.type, linkpath: entry3.linkpath });
     }
   });
   await pipeline(stream, parser);
@@ -2257,29 +2954,29 @@ async function validateArchiveReadable(stream) {
 }
 function validateArchiveEntries(entries) {
   const byPath = /* @__PURE__ */ new Map();
-  for (const entry2 of entries) {
-    if (byPath.has(entry2.path)) throw new Error(`backup contains a duplicate path: ${entry2.path}`);
-    byPath.set(entry2.path, entry2);
+  for (const entry3 of entries) {
+    if (byPath.has(entry3.path)) throw new Error(`backup contains a duplicate path: ${entry3.path}`);
+    byPath.set(entry3.path, entry3);
   }
   const symlinks = new Set(
-    entries.filter((entry2) => entry2.type === "SymbolicLink").map((entry2) => entry2.path)
+    entries.filter((entry3) => entry3.type === "SymbolicLink").map((entry3) => entry3.path)
   );
-  for (const entry2 of entries) {
-    const segments = entry2.path.split("/");
+  for (const entry3 of entries) {
+    const segments = entry3.path.split("/");
     for (let i = 1; i < segments.length; i++) {
       const ancestor = segments.slice(0, i).join("/");
       if (symlinks.has(ancestor)) {
-        throw new Error(`backup entry traverses symbolic link ${ancestor}: ${entry2.path}`);
+        throw new Error(`backup entry traverses symbolic link ${ancestor}: ${entry3.path}`);
       }
       const ancestorEntry = byPath.get(ancestor);
       if (ancestorEntry && ancestorEntry.type !== "Directory") {
-        throw new Error(`backup entry traverses non-directory ${ancestor}: ${entry2.path}`);
+        throw new Error(`backup entry traverses non-directory ${ancestor}: ${entry3.path}`);
       }
     }
   }
   for (const required of ["bazilion.db", "auth.json"]) {
-    const entry2 = byPath.get(required);
-    if (!entry2 || entry2.type !== "File" && entry2.type !== "OldFile") {
+    const entry3 = byPath.get(required);
+    if (!entry3 || entry3.type !== "File" && entry3.type !== "OldFile") {
       throw new Error(`backup is missing required regular file: ${required}`);
     }
   }
@@ -2298,7 +2995,7 @@ function validateArchiveEntries(entries) {
 function validateAuthFile(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(path, "utf8"));
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(`backup auth.json is invalid: ${detail}`);
@@ -2311,7 +3008,7 @@ function validateAuthFile(path) {
 function validateDatabase(path, authToken) {
   let db = null;
   try {
-    db = new DatabaseSync(path, { readOnly: true });
+    db = new DatabaseSync2(path, { readOnly: true });
     const integrity = db.prepare("PRAGMA integrity_check").all();
     if (integrity.length !== 1 || integrity[0]?.integrity_check !== "ok") {
       const detail = integrity.map((row2) => row2.integrity_check).join("; ") || "no result";
@@ -2366,8 +3063,8 @@ function requireExtractedDirectory(path, rowLabel) {
 }
 function requireExtractedTeamSlot(path, rowLabel) {
   try {
-    const entry2 = lstatSync2(path);
-    if (entry2.isDirectory() || entry2.isSymbolicLink()) return;
+    const entry3 = lstatSync2(path);
+    if (entry3.isDirectory() || entry3.isSymbolicLink()) return;
   } catch {
   }
   throw new Error(`${rowLabel} is missing its canonical Team slot in the backup`);
@@ -2375,7 +3072,7 @@ function requireExtractedTeamSlot(path, rowLabel) {
 function rebaseRestoredHomeDirectories(database, payload, targetHome) {
   let db = null;
   try {
-    db = new DatabaseSync(database);
+    db = new DatabaseSync2(database);
     db.exec("PRAGMA foreign_keys = ON");
     const profiles = db.prepare("SELECT id FROM profiles ORDER BY id").all();
     const agents = db.prepare("SELECT id FROM agents ORDER BY id").all();
@@ -2455,15 +3152,15 @@ function removeRebuildableQmdIndexes(payload) {
     if (!team.isDirectory() || team.isSymbolicLink()) continue;
     const memoryDir = resolve2(teamsDir, team.name, "memory");
     if (!existsSync2(memoryDir) || !lstatSync2(memoryDir).isDirectory()) continue;
-    for (const entry2 of readdirSync(memoryDir, { withFileTypes: true })) {
-      if (entry2.isFile() && entry2.name.startsWith(".qmd-index.sqlite")) {
-        rmSync2(resolve2(memoryDir, entry2.name), { force: true });
+    for (const entry3 of readdirSync(memoryDir, { withFileTypes: true })) {
+      if (entry3.isFile() && entry3.name.startsWith(".qmd-index.sqlite")) {
+        rmSync2(resolve2(memoryDir, entry3.name), { force: true });
       }
     }
   }
 }
 function revokeRestoredBrowserSessions(database) {
-  const db = new DatabaseSync(database);
+  const db = new DatabaseSync2(database);
   try {
     db.prepare("UPDATE web_sessions SET revoked_at = ? WHERE revoked_at IS NULL").run(Date.now());
   } finally {
@@ -2603,18 +3300,18 @@ function isAgeEncrypted(path) {
 }
 function readAgeIdentity(rawPath) {
   const path = resolve2(rawPath);
-  const entry2 = lstatSync2(path);
-  if (!entry2.isFile()) throw new Error(`age identity is not a regular file: ${path}`);
-  if (process.platform !== "win32" && (entry2.mode & 63) !== 0) {
+  const entry3 = lstatSync2(path);
+  if (!entry3.isFile()) throw new Error(`age identity is not a regular file: ${path}`);
+  if (process.platform !== "win32" && (entry3.mode & 63) !== 0) {
     throw new Error(`age identity must be owner-only (chmod 600): ${path}`);
   }
-  const identities = readFileSync4(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  const identities = readFileSync5(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   if (identities.length !== 1 || !identities[0]?.startsWith("AGE-SECRET-KEY-")) {
     throw new Error("age identity file must contain exactly one supported AGE-SECRET-KEY entry");
   }
   return identities[0];
 }
-var restoreCmd = defineCommand5({
+var restoreCmd = defineCommand9({
   meta: {
     name: "restore",
     description: "Extract a backup tar.gz into ~/.bazilion (offline; server must be stopped)"
@@ -2725,6 +3422,7 @@ var restoreCmd = defineCommand5({
         validateDatabase(database, authToken);
         rebaseRestoredHomeDirectories(database, payload, targetHome);
         revokeRestoredBrowserSessions(database);
+        pauseRestoredUserQueue(database);
         validateDatabase(database, authToken);
         removeRebuildableQmdIndexes(payload);
         console.log(`installing validated backup ${file} \u2192 ${targetHome}`);
@@ -2783,7 +3481,7 @@ function credentialInventory(home) {
   const database = resolve2(home, "bazilion.db");
   const token = validateAuthFile(authFile);
   validateDatabase(database, token);
-  const db = new DatabaseSync(database, { readOnly: true });
+  const db = new DatabaseSync2(database, { readOnly: true });
   try {
     const activeTokens = db.prepare(
       "SELECT COUNT(*) AS count FROM web_tokens WHERE revoked_at IS NULL AND kind = 'device' AND expires_at > ?"
@@ -2794,7 +3492,7 @@ function credentialInventory(home) {
     db.close();
   }
 }
-var inventoryCmd = defineCommand5({
+var inventoryCmd = defineCommand9({
   meta: { name: "inventory", description: "List credential classes captured by a backup/home" },
   args: { home: { type: "string", description: "Override BAZILION_HOME" } },
   run({ args }) {
@@ -2806,7 +3504,7 @@ var inventoryCmd = defineCommand5({
     for (const key of inventory.secretKeys) console.log(`  stored secret: ${key}`);
   }
 });
-var recoveryGuideCmd = defineCommand5({
+var recoveryGuideCmd = defineCommand9({
   meta: { name: "recovery-guide", description: "Print the credential-exposure recovery checklist" },
   run() {
     console.log("Bazilion credential exposure recovery:");
@@ -2825,7 +3523,7 @@ var recoveryGuideCmd = defineCommand5({
     );
   }
 });
-var rotateBootstrapCmd = defineCommand5({
+var rotateBootstrapCmd = defineCommand9({
   meta: {
     name: "rotate-bootstrap",
     description: "Offline crash-safe bootstrap rotation; revokes every other local token"
@@ -2852,7 +3550,7 @@ var rotateBootstrapCmd = defineCommand5({
           throw new Error(`bazilion server appears to be running at ${serverUrl} \u2014 stop it first.`);
         }
       }
-      const oldAuth = JSON.parse(readFileSync4(paths.authFile, "utf8"));
+      const oldAuth = JSON.parse(readFileSync5(paths.authFile, "utf8"));
       if (typeof oldAuth.token !== "string" || !oldAuth.token) {
         throw new Error("auth.json is missing the bootstrap token");
       }
@@ -2865,7 +3563,7 @@ var rotateBootstrapCmd = defineCommand5({
       });
       const stagedDb = resolve2(payload, "bazilion.db");
       rmSync2(stagedDb, { force: true });
-      const sourceDb = new DatabaseSync(resolve2(targetHome, "bazilion.db"), { readOnly: true });
+      const sourceDb = new DatabaseSync2(resolve2(targetHome, "bazilion.db"), { readOnly: true });
       try {
         await sqliteBackup(sourceDb, stagedDb);
       } finally {
@@ -2874,7 +3572,7 @@ var rotateBootstrapCmd = defineCommand5({
       for (const suffix of ["-wal", "-shm", "-journal"])
         rmSync2(`${stagedDb}${suffix}`, { force: true });
       const newToken = randomBytes(24).toString("hex");
-      const db = new DatabaseSync(stagedDb);
+      const db = new DatabaseSync2(stagedDb);
       try {
         db.exec("PRAGMA foreign_keys = ON; BEGIN IMMEDIATE");
         try {
@@ -2913,7 +3611,7 @@ var rotateBootstrapCmd = defineCommand5({
         db.close();
       }
       const stagedAuth = resolve2(payload, "auth.json");
-      const authPartial = resolve2(payload, `.auth.json.${randomUUID2()}.installing`);
+      const authPartial = resolve2(payload, `.auth.json.${randomUUID7()}.installing`);
       writeFileSync2(authPartial, `${JSON.stringify({ ...oldAuth, token: newToken }, null, 2)}
 `, {
         mode: 384,
@@ -2941,7 +3639,7 @@ var rotateBootstrapCmd = defineCommand5({
     }
   }
 });
-var backupCommand = defineCommand5({
+var backupCommand = defineCommand9({
   meta: { name: "backup", description: "Encrypted backup, restore, and credential recovery" },
   subCommands: {
     create: createCmd,
@@ -2958,7 +3656,7 @@ var backupCommand = defineCommand5({
 });
 
 // src/commands/completion.ts
-import { defineCommand as defineCommand6 } from "citty";
+import { defineCommand as defineCommand10 } from "citty";
 async function walk(cmd, path, out) {
   const subsRaw = cmd.subCommands ?? {};
   const subNames = Object.keys(subsRaw);
@@ -3063,7 +3761,7 @@ function fishScript(flat) {
 `;
 }
 function completionCommand(main2) {
-  return defineCommand6({
+  return defineCommand10({
     meta: {
       name: "completion",
       description: "Print a shell completion script (bash, zsh, or fish)"
@@ -3088,13 +3786,13 @@ function completionCommand(main2) {
 }
 
 // src/commands/config.ts
-import { defineCommand as defineCommand7 } from "citty";
+import { defineCommand as defineCommand11 } from "citty";
 function displayValue(f) {
   if (!f.set) return "(unset)";
   if (f.kind === "secret") return f.preview ?? "(set)";
   return f.value ?? "(set)";
 }
-var listCmd2 = defineCommand7({
+var listCmd2 = defineCommand11({
   meta: {
     name: "list",
     description: "List every configurable field (credentials + URLs) across all services"
@@ -3117,7 +3815,7 @@ var listCmd2 = defineCommand7({
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var setCmd = defineCommand7({
+var setCmd = defineCommand11({
   meta: {
     name: "set",
     description: "Set a configurable field (auto-routes to secrets or plaintext store)"
@@ -3144,7 +3842,7 @@ var setCmd = defineCommand7({
     console.log(`${state.envVar} (${state.kind}): ${displayValue(state)}`);
   }
 });
-var rmCmd = defineCommand7({
+var rmCmd = defineCommand11({
   meta: { name: "rm", description: "Remove a configurable field value" },
   args: {
     envVar: { type: "positional", required: true, description: "Env var name to clear" }
@@ -3155,7 +3853,7 @@ var rmCmd = defineCommand7({
     console.log(`removed ${args.envVar}`);
   }
 });
-var configCommand = defineCommand7({
+var configCommand = defineCommand11({
   meta: {
     name: "config",
     description: "Manage service configuration \u2014 credentials (encrypted) and URLs/IDs (plaintext), unified under one CLI"
@@ -3172,7 +3870,7 @@ import { spawn } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { connect } from "net";
 import { join as join3 } from "path";
-import { defineCommand as defineCommand8 } from "citty";
+import { defineCommand as defineCommand12 } from "citty";
 var bundledDaemonEntry = join3(import.meta.dirname, "daemon.js");
 var sourceDaemonEntry = join3(import.meta.dirname, "..", "..", "..", "daemon", "src", "index.ts");
 var daemonEntry = existsSync3(bundledDaemonEntry) ? bundledDaemonEntry : sourceDaemonEntry;
@@ -3182,8 +3880,8 @@ var webServerEntry = existsSync3(bundledWebServerEntry) ? bundledWebServerEntry
 var bundledWebDist = join3(import.meta.dirname, "web");
 var sourceWebDist = join3(import.meta.dirname, "..", "..", "..", "web", "dist");
 var webDist = existsSync3(bundledWebDist) ? bundledWebDist : sourceWebDist;
-function nodeArgs(entry2) {
-  return entry2.endsWith(".ts") ? ["--import", "tsx/esm", entry2] : [entry2];
+function nodeArgs(entry3) {
+  return entry3.endsWith(".ts") ? ["--import", "tsx/esm", entry3] : [entry3];
 }
 async function responds(url) {
   try {
@@ -3257,16 +3955,16 @@ function openBrowser(url) {
   const proc = spawn(cmd, args, { detached: true, stdio: "ignore" });
   proc.unref();
 }
-function spawnProcess(label, entry2, env) {
-  if (!existsSync3(entry2)) {
-    throw new Error(`${label} entry not found at ${entry2}`);
+function spawnProcess(label, entry3, env) {
+  if (!existsSync3(entry3)) {
+    throw new Error(`${label} entry not found at ${entry3}`);
   }
-  return spawn(process.execPath, nodeArgs(entry2), {
+  return spawn(process.execPath, nodeArgs(entry3), {
     env,
     stdio: "inherit"
   });
 }
-var dashboardCommand = defineCommand8({
+var dashboardCommand = defineCommand12({
   meta: {
     name: "dashboard",
     description: "Start the bazilion daemon and bundled web UI"
@@ -3385,8 +4083,8 @@ var dashboardCommand = defineCommand8({
 });
 
 // src/commands/doctor.ts
-import { defineCommand as defineCommand9 } from "citty";
-var doctorCommand = defineCommand9({
+import { defineCommand as defineCommand13 } from "citty";
+var doctorCommand = defineCommand13({
   meta: { name: "doctor", description: "Diagnose your bazilion install" },
   async run() {
     const client = createClient2();
@@ -3574,7 +4272,7 @@ function checkLine(label, condition, hint) {
 // src/commands/gateway.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { defineCommand as defineCommand10 } from "citty";
+import { defineCommand as defineCommand14 } from "citty";
 var execFileAsync = promisify(execFile);
 function exactHttpsOrigin(raw) {
   if (!raw) throw new Error("BAZILION_PUBLIC_ORIGIN is required");
@@ -3584,9 +4282,9 @@ function exactHttpsOrigin(raw) {
   }
   return url;
 }
-function listenerIsLoopback(output, port) {
+function listenerIsLoopback(output4, port) {
   const suffix = `:${port}`;
-  const listeners = output.split("\n").filter((line) => line.trim()).filter((line) => line.split(/\s+/).some((field) => field.endsWith(suffix)));
+  const listeners = output4.split("\n").filter((line) => line.trim()).filter((line) => line.split(/\s+/).some((field) => field.endsWith(suffix)));
   return listeners.length > 0 && listeners.every((line) => /(?:127\.0\.0\.1|\[?::1\]?):\d+/.test(line));
 }
 function hasFunnel(value) {
@@ -3596,7 +4294,7 @@ function hasFunnel(value) {
     ([key, nested]) => /funnel/i.test(key) && nested !== false && nested !== null || hasFunnel(nested)
   );
 }
-var preflightCmd = defineCommand10({
+var preflightCmd = defineCommand14({
   meta: { name: "preflight", description: "Read-only private Tailscale gateway safety check" },
   async run() {
     const publicOrigin = exactHttpsOrigin(process.env.BAZILION_PUBLIC_ORIGIN);
@@ -3637,13 +4335,13 @@ var preflightCmd = defineCommand10({
     console.log("hosted Agent turns: protected baseline ready");
   }
 });
-var gatewayCommand = defineCommand10({
+var gatewayCommand = defineCommand14({
   meta: { name: "gateway", description: "Inspect the private web gateway posture" },
   subCommands: { preflight: preflightCmd }
 });
 
 // src/commands/inbox.ts
-import { defineCommand as defineCommand11 } from "citty";
+import { defineCommand as defineCommand15 } from "citty";
 function decodeText(payload) {
   try {
     const obj = JSON.parse(payload);
@@ -3659,7 +4357,7 @@ function messageRow(m) {
   const preview = text2.length > 60 ? `${text2.slice(0, 60)}\u2026` : text2;
   return [m.id, state, when, `from:${m.fromAgentId.slice(0, 8)}`, `"${preview}"`];
 }
-var listCmd3 = defineCommand11({
+var listCmd3 = defineCommand15({
   meta: { name: "list", description: "List messages in an agent inbox" },
   args: {
     agent: { type: "positional", required: true, description: "Recipient agent id" },
@@ -3678,7 +4376,7 @@ var listCmd3 = defineCommand11({
     for (const line of columnize(messages.map(messageRow))) console.log(line);
   }
 });
-var showCmd2 = defineCommand11({
+var showCmd2 = defineCommand15({
   meta: { name: "show", description: "Show a single message in full" },
   args: {
     id: { type: "positional", required: true, description: "Message id" }
@@ -3698,7 +4396,7 @@ var showCmd2 = defineCommand11({
     console.log(decodeText(m.payload));
   }
 });
-var readCmd = defineCommand11({
+var readCmd = defineCommand15({
   meta: { name: "read", description: "Mark a message as read" },
   args: {
     id: { type: "positional", required: true, description: "Message id" }
@@ -3709,7 +4407,7 @@ var readCmd = defineCommand11({
     console.log(`marked read: ${args.id}`);
   }
 });
-var loopBreaksCmd = defineCommand11({
+var loopBreaksCmd = defineCommand15({
   meta: { name: "loop-breaks", description: "List stopped agent-message chains" },
   args: {
     agent: { type: "positional", required: true, description: "Agent id" },
@@ -3737,7 +4435,7 @@ var loopBreaksCmd = defineCommand11({
       console.log(line);
   }
 });
-var inboxCommand = defineCommand11({
+var inboxCommand = defineCommand15({
   meta: { name: "inbox", description: "Inspect agent inboxes" },
   subCommands: {
     list: listCmd3,
@@ -3748,8 +4446,8 @@ var inboxCommand = defineCommand11({
 });
 
 // src/commands/login.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { defineCommand as defineCommand12 } from "citty";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { defineCommand as defineCommand16 } from "citty";
 function normalizeServer(raw) {
   let url;
   try {
@@ -3773,7 +4471,7 @@ async function verifyToken(server, token) {
     throw new Error("server canonical private origin does not match --server");
   }
 }
-var loginCommand = defineCommand12({
+var loginCommand = defineCommand16({
   meta: {
     name: "login",
     description: "Save a remote bazilion server + token pair to auth.json"
@@ -3791,7 +4489,7 @@ var loginCommand = defineCommand12({
         `${paths.authFile} not found. Start the daemon with "bazilion serve" first \u2014 login stores the remote there.`
       );
     }
-    const auth = JSON.parse(readFileSync5(paths.authFile, "utf8"));
+    const auth = JSON.parse(readFileSync6(paths.authFile, "utf8"));
     if (args.clear) {
       if (!auth.remote) {
         console.log("no remote stored \u2014 nothing to clear");
@@ -3821,7 +4519,7 @@ var loginCommand = defineCommand12({
 });
 
 // src/commands/mcp.ts
-import { defineCommand as defineCommand13 } from "citty";
+import { defineCommand as defineCommand17 } from "citty";
 function serverRow(s) {
   const where = s.transport === "stdio" ? `${s.command} ${s.args.join(" ")}`.trim() : s.url ?? "";
   return [
@@ -3833,7 +4531,7 @@ function serverRow(s) {
     where
   ];
 }
-var addCmd = defineCommand13({
+var addCmd = defineCommand17({
   meta: { name: "add", description: "Register an MCP server" },
   args: {
     name: { type: "positional", required: true, description: "Unique name ([a-zA-Z0-9_])" },
@@ -3860,7 +4558,7 @@ var addCmd = defineCommand13({
     console.log(`${server.id}	${server.name}	${server.transport}`);
   }
 });
-var listCmd4 = defineCommand13({
+var listCmd4 = defineCommand17({
   meta: { name: "list", description: "List MCP servers" },
   async run() {
     const client = createClient2();
@@ -3872,7 +4570,7 @@ var listCmd4 = defineCommand13({
     for (const line of columnize(servers.map(serverRow))) console.log(line);
   }
 });
-var showCmd3 = defineCommand13({
+var showCmd3 = defineCommand17({
   meta: { name: "show", description: "Show one MCP server" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -3881,7 +4579,7 @@ var showCmd3 = defineCommand13({
     console.log(JSON.stringify(server, null, 2));
   }
 });
-var rmCmd2 = defineCommand13({
+var rmCmd2 = defineCommand17({
   meta: { name: "rm", description: "Delete an MCP server" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -3890,7 +4588,7 @@ var rmCmd2 = defineCommand13({
     console.log(`removed MCP server ${args.id}`);
   }
 });
-var enableCmd = defineCommand13({
+var enableCmd = defineCommand17({
   meta: { name: "enable", description: "Enable an MCP server" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -3899,7 +4597,7 @@ var enableCmd = defineCommand13({
     console.log(`enabled MCP server ${args.id}`);
   }
 });
-var disableCmd = defineCommand13({
+var disableCmd = defineCommand17({
   meta: { name: "disable", description: "Disable an MCP server" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -3908,7 +4606,7 @@ var disableCmd = defineCommand13({
     console.log(`disabled MCP server ${args.id}`);
   }
 });
-var testCmd = defineCommand13({
+var testCmd = defineCommand17({
   meta: { name: "test", description: "Connect to a server and list its tools" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -3926,7 +4624,7 @@ var testCmd = defineCommand13({
     for (const t of tools) console.log(`  ${t.name}	${t.description}`);
   }
 });
-var mcpCommand = defineCommand13({
+var mcpCommand = defineCommand17({
   meta: { name: "mcp", description: "Manage MCP servers" },
   subCommands: {
     add: addCmd,
@@ -3940,11 +4638,11 @@ var mcpCommand = defineCommand13({
 });
 
 // src/commands/memory.ts
-import { defineCommand as defineCommand14 } from "citty";
+import { defineCommand as defineCommand18 } from "citty";
 function encodeKey(key) {
   return key.split("/").map(encodeURIComponent).join("/");
 }
-var writeCmd = defineCommand14({
+var writeCmd = defineCommand18({
   meta: { name: "write", description: "Write an entry into a team's shared memory" },
   args: {
     team: { type: "positional", required: true, description: "Team slug" },
@@ -3953,14 +4651,14 @@ var writeCmd = defineCommand14({
   },
   async run({ args }) {
     const client = createClient2();
-    const entry2 = await client.put(
+    const entry3 = await client.put(
       `/api/teams/${args.team}/memory/${encodeKey(args.key)}`,
       { content: args.content }
     );
-    console.log(`wrote ${entry2.key} (${entry2.content.length} bytes)`);
+    console.log(`wrote ${entry3.key} (${entry3.content.length} bytes)`);
   }
 });
-var readCmd2 = defineCommand14({
+var readCmd2 = defineCommand18({
   meta: { name: "read", description: "Read an entry from a team's shared memory" },
   args: {
     team: { type: "positional", required: true, description: "Team slug" },
@@ -3968,13 +4666,13 @@ var readCmd2 = defineCommand14({
   },
   async run({ args }) {
     const client = createClient2();
-    const entry2 = await client.get(
+    const entry3 = await client.get(
       `/api/teams/${args.team}/memory/${encodeKey(args.key)}`
     );
-    console.log(entry2.content);
+    console.log(entry3.content);
   }
 });
-var searchCmd = defineCommand14({
+var searchCmd = defineCommand18({
   meta: { name: "search", description: "Search a team's shared memory" },
   args: {
     team: { type: "positional", required: true, description: "Team slug" },
@@ -3995,7 +4693,7 @@ var searchCmd = defineCommand14({
     }
   }
 });
-var listCmd5 = defineCommand14({
+var listCmd5 = defineCommand18({
   meta: { name: "list", description: "List all entries in a team's shared memory" },
   args: {
     team: { type: "positional", required: true, description: "Team slug" }
@@ -4012,7 +4710,7 @@ var listCmd5 = defineCommand14({
     }
   }
 });
-var rmCmd3 = defineCommand14({
+var rmCmd3 = defineCommand18({
   meta: { name: "rm", description: "Remove an entry from a team's shared memory" },
   args: {
     team: { type: "positional", required: true, description: "Team slug" },
@@ -4024,7 +4722,7 @@ var rmCmd3 = defineCommand14({
     console.log(`removed ${args.key}`);
   }
 });
-var memoryCommand = defineCommand14({
+var memoryCommand = defineCommand18({
   meta: {
     name: "memory",
     description: "Manage a team's shared memory (BM25-indexed markdown notes)"
@@ -4041,7 +4739,7 @@ var memoryCommand = defineCommand14({
 // src/commands/profile.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4 } from "path";
 
@@ -4056,7 +4754,7 @@ var PROFILE_FILES = [
 ];
 
 // src/commands/profile.ts
-import { defineCommand as defineCommand15 } from "citty";
+import { defineCommand as defineCommand19 } from "citty";
 function splitCsv(v) {
   if (!v) return void 0;
   const out = v.split(",").map((s) => s.trim()).filter(Boolean);
@@ -4067,7 +4765,7 @@ function parseSkillsMode(v) {
   if (v === "all" || v === "selected") return v;
   throw new Error(`--skills-mode must be 'all' or 'selected', got '${v}'`);
 }
-var createCmd2 = defineCommand15({
+var createCmd2 = defineCommand19({
   meta: { name: "create", description: "Create a new profile" },
   args: {
     id: { type: "positional", required: true, description: "Profile slug" },
@@ -4112,7 +4810,7 @@ var createCmd2 = defineCommand15({
   },
   async run({ args }) {
     const skillsMode = parseSkillsMode(args["skills-mode"]);
-    const readTemplate = (path) => path ? readFileSync6(path, "utf8") : void 0;
+    const readTemplate = (path) => path ? readFileSync7(path, "utf8") : void 0;
     const body = {
       id: args.id,
       name: args.name,
@@ -4130,20 +4828,20 @@ var createCmd2 = defineCommand15({
     console.log(`created profile ${profile.id} at ${profile.dir}`);
   }
 });
-var listCmd6 = defineCommand15({
+var listCmd6 = defineCommand19({
   meta: { name: "list", description: "List profiles" },
   async run() {
     const client = createClient2();
-    const list5 = await client.get("/api/profiles");
-    if (list5.length === 0) {
+    const list8 = await client.get("/api/profiles");
+    if (list8.length === 0) {
       console.log("(no profiles)");
       return;
     }
-    const rows = list5.map((p) => [p.id, p.defaultModel, p.name]);
+    const rows = list8.map((p) => [p.id, p.defaultModel, p.name]);
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var showCmd4 = defineCommand15({
+var showCmd4 = defineCommand19({
   meta: { name: "show", description: "Show profile details" },
   args: {
     id: { type: "positional", required: true }
@@ -4168,7 +4866,7 @@ var showCmd4 = defineCommand15({
     }
   }
 });
-var editCmd2 = defineCommand15({
+var editCmd2 = defineCommand19({
   meta: { name: "edit", description: "Open a profile file in $EDITOR" },
   args: {
     id: { type: "positional", required: true },
@@ -4197,7 +4895,7 @@ var editCmd2 = defineCommand15({
         child.on("close", (c) => resolve5(c ?? 0));
       });
       if (code !== 0) throw new Error(`editor exited with code ${code}`);
-      const updated = readFileSync6(tmpPath, "utf8");
+      const updated = readFileSync7(tmpPath, "utf8");
       if (updated === content) {
         console.log("(no changes)");
         return;
@@ -4213,7 +4911,7 @@ var editCmd2 = defineCommand15({
     }
   }
 });
-var updateCmd = defineCommand15({
+var updateCmd = defineCommand19({
   meta: {
     name: "update",
     description: "Update profile settings (name, model, skills-mode, skills)"
@@ -4247,7 +4945,7 @@ var updateCmd = defineCommand15({
     console.log(`updated profile ${profile.id}`);
   }
 });
-var deleteCmd2 = defineCommand15({
+var deleteCmd2 = defineCommand19({
   meta: { name: "delete", description: "Permanently delete a profile and its files" },
   args: {
     id: { type: "positional", required: true }
@@ -4258,7 +4956,7 @@ var deleteCmd2 = defineCommand15({
     console.log(`deleted profile ${args.id}`);
   }
 });
-var profileCommand = defineCommand15({
+var profileCommand = defineCommand19({
   meta: { name: "profile", description: "Manage profiles" },
   subCommands: {
     create: createCmd2,
@@ -4271,8 +4969,8 @@ var profileCommand = defineCommand15({
 });
 
 // src/commands/provider.ts
-import { defineCommand as defineCommand16 } from "citty";
-var listCmd7 = defineCommand16({
+import { defineCommand as defineCommand20 } from "citty";
+var listCmd7 = defineCommand20({
   meta: {
     name: "list",
     description: "List all providers with enabled/disabled state and curated model counts"
@@ -4298,7 +4996,7 @@ var listCmd7 = defineCommand16({
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var modelsCmd = defineCommand16({
+var modelsCmd = defineCommand20({
   meta: {
     name: "models",
     description: "Show curated + catalog + live models for one provider"
@@ -4330,7 +5028,7 @@ var modelsCmd = defineCommand16({
     }
   }
 });
-var modelsSetCmd = defineCommand16({
+var modelsSetCmd = defineCommand20({
   meta: {
     name: "models-set",
     description: "Replace the curated model list for a provider (comma-separated)"
@@ -4355,7 +5053,7 @@ var modelsSetCmd = defineCommand16({
     for (const m of saved.models) console.log(`  ${m}`);
   }
 });
-var enableCmd2 = defineCommand16({
+var enableCmd2 = defineCommand20({
   meta: { name: "enable", description: "Toggle a provider on so agents can use it" },
   args: {
     name: { type: "positional", required: true, description: "Provider id (e.g. anthropic)" }
@@ -4369,7 +5067,7 @@ var enableCmd2 = defineCommand16({
     console.log(`${res.name}: enabled`);
   }
 });
-var disableCmd2 = defineCommand16({
+var disableCmd2 = defineCommand20({
   meta: {
     name: "disable",
     description: "Toggle a provider off \u2014 agents will refuse its model strings"
@@ -4386,7 +5084,7 @@ var disableCmd2 = defineCommand16({
     console.log(`${res.name}: disabled`);
   }
 });
-var testCmd2 = defineCommand16({
+var testCmd2 = defineCommand20({
   meta: { name: "test", description: "Send a single chat to a model and print the reply" },
   args: {
     model: {
@@ -4407,7 +5105,7 @@ var testCmd2 = defineCommand16({
     }
   }
 });
-var providerCommand = defineCommand16({
+var providerCommand = defineCommand20({
   meta: { name: "provider", description: "Manage and test LLM providers" },
   subCommands: {
     list: listCmd7,
@@ -4419,9 +5117,98 @@ var providerCommand = defineCommand16({
   }
 });
 
+// src/commands/result.ts
+import { closeSync as closeSync3, fsyncSync as fsyncSync3, openSync as openSync3, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { defineCommand as defineCommand21 } from "citty";
+var idArg = { type: "positional", required: true };
+var list6 = defineCommand21({
+  meta: { name: "list", description: "List saved results released to the operator" },
+  args: {
+    team: { type: "string" },
+    agent: { type: "string" },
+    limit: { type: "string", default: "50" },
+    offset: { type: "string", default: "0" },
+    json: { type: "boolean" }
+  },
+  async run({ args }) {
+    const query = new URLSearchParams({ limit: args.limit, offset: args.offset });
+    if (args.team) query.set("teamId", args.team);
+    if (args.agent) query.set("agentId", args.agent);
+    const body = await createClient2().get(`/api/results?${query}`);
+    if (args.json) return console.log(JSON.stringify(body, null, 2));
+    if (!body.results.length) return console.log("(no saved results)");
+    for (const line of columnize([
+      ["id", "filename", "bytes", "team", "agent", "created"],
+      ...body.results.map((r) => [
+        r.id,
+        r.name,
+        String(r.byteLength),
+        r.teamId,
+        r.agentId,
+        new Date(r.createdAt).toISOString()
+      ])
+    ]))
+      console.log(line);
+    console.log(`${body.offset + 1}\u2013${body.offset + body.results.length} of ${body.total}`);
+  }
+});
+var show4 = defineCommand21({
+  meta: { name: "show", description: "Inspect a saved result and its provenance" },
+  args: { id: idArg, json: { type: "boolean" } },
+  async run({ args }) {
+    const { result } = await createClient2().get(
+      `/api/results/${encodeURIComponent(args.id)}`
+    );
+    console.log(JSON.stringify(result, null, 2));
+  }
+});
+var download = defineCommand21({
+  meta: { name: "download", description: "Download a saved result to an explicit new file" },
+  args: {
+    id: idArg,
+    output: {
+      type: "string",
+      required: true,
+      description: "Destination path; existing files are never overwritten"
+    }
+  },
+  async run({ args }) {
+    const bytes = await createClient2().binary(
+      `/api/results/${encodeURIComponent(args.id)}/download`
+    );
+    const fd = openSync3(args.output, "wx", 384);
+    try {
+      writeFileSync5(fd, bytes);
+      fsyncSync3(fd);
+    } catch (error) {
+      closeSync3(fd);
+      unlinkSync(args.output);
+      throw error;
+    }
+    closeSync3(fd);
+    console.log(`Saved ${bytes.byteLength} bytes to ${args.output}`);
+  }
+});
+var rm = defineCommand21({
+  meta: {
+    name: "rm",
+    description: "Delete saved bytes; retained history will report the result as deleted"
+  },
+  args: { id: idArg, yes: { type: "boolean" } },
+  async run({ args }) {
+    if (!args.yes) throw new Error("Pass --yes to permanently delete the saved file bytes");
+    await createClient2().del(`/api/results/${encodeURIComponent(args.id)}`);
+    console.log("Saved file deleted; historical references retain a deletion receipt.");
+  }
+});
+var resultCommand = defineCommand21({
+  meta: { name: "result", description: "Find, download and delete saved Agent results" },
+  subCommands: { list: list6, show: show4, download, rm }
+});
+
 // src/commands/send.ts
-import { defineCommand as defineCommand17 } from "citty";
-var sendCommand = defineCommand17({
+import { defineCommand as defineCommand22 } from "citty";
+var sendCommand = defineCommand22({
   meta: {
     name: "send",
     description: "Send a message from one agent to another"
@@ -4455,11 +5242,11 @@ var sendCommand = defineCommand17({
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { join as join5 } from "path";
-import { defineCommand as defineCommand18 } from "citty";
+import { defineCommand as defineCommand23 } from "citty";
 var bundledDaemonEntry2 = join5(import.meta.dirname, "daemon.js");
 var sourceDaemonEntry2 = join5(import.meta.dirname, "..", "..", "..", "daemon", "src", "index.ts");
 var daemonEntry2 = existsSync5(bundledDaemonEntry2) ? bundledDaemonEntry2 : sourceDaemonEntry2;
-var serveCommand = defineCommand18({
+var serveCommand = defineCommand23({
   meta: {
     name: "serve",
     description: "Start the bazilion daemon (HTTP API)"
@@ -4526,7 +5313,7 @@ var serveCommand = defineCommand18({
 });
 
 // src/commands/session.ts
-import { defineCommand as defineCommand19 } from "citty";
+import { defineCommand as defineCommand24 } from "citty";
 function row(session) {
   const state = session.revokedAt ? "revoked" : session.absoluteExpiresAt <= Date.now() || session.idleExpiresAt <= Date.now() ? "expired" : "active";
   return [
@@ -4538,7 +5325,7 @@ function row(session) {
     `absolute: ${new Date(session.absoluteExpiresAt).toISOString()}`
   ];
 }
-var listCmd8 = defineCommand19({
+var listCmd8 = defineCommand24({
   meta: { name: "list", description: "List browser sessions" },
   async run() {
     const { sessions } = await createClient2().get("/api/sessions");
@@ -4549,7 +5336,7 @@ var listCmd8 = defineCommand19({
     for (const line of columnize(sessions.map(row))) console.log(line);
   }
 });
-var revokeCmd = defineCommand19({
+var revokeCmd = defineCommand24({
   meta: { name: "revoke", description: "Revoke one browser session" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -4557,22 +5344,22 @@ var revokeCmd = defineCommand19({
     console.log(`revoked browser session ${args.id}`);
   }
 });
-var sessionCommand = defineCommand19({
+var sessionCommand = defineCommand24({
   meta: { name: "session", description: "Manage browser sessions" },
   subCommands: { list: listCmd8, revoke: revokeCmd }
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, statSync } from "fs";
-import { basename as basename4, resolve as resolve3 } from "path";
-import { defineCommand as defineCommand20 } from "citty";
+import { existsSync as existsSync6, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import { basename as basename5, resolve as resolve3 } from "path";
+import { defineCommand as defineCommand25 } from "citty";
 function printFindings(findings, prefix = "  ") {
   for (const f of findings) {
     const line = f.line ? ` line ${f.line}` : "";
     console.log(`${prefix}${f.severity}: ${f.code}${line} - ${f.message}`);
   }
 }
-var listCmd9 = defineCommand20({
+var listCmd9 = defineCommand25({
   meta: { name: "list", description: "List installed skills (or those attached to an agent)" },
   args: {
     agent: { type: "string", description: "Filter to skills attached to this agent" }
@@ -4613,7 +5400,7 @@ var listCmd9 = defineCommand20({
     }
   }
 });
-var importCmd = defineCommand20({
+var importCmd = defineCommand25({
   meta: {
     name: "import",
     description: "Import skills from openclaw, a directory, or a local .zip archive"
@@ -4629,12 +5416,12 @@ var importCmd = defineCommand20({
   async run({ args }) {
     const client = createClient2();
     const absFrom = resolve3(args.from);
-    const isLocalZip = args.from.toLowerCase().endsWith(".zip") && existsSync6(absFrom) && statSync(absFrom).isFile();
+    const isLocalZip = args.from.toLowerCase().endsWith(".zip") && existsSync6(absFrom) && statSync2(absFrom).isFile();
     let result;
     try {
       if (isLocalZip) {
-        const bytes = readFileSync7(absFrom);
-        const file = new File([bytes], basename4(absFrom), { type: "application/zip" });
+        const bytes = readFileSync8(absFrom);
+        const file = new File([bytes], basename5(absFrom), { type: "application/zip" });
         const fd = new FormData();
         fd.set("file", file);
         if (args.force) fd.set("force", "true");
@@ -4682,7 +5469,7 @@ var importCmd = defineCommand20({
     }
   }
 });
-var rmCmd4 = defineCommand20({
+var rmCmd4 = defineCommand25({
   meta: { name: "rm", description: "Remove an installed skill" },
   args: {
     name: { type: "positional", required: true }
@@ -4693,7 +5480,7 @@ var rmCmd4 = defineCommand20({
     console.log(`removed skill ${args.name}`);
   }
 });
-var skillCommand = defineCommand20({
+var skillCommand = defineCommand25({
   meta: { name: "skill", description: "Manage the skill library" },
   subCommands: {
     list: listCmd9,
@@ -4703,13 +5490,13 @@ var skillCommand = defineCommand20({
 });
 
 // src/commands/team.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { stdin as stdin2 } from "process";
-import { defineCommand as defineCommand22 } from "citty";
+import { defineCommand as defineCommand27 } from "citty";
 
 // src/commands/team-policy.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { defineCommand as defineCommand21 } from "citty";
+import { readFileSync as readFileSync9 } from "fs";
+import { defineCommand as defineCommand26 } from "citty";
 
 // src/team-interchange.ts
 var TEAM_POLICY_INTERCHANGE_VERSION = 1;
@@ -4925,7 +5712,7 @@ function edgeDiff(before, after) {
 // src/commands/team-policy.ts
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync9(path, "utf8"));
   } catch (error) {
     throw new Error(`invalid JSON: ${error.message}`);
   }
@@ -4957,7 +5744,7 @@ function printPolicy(detail) {
       console.log(line);
   }
 }
-var show2 = defineCommand21({
+var show5 = defineCommand26({
   meta: { name: "show", description: "Show the one effective live policy for a Team" },
   args: {
     team: { type: "positional", required: true },
@@ -4971,7 +5758,7 @@ var show2 = defineCommand21({
     else printPolicy(detail);
   }
 });
-var exportCommand = defineCommand21({
+var exportCommand = defineCommand26({
   meta: { name: "export", description: "Export a revisioned Team policy document" },
   args: { team: { type: "positional", required: true } },
   async run({ args }) {
@@ -4995,7 +5782,7 @@ function printEdgeDiff(current, edges) {
   for (const value of diff2.added) console.log(`  + ${value}`);
   for (const value of diff2.removed) console.log(`  - ${value}`);
 }
-var importCommand = defineCommand21({
+var importCommand = defineCommand26({
   meta: {
     name: "import",
     description: "Validate, diff, and explicitly replace a Team policy"
@@ -5050,7 +5837,7 @@ var importCommand = defineCommand21({
     console.log(`updated Team ${args.team} policy to revision ${updated.teamPolicy.revision}`);
   }
 });
-var diff = defineCommand21({
+var diff = defineCommand26({
   meta: { name: "diff", description: "Compare live policy with its retained baseline source" },
   args: {
     team: { type: "positional", required: true },
@@ -5074,7 +5861,7 @@ var diff = defineCommand21({
     );
   }
 });
-var evaluate = defineCommand21({
+var evaluate = defineCommand26({
   meta: {
     name: "evaluate",
     description: "Evaluate a communication path without sending or recording a block"
@@ -5105,7 +5892,7 @@ var evaluate = defineCommand21({
     );
   }
 });
-var blocks = defineCommand21({
+var blocks = defineCommand26({
   meta: { name: "blocks", description: "List paginated durable communication denials" },
   args: {
     team: { type: "positional", required: true },
@@ -5154,10 +5941,10 @@ var blocks = defineCommand21({
     if (page.nextCursor) console.log(`next cursor: ${page.nextCursor}`);
   }
 });
-var teamPolicyCommand = defineCommand21({
+var teamPolicyCommand = defineCommand26({
   meta: { name: "policy", description: "Inspect and manage the Team-owned live policy" },
   subCommands: {
-    show: show2,
+    show: show5,
     export: exportCommand,
     import: importCommand,
     diff,
@@ -5167,7 +5954,7 @@ var teamPolicyCommand = defineCommand21({
 });
 
 // src/commands/team.ts
-var addCmd2 = defineCommand22({
+var addCmd2 = defineCommand27({
   meta: {
     name: "add",
     description: "Register a team at ~/.bazilion/teams/<slug>/ (use --link to point at an existing tree)"
@@ -5191,20 +5978,20 @@ var addCmd2 = defineCommand22({
     console.log(`registered team ${g.id} at ${g.path}`);
   }
 });
-var listCmd10 = defineCommand22({
+var listCmd10 = defineCommand27({
   meta: { name: "list", description: "List teams" },
   async run() {
     const client = createClient2();
-    const list5 = await client.get("/api/teams");
-    if (list5.length === 0) {
+    const list8 = await client.get("/api/teams");
+    if (list8.length === 0) {
       console.log("(no teams)");
       return;
     }
-    const rows = list5.map((g) => [g.id, g.path]);
+    const rows = list8.map((g) => [g.id, g.path]);
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var rmCmd5 = defineCommand22({
+var rmCmd5 = defineCommand27({
   meta: { name: "rm", description: "Remove a team registration" },
   args: {
     id: { type: "positional", required: true }
@@ -5225,7 +6012,7 @@ async function readStdin() {
   for await (const chunk of stdin2) chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf8");
 }
-var userMdShowCmd = defineCommand22({
+var userMdShowCmd = defineCommand27({
   meta: { name: "show", description: "Print the team's USER.md" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -5235,7 +6022,7 @@ var userMdShowCmd = defineCommand22({
     if (g.userMd && !g.userMd.endsWith("\n")) process.stdout.write("\n");
   }
 });
-var userMdSetCmd = defineCommand22({
+var userMdSetCmd = defineCommand27({
   meta: {
     name: "set",
     description: "Replace the team's USER.md (from --file, --from-stdin, or inline text)"
@@ -5249,7 +6036,7 @@ var userMdSetCmd = defineCommand22({
   async run({ args }) {
     let content;
     if (args["from-stdin"]) content = await readStdin();
-    else if (args.file) content = readFileSync9(args.file, "utf8");
+    else if (args.file) content = readFileSync10(args.file, "utf8");
     else if (args.text !== void 0) content = args.text;
     else {
       console.error("team user-md set: provide --file, --from-stdin, or --text");
@@ -5261,7 +6048,7 @@ var userMdSetCmd = defineCommand22({
     console.log(`updated USER.md for team ${args.id} (${content.length} bytes)`);
   }
 });
-var userMdClearCmd = defineCommand22({
+var userMdClearCmd = defineCommand27({
   meta: { name: "clear", description: "Clear the team's USER.md to empty" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -5271,7 +6058,7 @@ var userMdClearCmd = defineCommand22({
     console.log(`cleared USER.md for team ${args.id}`);
   }
 });
-var userMdCmd = defineCommand22({
+var userMdCmd = defineCommand27({
   meta: { name: "user-md", description: "View or edit a team's USER.md" },
   subCommands: {
     show: userMdShowCmd,
@@ -5279,7 +6066,7 @@ var userMdCmd = defineCommand22({
     clear: userMdClearCmd
   }
 });
-var topicFormatShowCmd = defineCommand22({
+var topicFormatShowCmd = defineCommand27({
   meta: { name: "show", description: "Print the team's Telegram topic-name template" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -5288,7 +6075,7 @@ var topicFormatShowCmd = defineCommand22({
     console.log(g.telegramTopicNameFormat ?? "(default naming)");
   }
 });
-var topicFormatSetCmd = defineCommand22({
+var topicFormatSetCmd = defineCommand27({
   meta: {
     name: "set",
     description: "Set the topic-name template. Tokens: {agent.name} {team.name} {team.slug} (must include {agent.name})"
@@ -5308,7 +6095,7 @@ var topicFormatSetCmd = defineCommand22({
     console.log(`set topic-name template for team ${args.id}: ${g.telegramTopicNameFormat}`);
   }
 });
-var topicFormatClearCmd = defineCommand22({
+var topicFormatClearCmd = defineCommand27({
   meta: { name: "clear", description: "Clear the template (revert to built-in naming)" },
   args: { id: { type: "positional", required: true } },
   async run({ args }) {
@@ -5318,7 +6105,7 @@ var topicFormatClearCmd = defineCommand22({
     console.log(`cleared topic-name template for team ${args.id}`);
   }
 });
-var topicFormatCmd = defineCommand22({
+var topicFormatCmd = defineCommand27({
   meta: {
     name: "topic-format",
     description: "View or edit a team's Telegram forum-topic name template"
@@ -5329,7 +6116,7 @@ var topicFormatCmd = defineCommand22({
     clear: topicFormatClearCmd
   }
 });
-var teamCommand = defineCommand22({
+var teamCommand = defineCommand27({
   meta: { name: "team", description: "Manage teams (collaboration contexts)" },
   subCommands: {
     add: addCmd2,
@@ -5342,11 +6129,11 @@ var teamCommand = defineCommand22({
 });
 
 // src/commands/team-template.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { defineCommand as defineCommand23 } from "citty";
+import { readFileSync as readFileSync11 } from "fs";
+import { defineCommand as defineCommand28 } from "citty";
 function jsonFile(path) {
   try {
-    return JSON.parse(readFileSync10(path, "utf8"));
+    return JSON.parse(readFileSync11(path, "utf8"));
   } catch (error) {
     throw new Error(`invalid JSON: ${error.message}`);
   }
@@ -5371,7 +6158,7 @@ function printTeam(detail) {
       console.log(line);
   }
 }
-var list4 = defineCommand23({
+var list7 = defineCommand28({
   meta: { name: "list", description: "List canonical Team templates" },
   args: { json: { type: "boolean", description: "Emit stable JSON" } },
   async run({ args }) {
@@ -5385,7 +6172,7 @@ var list4 = defineCommand23({
       console.log(line);
   }
 });
-var show3 = defineCommand23({
+var show6 = defineCommand28({
   meta: { name: "show", description: "Show a canonical Team template" },
   args: {
     id: { type: "positional", required: true },
@@ -5399,7 +6186,7 @@ var show3 = defineCommand23({
     else printTeam(detail);
   }
 });
-var exportCommand2 = defineCommand23({
+var exportCommand2 = defineCommand28({
   meta: {
     name: "export",
     description: "Export a portable versioned Team-template document to stdout"
@@ -5439,7 +6226,7 @@ function printImportDiff(current, document) {
   for (const value of diff2.added) console.log(`  + ${value}`);
   for (const value of diff2.removed) console.log(`  - ${value}`);
 }
-var importCommand2 = defineCommand23({
+var importCommand2 = defineCommand28({
   meta: {
     name: "import",
     description: "Validate, diff, and explicitly apply a portable Team-template document"
@@ -5520,17 +6307,17 @@ var importCommand2 = defineCommand23({
     );
   }
 });
-var teamTemplateCommand = defineCommand23({
+var teamTemplateCommand = defineCommand28({
   meta: {
     name: "team-template",
     description: "Inspect and exchange canonical Team templates"
   },
-  subCommands: { list: list4, show: show3, export: exportCommand2, import: importCommand2 }
+  subCommands: { list: list7, show: show6, export: exportCommand2, import: importCommand2 }
 });
 
 // src/commands/telegram.ts
-import { defineCommand as defineCommand24 } from "citty";
-var setCmd2 = defineCommand24({
+import { defineCommand as defineCommand29 } from "citty";
+var setCmd2 = defineCommand29({
   meta: {
     name: "set",
     description: "Save bot token + supergroup chat ID (paired write)"
@@ -5548,7 +6335,7 @@ var setCmd2 = defineCommand24({
     console.log(`saved \xB7 token ${state.botTokenPreview} \xB7 chat ${state.chatId}`);
   }
 });
-var clearCmd = defineCommand24({
+var clearCmd = defineCommand29({
   meta: {
     name: "clear",
     description: "Remove stored bot token + chat ID"
@@ -5559,7 +6346,7 @@ var clearCmd = defineCommand24({
     console.log("cleared");
   }
 });
-var showCmd5 = defineCommand24({
+var showCmd5 = defineCommand29({
   meta: {
     name: "show",
     description: "Show what credentials are stored (token is masked)"
@@ -5580,7 +6367,7 @@ var showCmd5 = defineCommand24({
     }
   }
 });
-var reconnectCmd = defineCommand24({
+var reconnectCmd = defineCommand29({
   meta: {
     name: "reconnect",
     description: "Apply a pending supergroup chat-id migration + re-activate the bot"
@@ -5591,7 +6378,7 @@ var reconnectCmd = defineCommand24({
     console.log(`reconnected \xB7 chat ${state.chatId}`);
   }
 });
-var configCmd = defineCommand24({
+var configCmd = defineCommand29({
   meta: {
     name: "config",
     description: "Manage Telegram credentials (bot token + chat ID)"
@@ -5602,7 +6389,7 @@ var configCmd = defineCommand24({
     show: showCmd5
   }
 });
-var healthCmd = defineCommand24({
+var healthCmd = defineCommand29({
   meta: {
     name: "health",
     description: "Run the four-step preflight against the Telegram Bot API"
@@ -5641,7 +6428,7 @@ var healthCmd = defineCommand24({
     if (!allOk) process.exitCode = 1;
   }
 });
-var botStatusCmd = defineCommand24({
+var botStatusCmd = defineCommand29({
   meta: {
     name: "status",
     description: "Show polling state of the live bot"
@@ -5666,7 +6453,7 @@ var botStatusCmd = defineCommand24({
     if (!p.running) process.exitCode = 1;
   }
 });
-var botRestartCmd = defineCommand24({
+var botRestartCmd = defineCommand29({
   meta: {
     name: "restart",
     description: "Force-restart the bot (tears down + brings up from current creds)"
@@ -5677,7 +6464,7 @@ var botRestartCmd = defineCommand24({
     console.log("restart requested");
   }
 });
-var botCmd = defineCommand24({
+var botCmd = defineCommand29({
   meta: {
     name: "bot",
     description: "Inspect / control the live polling bot"
@@ -5687,7 +6474,7 @@ var botCmd = defineCommand24({
     restart: botRestartCmd
   }
 });
-var bindCmd = defineCommand24({
+var bindCmd = defineCommand29({
   meta: {
     name: "bind",
     description: "Create a Telegram topic for an agent (manual fallback for /talk)"
@@ -5705,7 +6492,7 @@ var bindCmd = defineCommand24({
     console.log(`  ${result.deepLink}`);
   }
 });
-var unbindCmd = defineCommand24({
+var unbindCmd = defineCommand29({
   meta: {
     name: "unbind",
     description: "Clear an agent's Telegram topic binding (topic stays in Telegram as orphan)"
@@ -5719,7 +6506,7 @@ var unbindCmd = defineCommand24({
     console.log(`unbound agent ${args.agent}`);
   }
 });
-var listBindingsCmd = defineCommand24({
+var listBindingsCmd = defineCommand29({
   meta: {
     name: "list",
     description: "List agents and their Telegram topic bindings"
@@ -5747,7 +6534,7 @@ var listBindingsCmd = defineCommand24({
     }
   }
 });
-var allowCmd = defineCommand24({
+var allowCmd = defineCommand29({
   meta: { name: "allow", description: "Add a Telegram user id to the allowlist" },
   args: {
     userId: { type: "positional", required: true, description: "Numeric Telegram user id" },
@@ -5763,7 +6550,7 @@ var allowCmd = defineCommand24({
     console.log(`allowed ${u.userId} (${u.role})`);
   }
 });
-var denyCmd = defineCommand24({
+var denyCmd = defineCommand29({
   meta: { name: "deny", description: "Remove a Telegram user id from the allowlist" },
   args: { userId: { type: "positional", required: true } },
   async run({ args }) {
@@ -5772,7 +6559,7 @@ var denyCmd = defineCommand24({
     console.log(`removed ${args.userId}`);
   }
 });
-var allowedCmd = defineCommand24({
+var allowedCmd = defineCommand29({
   meta: { name: "allowed", description: "List allowlisted Telegram users" },
   async run() {
     const client = createClient2();
@@ -5787,7 +6574,7 @@ var allowedCmd = defineCommand24({
     }
   }
 });
-var pairingCreateCmd = defineCommand24({
+var pairingCreateCmd = defineCommand29({
   meta: { name: "create", description: "Generate a one-time Telegram owner pairing code" },
   async run() {
     const result = await createClient2().post(
@@ -5798,7 +6585,7 @@ var pairingCreateCmd = defineCommand24({
     console.log("send `/pair <code>` in the configured \u2699 bazilion service topic");
   }
 });
-var pairingStatusCmd = defineCommand24({
+var pairingStatusCmd = defineCommand29({
   meta: { name: "status", description: "Show Telegram owner pairing status" },
   async run() {
     const result = await createClient2().get("/api/config/telegram/pairing");
@@ -5809,14 +6596,14 @@ var pairingStatusCmd = defineCommand24({
       console.log(`expires: ${new Date(result.challengeExpiresAt).toISOString()}`);
   }
 });
-var pairingCancelCmd = defineCommand24({
+var pairingCancelCmd = defineCommand29({
   meta: { name: "cancel", description: "Cancel the active Telegram pairing code" },
   async run() {
     await createClient2().del("/api/config/telegram/pairing/challenge");
     console.log("pairing challenge cancelled");
   }
 });
-var pairingResetCmd = defineCommand24({
+var pairingResetCmd = defineCommand29({
   meta: { name: "reset", description: "Revoke the Telegram owner and require re-pairing" },
   args: {
     yes: { type: "boolean", description: "Confirm destructive owner reset", required: true }
@@ -5827,7 +6614,7 @@ var pairingResetCmd = defineCommand24({
     console.log("Telegram owner reset; ingress is closed until re-paired");
   }
 });
-var pairingCmd = defineCommand24({
+var pairingCmd = defineCommand29({
   meta: { name: "pairing", description: "Manage single-owner Telegram pairing" },
   subCommands: {
     create: pairingCreateCmd,
@@ -5836,7 +6623,7 @@ var pairingCmd = defineCommand24({
     reset: pairingResetCmd
   }
 });
-var telegramCommand = defineCommand24({
+var telegramCommand = defineCommand29({
   meta: {
     name: "telegram",
     description: "Telegram integration: credentials, health, bot lifecycle, bindings, access"
@@ -5857,7 +6644,7 @@ var telegramCommand = defineCommand24({
 });
 
 // src/commands/token.ts
-import { defineCommand as defineCommand25 } from "citty";
+import { defineCommand as defineCommand30 } from "citty";
 import qrcode from "qrcode-terminal";
 function tokenRow(t) {
   const last = t.lastUsedAt ? new Date(t.lastUsedAt).toISOString() : "(never)";
@@ -5886,7 +6673,7 @@ function resolveQrServer(override) {
   }
   return url.origin;
 }
-var createCmd3 = defineCommand25({
+var createCmd3 = defineCommand30({
   meta: { name: "create", description: "Mint a new web token (shown once)" },
   args: {
     label: { type: "positional", required: true, description: "Human-readable label" },
@@ -5929,7 +6716,7 @@ var createCmd3 = defineCommand25({
     qrcode.generate(pairUrl, { small: true }, (qr) => console.log(qr));
   }
 });
-var listCmd11 = defineCommand25({
+var listCmd11 = defineCommand30({
   meta: { name: "list", description: "List web tokens" },
   args: {
     all: { type: "boolean", description: "Include revoked tokens" }
@@ -5945,7 +6732,7 @@ var listCmd11 = defineCommand25({
     for (const line of columnize(tokens.map(tokenRow))) console.log(line);
   }
 });
-var showLocalCmd = defineCommand25({
+var showLocalCmd = defineCommand30({
   meta: {
     name: "show-local",
     description: "Print the bootstrap web token stored in ~/.bazilion/auth.json"
@@ -5955,7 +6742,7 @@ var showLocalCmd = defineCommand25({
     console.log(readAuthFile(paths.authFile).token);
   }
 });
-var revokeCmd2 = defineCommand25({
+var revokeCmd2 = defineCommand30({
   meta: { name: "revoke", description: "Revoke a web token" },
   args: {
     id: { type: "positional", required: true }
@@ -5966,7 +6753,7 @@ var revokeCmd2 = defineCommand25({
     console.log(`revoked token ${args.id}`);
   }
 });
-var tokenCommand = defineCommand25({
+var tokenCommand = defineCommand30({
   meta: { name: "token", description: "Manage web tokens for API/CLI clients" },
   subCommands: {
     create: createCmd3,
@@ -5977,8 +6764,8 @@ var tokenCommand = defineCommand25({
 });
 
 // src/commands/trigger.ts
-import { defineCommand as defineCommand26 } from "citty";
-var addCmd3 = defineCommand26({
+import { defineCommand as defineCommand31 } from "citty";
+var addCmd3 = defineCommand31({
   meta: { name: "add", description: "Add an interval / cron trigger to an agent" },
   args: {
     agent: { type: "positional", required: true },
@@ -6026,7 +6813,7 @@ function triggerRow(t) {
   const msgPreview = t.message.length > 60 ? `${t.message.slice(0, 60)}\u2026` : t.message;
   return [t.id, state, spec, `last: ${last}`, `"${msgPreview}"`];
 }
-var listCmd12 = defineCommand26({
+var listCmd12 = defineCommand31({
   meta: { name: "list", description: "List triggers for an agent" },
   args: {
     agent: { type: "positional", required: true }
@@ -6043,7 +6830,7 @@ var listCmd12 = defineCommand26({
     for (const line of columnize(triggers.map(triggerRow))) console.log(line);
   }
 });
-var rmCmd6 = defineCommand26({
+var rmCmd6 = defineCommand31({
   meta: { name: "rm", description: "Delete a trigger" },
   args: {
     id: { type: "positional", required: true }
@@ -6054,7 +6841,7 @@ var rmCmd6 = defineCommand26({
     console.log(`removed trigger ${args.id}`);
   }
 });
-var enableCmd3 = defineCommand26({
+var enableCmd3 = defineCommand31({
   meta: { name: "enable", description: "Enable a trigger" },
   args: {
     id: { type: "positional", required: true }
@@ -6066,7 +6853,7 @@ var enableCmd3 = defineCommand26({
     console.log(`enabled trigger ${args.id}`);
   }
 });
-var disableCmd3 = defineCommand26({
+var disableCmd3 = defineCommand31({
   meta: { name: "disable", description: "Disable a trigger" },
   args: {
     id: { type: "positional", required: true }
@@ -6078,7 +6865,7 @@ var disableCmd3 = defineCommand26({
     console.log(`disabled trigger ${args.id}`);
   }
 });
-var historyCmd = defineCommand26({
+var historyCmd = defineCommand31({
   meta: { name: "history", description: "Show recent dispatches for a trigger" },
   args: {
     id: { type: "positional", required: true },
@@ -6106,7 +6893,7 @@ var historyCmd = defineCommand26({
     for (const line of columnize(rows)) console.log(line);
   }
 });
-var triggerCommand = defineCommand26({
+var triggerCommand = defineCommand31({
   meta: { name: "trigger", description: "Manage scheduled agent triggers" },
   subCommands: {
     add: addCmd3,
@@ -6122,7 +6909,7 @@ var triggerCommand = defineCommand26({
 import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync2, realpathSync as realpathSync2, rmSync as rmSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { isAbsolute as isAbsolute2, join as join6, parse as parse2, relative as relative2, resolve as resolve4, sep } from "path";
-import { defineCommand as defineCommand27 } from "citty";
+import { defineCommand as defineCommand32 } from "citty";
 function makeLineReader() {
   let buffer = "";
   let ended = false;
@@ -6209,7 +6996,7 @@ function assertSafeUninstallHome(home) {
   }
   return target;
 }
-var uninstallCommand = defineCommand27({
+var uninstallCommand = defineCommand32({
   meta: {
     name: "uninstall",
     description: "Wipe bazilion state from ~/.bazilion (or BAZILION_HOME)"
@@ -6313,7 +7100,7 @@ var uninstallCommand = defineCommand27({
 
 // src/index.ts
 var VERSION = package_default.version;
-var main = defineCommand28({
+var main = defineCommand33({
   meta: {
     name: "bazilion",
     version: VERSION,
@@ -6327,6 +7114,11 @@ var main = defineCommand28({
     agent: agentCommand,
     approval: approvalCommand,
     attention: attentionCommand,
+    result: resultCommand,
+    conversation: conversationCommand,
+    queue: queueCommand,
+    question: questionCommand,
+    notification: notificationCommand,
     skill: skillCommand,
     memory: memoryCommand,
     mcp: mcpCommand,
@@ -6462,7 +7254,7 @@ function printTopLevelHelp() {
   }
   console.log("Use `bazilion <command> --help` for more information about a command.");
 }
-async function entry() {
+async function entry2() {
   const rawArgs = process.argv.slice(2);
   try {
     if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
@@ -6485,5 +7277,5 @@ async function entry() {
     process.exit(exitCodeForError(err));
   }
 }
-entry();
+entry2();
 //# sourceMappingURL=cli.js.map