@canonmsg/agent-sdk 13.1.0 → 13.2.0

package/dist/chunks/{chunk-IEKVS7AN.js → chunk-6FD6KFQN.js}

@@ -11,6 +11,7 @@ import {
 } from "./chunk-DTAWEQCM.js";
 import {
   BoundedFileReadError,
+  CanonApiError,
   CanonClient,
   MAX_CANON_MEDIA_BYTES,
   RUNTIME_NEW_SESSION_ACTION,
@@ -18,7 +19,6 @@ import {
   RUNTIME_STOP_AND_DROP_ACTION,
   acquireLock,
   conversationMediaCacheDir,
-  createCompletedOutputJournal,
   createRuntimeHeartbeat,
   createRuntimeStatePublisher,
   inferUploadMimeType,
@@ -31,7 +31,7 @@ import {
   resolveCanonRuntimeConnection,
   splitTextWithinBytes,
   verifyCanonRuntimeConnection
-} from "./chunk-ZPBOGOAD.js";
+} from "./chunk-5YKGDUJX.js";
 import {
   NodeMlsDevCustodyError,
   createNodeMlsDevCustody,
@@ -1585,7 +1585,7 @@ ${name}`, `Errands: ${name} in the inbox is not a command file; it is left alone
       }
       const path = join2(inbox, name);
       try {
-        if (handler.taken(id) || await handler.take(id, readCommand(path, id))) unlinkSync(path);
+        if (await handler.taken(id) || await handler.take(id, readCommand(path, id))) unlinkSync(path);
       } catch (error) {
         if (error.code === "ENOENT") continue;
         const reason = error instanceof Error ? error.message : String(error);
@@ -2413,10 +2413,10 @@ function relayRunnerHome(home, installationId) {
 __name(relayRunnerHome, "relayRunnerHome");
 
 // src/runner/runner.ts
-import { createHash as createHash8 } from "node:crypto";
-import { readFileSync as readFileSync6, rmSync as rmSync2 } from "node:fs";
+import { createHash as createHash9, randomUUID as randomUUID2 } from "node:crypto";
+import { readFileSync as readFileSync7, rmSync as rmSync2 } from "node:fs";
 import { realpath as realpath4, stat as stat2 } from "node:fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute3, join as join7, sep } from "node:path";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join8, sep } from "node:path";
 
 // ../agent-tools/src/communication-tool.ts
 var CANON_COMMUNICATE_DISCOVERY_MAX_RESULTS = 10;
@@ -2638,6 +2638,54 @@ async function executeCanonCommunicateTool(client, args) {
 }
 __name(executeCanonCommunicateTool, "executeCanonCommunicateTool");
 
+// src/runner/finals.ts
+import { createHash as createHash7 } from "node:crypto";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, rmdirSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+var sha2562 = /* @__PURE__ */ __name((value) => createHash7("sha256").update(value).digest("hex"), "sha256");
+async function importFinals(directory, scope, input) {
+  const folder = join6(directory, sha2562(JSON.stringify(scope)));
+  let names;
+  try {
+    names = readdirSync3(folder);
+  } catch {
+    return;
+  }
+  for (const name of names.sort()) {
+    const match = /^([a-f0-9]{64})(\.\d+\.[a-f0-9-]+\.tmp|\.json)$/.exec(name);
+    if (!match) continue;
+    const path = join6(folder, name);
+    const torn = match[2] !== ".json";
+    let record;
+    try {
+      record = JSON.parse(readFileSync5(path, "utf8"));
+    } catch {
+      record = void 0;
+    }
+    if (!input.valid(record) || sha2562(record.turnId) !== match[1]) {
+      if (torn) {
+        try {
+          unlinkSync2(path);
+        } catch (error) {
+          input.warn(`torn output write ${name}`)(error);
+        }
+      } else input.warn(`saved output ${name}`)(new Error("it is not a valid output; it stays for operator reconciliation"));
+      continue;
+    }
+    try {
+      await input.save(record);
+      unlinkSync2(path);
+    } catch (error) {
+      input.warn(`saved output ${name} stays where it was`)(error);
+    }
+  }
+  try {
+    rmdirSync(folder);
+  } catch {
+  }
+}
+__name(importFinals, "importFinals");
+
 // src/runner/live.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 var KEEPALIVE_MS = 3500;
@@ -2681,10 +2729,10 @@ function createLivePublisher(options) {
 __name(createLivePublisher, "createLivePublisher");
 
 // src/runner/mls-ask.ts
-import { createHash as createHash7 } from "node:crypto";
-import { readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync } from "node:fs";
-import { join as join6 } from "node:path";
-var sha2562 = /* @__PURE__ */ __name((value) => createHash7("sha256").update(value).digest("hex"), "sha256");
+import { createHash as createHash8 } from "node:crypto";
+import { readdirSync as readdirSync4, readFileSync as readFileSync6, rmSync } from "node:fs";
+import { join as join7 } from "node:path";
+var sha2563 = /* @__PURE__ */ __name((value) => createHash8("sha256").update(value).digest("hex"), "sha256");
 var pause = /* @__PURE__ */ __name((ms) => new Promise((resolve4) => {
   setTimeout(resolve4, ms).unref?.();
 }), "pause");
@@ -2738,10 +2786,10 @@ function createMlsAsks(options, approvalScope2) {
       });
     }
   });
-  const file = /* @__PURE__ */ __name((conversationId, requestId) => join6(options.directory, `${sha2562(JSON.stringify([conversationId, requestId])).slice(0, 32)}.json`), "file");
+  const file = /* @__PURE__ */ __name((conversationId, requestId) => join7(options.directory, `${sha2563(JSON.stringify([conversationId, requestId])).slice(0, 32)}.json`), "file");
   const save = /* @__PURE__ */ __name((journal) => writeDurable(file(journal.conversationId, journal.requestId), JSON.stringify(journal)), "save");
   const forget = /* @__PURE__ */ __name((journal) => rmSync(file(journal.conversationId, journal.requestId), { force: true }), "forget");
-  const operationOf = /* @__PURE__ */ __name((conversationId, messageId) => `runner-mls-ask:${sha2562(JSON.stringify([conversationId, messageId])).slice(0, 48)}`, "operationOf");
+  const operationOf = /* @__PURE__ */ __name((conversationId, messageId) => `runner-mls-ask:${sha2563(JSON.stringify([conversationId, messageId])).slice(0, 48)}`, "operationOf");
   const withdrawalOf = /* @__PURE__ */ __name((journal) => operationOf(journal.conversationId, `${journal.requestId}:withdraw`), "withdrawalOf");
   const audienceChanged = /* @__PURE__ */ __name((error) => codeOf(error) === "MLS_DEV_AUDIENCE_CHANGED", "audienceChanged");
   const sameHead = /* @__PURE__ */ __name((a, b) => JSON.stringify(a.head) === JSON.stringify(b.head), "sameHead");
@@ -3075,18 +3123,18 @@ function createMlsAsks(options, approvalScope2) {
     async recover() {
       let names;
       try {
-        names = readdirSync3(options.directory).filter((name) => name.endsWith(".json"));
+        names = readdirSync4(options.directory).filter((name) => name.endsWith(".json"));
       } catch {
         return;
       }
       for (const name of names) {
         let journal;
         try {
-          journal = JSON.parse(readFileSync5(join6(options.directory, name), "utf8"));
+          journal = JSON.parse(readFileSync6(join7(options.directory, name), "utf8"));
           if (journal.version !== 1 || typeof journal.conversationId !== "string" || typeof journal.requestId !== "string" || !Array.isArray(journal.sends) || journal.sends.some((sent) => typeof sent?.operationId !== "string" || typeof sent.messageId !== "string")) throw new Error();
           for (const sent of journal.sends) sent.audience = snapshotMlsAudience(sent.audience);
         } catch {
-          rmSync(join6(options.directory, name), { force: true });
+          rmSync(join7(options.directory, name), { force: true });
           continue;
         }
         try {
@@ -3182,6 +3230,38 @@ __name(startToolServer, "startToolServer");
 
 // src/runner/runner.ts
 var STOPS = ["stop", "drop", "new_session", "membership", "audience"];
+var toCompletion = /* @__PURE__ */ __name((record) => ({
+  version: 1,
+  id: record.turnId,
+  conversationId: record.conversationId,
+  createdAt: record.createdAt,
+  inputIds: record.inputs,
+  fence: record.mls ?? null,
+  output: {
+    text: record.text,
+    options: record.options,
+    notice: record.notice,
+    ...record.items ? { items: record.items } : {},
+    ...record.parts !== void 0 ? { parts: record.parts } : {},
+    ...record.errand ? { errand: record.errand } : {},
+    ...record.proactive ? { proactive: true } : {},
+    ...record.sent ? { sent: record.sent } : {}
+  }
+}), "toCompletion");
+var fromCompletion = /* @__PURE__ */ __name(({ id, conversationId, createdAt, inputIds, fence, output }) => ({
+  turnId: id,
+  conversationId,
+  createdAt,
+  inputs: inputIds,
+  ...output,
+  ...fence ? { mls: fence } : {}
+}), "fromCompletion");
+var isOutputFile = /* @__PURE__ */ __name((record) => {
+  const value = record;
+  return !!value && value.version === 1 && typeof value.turnId === "string" && !!value.turnId && typeof value.conversationId === "string" && !!value.conversationId && typeof value.createdAt === "string" && typeof value.text === "string" && typeof value.options?.messageId === "string" && Array.isArray(value.inputs) && value.inputs.every((id) => typeof id === "string" && !!id) && typeof value.notice === "boolean" && (value.mls === void 0 || !!value.mls && typeof value.mls === "object") && (value.parts === void 0 || Number.isSafeInteger(value.parts)) && (value.errand === void 0 || typeof value.errand === "string") && (value.proactive === void 0 || value.proactive === true) && (value.sent === void 0 || typeof value.sent?.fingerprint === "string" && ["delivered", "refused"].includes(value.sent.outcome));
+}, "isOutputFile");
+var textFingerprint = /* @__PURE__ */ __name((text3) => createHash9("sha256").update(JSON.stringify(["canon.runner.proactive-text.v1", text3])).digest("hex"), "textFingerprint");
+var PLAINTEXT_START = ["opening-text-required", "encrypted-room-required"];
 var MAX_INPUTS_PER_TURN = 20;
 var OUTBOUND_UNANSWERED = ["queued", "sending", "deferred", "pending"];
 var INBOUND_UNSETTLED = ["observed", "deferred", "offered"];
@@ -3246,7 +3326,7 @@ function answerText(answer) {
   return answer.text?.trim() ? answer.text : "They answered with an empty message.";
 }
 __name(answerText, "answerText");
-var sha2563 = /* @__PURE__ */ __name((value) => createHash8("sha256").update(value).digest("hex"), "sha256");
+var sha2564 = /* @__PURE__ */ __name((value) => createHash9("sha256").update(value).digest("hex"), "sha256");
 var toolText = /* @__PURE__ */ __name((text3, isError = false) => ({ content: [{ type: "text", text: text3 }], ...isError ? { isError } : {} }), "toolText");
 var turnEnded2 = /* @__PURE__ */ __name(() => new DOMException("This turn has ended", "AbortError"), "turnEnded");
 function within(promise, ms) {
@@ -3347,7 +3427,7 @@ function approvalScope(request) {
   if (request.scopeKey !== void 0 && /^[A-Za-z0-9_:-]{1,64}$/.test(request.scopeKey)) return request.scopeKey;
   const key = request.scopeKey ?? request.title;
   const slug = key.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "approval";
-  return `${slug}-${sha2563(JSON.stringify([request.scopeKey === void 0 ? "title" : "scope", key])).slice(0, 16)}`;
+  return `${slug}-${sha2564(JSON.stringify([request.scopeKey === void 0 ? "title" : "scope", key])).slice(0, 16)}`;
 }
 __name(approvalScope, "approvalScope");
 var MAX_GROUP_PARTS = 100;
@@ -3457,7 +3537,6 @@ async function createRunner(options) {
   let endpoint;
   let inbound;
   let heartbeat;
-  let journal;
   let agentId = "";
   let scope = "";
   let stopping;
@@ -3481,6 +3560,7 @@ async function createRunner(options) {
   const ruleNotes = /* @__PURE__ */ new Set();
   const guards = /* @__PURE__ */ new Map();
   const relaySends = /* @__PURE__ */ new Map();
+  const proactive = /* @__PURE__ */ new Map();
   let errands;
   let errandInbox2;
   let errandScope = "";
@@ -3584,7 +3664,7 @@ async function createRunner(options) {
   const dispose = /* @__PURE__ */ __name((inputs, kind, reason) => Promise.allSettled(inputs.map((input) => input.handle[kind](reason))).then(() => void 0), "dispose");
   const settle = /* @__PURE__ */ __name(async (ids, reason) => (await Promise.allSettled(ids.map((id) => endpoint.setInboundState(id, "settled", reason)))).every(({ status }) => status === "fulfilled"), "settle");
   const queued = /* @__PURE__ */ __name((turn) => turn.inputs.filter((input) => input.handle.phase === "queued"), "queued");
-  const turnId = /* @__PURE__ */ __name((roomId, inputs) => `turn-${sha2563(JSON.stringify([roomId, ...inputs.map((input) => [input.id, input.generation])])).slice(0, 32)}`, "turnId");
+  const turnId = /* @__PURE__ */ __name((roomId, inputs) => `turn-${sha2564(JSON.stringify([roomId, ...inputs.map((input) => [input.id, input.generation])])).slice(0, 32)}`, "turnId");
   const livePublisher = /* @__PURE__ */ __name((current, turn) => createLivePublisher({
     client,
     conversationId: current.id,
@@ -3593,7 +3673,7 @@ async function createRunner(options) {
       current.lane = current.lane.then(publish2).catch(() => void 0);
     }, "enqueue")
   }), "livePublisher");
-  const stateFile = /* @__PURE__ */ __name((session) => join7(home, "runner", options.environmentId, agentId, "state", driver.name, `${sha2563(JSON.stringify([scope, session]))}.json`), "stateFile");
+  const stateFile = /* @__PURE__ */ __name((session) => join8(home, "runner", options.environmentId, agentId, "state", driver.name, `${sha2564(JSON.stringify([scope, session]))}.json`), "stateFile");
   const resetSession = /* @__PURE__ */ __name(async (session) => {
     rmSync2(stateFile(session), { force: true });
     mlsAsks?.endSession(session);
@@ -4061,7 +4141,7 @@ ${decision.reasonCode}`;
     return check;
   }
   __name(reaudience, "reaudience");
-  const inboundMedia = /* @__PURE__ */ __name((conversationId) => ({ agentId: "inbound", conversationId, rootDir: join7(home, "runner", options.environmentId, agentId) }), "inboundMedia");
+  const inboundMedia = /* @__PURE__ */ __name((conversationId) => ({ agentId: "inbound", conversationId, rootDir: join8(home, "runner", options.environmentId, agentId) }), "inboundMedia");
   async function materialize(current, turn) {
     if (driver.capabilities.remote) return;
     for (const { payload: { message: message2 } } of turn.inputs) {
@@ -4112,7 +4192,7 @@ ${decision.reasonCode}`;
       ask_question: /* @__PURE__ */ __name(async (args) => {
         const question = questionOf(args);
         if (typeof question === "string") return { result: toolText(question, true) };
-        const key = sha2563(JSON.stringify(question));
+        const key = sha2564(JSON.stringify(question));
         const waiting = questions.get(key);
         const entry = waiting?.waiting ? waiting : { id: `canon:ask_question:${asked += 1}`, waiting: true };
         questions.set(key, entry);
@@ -4195,7 +4275,7 @@ ${decision.reasonCode}`;
       }
     }
     if (errand && "contact" in errand.target && (command.action === "start_conversation" || command.action === "start_direct") && command.principalId === errand.target.contact) {
-      const result = await client.communicate({ ...command, action: "start_conversation", selection: { mode: "new" } });
+      const result = await startConversation({ ...command, action: "start_conversation", selection: { mode: "new" } });
       if (result.status === "messaged") reach(turn, result.conversationId);
       return toolText(`communicate: ${result.status}
 ${JSON.stringify(result, null, 2)}`);
@@ -4211,20 +4291,18 @@ ${JSON.stringify(result, null, 2)}`);
       turn.said.set(messageId, sending = (async () => {
         const mls2 = audience ?? (await currentAudience(roomId)).audience;
         const record = {
-          version: 1,
           turnId: messageId,
           conversationId: roomId,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          audience: null,
           inputs: [],
           text: text3,
           options: { messageId },
           notice: false,
           mls: mls2
         };
-        saveOutput(record);
+        await saveOutput(record);
         const sent2 = await publish(record, turn.retire.signal);
-        if (sent2 !== "pending") journal.remove(messageId);
+        if (sent2 !== "pending") await endpoint.finishCompletion(messageId);
         else if (turn.retire.signal.aborted) await stopOutput(record);
         return sent2;
       })().catch((error) => {
@@ -4308,11 +4386,9 @@ ${JSON.stringify(result, null, 2)}`);
       const kind = failed ? "failed" : "final";
       const replyAuthority = await replyGrant(current.id, turn.inputs.at(-1).payload.message.id, stopped);
       const record = {
-        version: 1,
         turnId: turn.id,
         conversationId: current.id,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        audience: null,
         inputs: turn.inputs.map((input) => input.id),
         text: text3,
         ...items.length ? { items } : {},
@@ -4320,7 +4396,7 @@ ${JSON.stringify(result, null, 2)}`);
         notice: failed,
         mls: audience
       };
-      saveOutput(record);
+      await saveOutput(record);
       sent = await publish(record, turn.retire.signal);
       if (sent === "pending" && !stopped()) return turn.live.end(turn.reason && STOPS.includes(turn.reason) ? "stopped" : "ended");
       if (sent === "pending") await stopOutput(record);
@@ -4334,7 +4410,7 @@ ${JSON.stringify(result, null, 2)}`);
       if (current.session === turn.session) current.session = void 0;
     }
     const reason = stopped() ? turn.reason : silent ? "silent" : answered2 ? "answered" : "failed";
-    if (await settle(turn.inputs.map((input) => input.id), reason) && sent !== void 0) journal.remove(turn.id);
+    await endpoint.finishCompletion(turn.id, { inputIds: turn.inputs.map((input) => input.id), reason }).catch(warn("reply kept for restart recovery"));
   }
   __name(deliver, "deliver");
   const forOwner2 = /* @__PURE__ */ __name((turn) => turn.inputs.every(({ payload: { message: message2 } }) => message2.isOwner === true || message2.senderType === "ai_agent" && turn.trusted.has(message2.id)), "forOwner");
@@ -4364,11 +4440,16 @@ ${JSON.stringify(result, null, 2)}`);
   }
   __name(send, "send");
   const partsOf = /* @__PURE__ */ __name((text3, options2) => encryptedParts(text3, options2.replyAuthority ? MAX_REPLY_PARTS : MAX_GROUP_PARTS), "partsOf");
-  function saveOutput(record) {
+  async function saveOutput(record) {
     record.parts = partsOf(record.text, record.options).length;
-    journal.save(record);
+    await endpoint.saveCompletion(toCompletion(record));
   }
   __name(saveOutput, "saveOutput");
+  const outputs = /* @__PURE__ */ __name(async () => (await endpoint.listCompletions()).map(fromCompletion).filter((record) => !record.sent), "outputs");
+  const savedOutput = /* @__PURE__ */ __name(async (turnId2) => {
+    const found = await endpoint.getCompletion(turnId2);
+    return found && fromCompletion(found);
+  }, "savedOutput");
   function encryptedMessages(mls2, text3, options2, record) {
     const all = record && record.parts === void 0 ? [fitEncrypted(text3)] : partsOf(text3, options2);
     return all.slice(0, record?.parts).map((part, index) => ({
@@ -4384,11 +4465,9 @@ ${JSON.stringify(result, null, 2)}`);
       const status = (await endpoint.getOperation(encryptedOperation(record.mls, messageId)))?.status;
       if (status && status !== "succeeded" && status !== "rejected") queued2 = index + 1;
     }
-    if (queued2) {
-      const { items: _items, errand: _errand, ...rest } = record;
-      journal.save({ ...rest, turnId: `${record.turnId}:stopped`, inputs: [], parts: queued2 });
-    }
-    journal.remove(record.turnId);
+    const { items: _items, errand: _errand, ...rest } = record;
+    if (queued2) await endpoint.replaceCompletion(record.turnId, toCompletion({ ...rest, turnId: `${record.turnId}:stopped`, inputs: [], parts: queued2 }));
+    else await endpoint.finishCompletion(record.turnId);
   }
   __name(stopOutput, "stopOutput");
   async function sendEncrypted(audience, messageId, text3, signal, replyAuthority) {
@@ -4484,7 +4563,7 @@ ${JSON.stringify(result, null, 2)}`);
     return { items, refused: refused2 };
   }
   __name(admitItems, "admitItems");
-  const encryptedOperation = /* @__PURE__ */ __name((audience, messageId) => `runner-mls:${sha2563(JSON.stringify([audience.conversationId, messageId])).slice(0, 48)}`, "encryptedOperation");
+  const encryptedOperation = /* @__PURE__ */ __name((audience, messageId) => `runner-mls:${sha2564(JSON.stringify([audience.conversationId, messageId])).slice(0, 48)}`, "encryptedOperation");
   function forgetGuard(audience, messageId, sent) {
     if (sent === "pending") return;
     const operationId = encryptedOperation(audience, messageId);
@@ -4622,7 +4701,7 @@ ${JSON.stringify(result, null, 2)}`);
     const file = stateFile(session);
     let data = {};
     try {
-      data = JSON.parse(readFileSync6(file, "utf8"));
+      data = JSON.parse(readFileSync7(file, "utf8"));
     } catch {
     }
     const save = /* @__PURE__ */ __name((next) => {
@@ -4693,9 +4772,8 @@ ${JSON.stringify(result, null, 2)}`);
   __name(scheduleControl, "scheduleControl");
   async function recover() {
     await mlsAsks?.recover().catch(warn("pending encrypted cards"));
-    const records = journal.list();
-    const answered2 = new Set(records.flatMap((record) => record.inputs));
-    const orphans = (await endpoint.listInbound({ states: ["uncertain"] })).filter(({ event }) => event.kind === "message.created" && event.conversationId && !answered2.has(event.id));
+    const records = await outputs();
+    const orphans = (await endpoint.listInbound({ states: ["uncertain"], unanswered: true })).filter(({ event }) => event.kind === "message.created" && event.conversationId);
     for (const roomId of /* @__PURE__ */ new Set([...records.map((record) => record.conversationId), ...orphans.map(({ event }) => event.conversationId)])) {
       const target = room(roomId);
       const work = (async () => {
@@ -4725,14 +4803,14 @@ ${JSON.stringify(result, null, 2)}`);
   async function redeliver(record) {
     if (!record.mls) {
       if (record.errand) return finishErrandOutput(record, "refused", "its conversation is not encrypted");
-      if (await settle(record.inputs, "plaintext-output-dropped")) journal.remove(record.turnId);
-      return;
+      return endpoint.finishCompletion(record.turnId, { inputIds: record.inputs, reason: "plaintext-output-dropped" });
     }
     if (!mlsOn) return refuse(record.conversationId, "no-device");
     const sent = await publish(record);
     if (sent === "pending") return;
     if (record.errand) return finishErrandOutput(record, sent);
-    if (await settle(record.inputs, "recovered")) journal.remove(record.turnId);
+    if (record.proactive) return finishProactive(record, sent);
+    await endpoint.finishCompletion(record.turnId, { inputIds: record.inputs, reason: "recovered" });
   }
   __name(redeliver, "redeliver");
   function pendingNotes(roomId) {
@@ -4824,25 +4902,12 @@ ${JSON.stringify(result, null, 2)}`);
       log(`Errand ${id} (tell) kept for the next turn in ${conversationId}.`);
       return true;
     }
-    const turnId2 = `turn-${sha2563(JSON.stringify(["canon.runner.errand", id])).slice(0, 32)}`;
-    const record = {
-      version: 1,
-      turnId: turnId2,
-      conversationId,
-      createdAt,
-      audience: null,
-      inputs: [],
-      text: parsed.text,
-      options: { messageId: keyed().text("final", conversationId, turnId2) },
-      notice: false,
-      errand: id,
-      mls: target.mls
-    };
-    saveOutput(record);
+    const turnId2 = `turn-${sha2564(JSON.stringify(["canon.runner.errand", id])).slice(0, 32)}`;
+    const record = await outsideTurn({ conversationId, turnId: turnId2, text: parsed.text, mls: target.mls, createdAt, errand: id });
     errands.put({ ...base, status: "sending", updatedAt });
-    const delivery = publish(record).then((sent) => {
-      if (sent !== "pending") finishErrandOutput(record, sent);
-    }, warn(`errand ${id}`));
+    const delivery = publish(record).then(async (sent) => {
+      if (sent !== "pending") await finishErrandOutput(record, sent);
+    }).catch(warn(`errand ${id}`));
     posting.add(delivery);
     touch();
     void delivery.finally(() => {
@@ -4863,10 +4928,12 @@ ${JSON.stringify(result, null, 2)}`);
     const mode = await endpoint.getConversationContentMode(roomId).catch(missing);
     if (mode === "plaintext") return "it is not encrypted, and the agent takes part only in encrypted conversations";
     if (mode !== "mls-dev-text" || !mlsOn) return "it is an encrypted conversation this runner cannot take part in";
-    return kind === "post" ? { mls: (await currentAudience(roomId)).audience } : {};
+    if (kind !== "post") return {};
+    const { audience, ownerId } = await currentAudience(roomId);
+    return { mls: audience, ownerRoom: conversation.memberIds.length === 2 && conversation.memberIds.includes(ownerId) };
   }
   __name(errandRoom, "errandRoom");
-  function finishErrandOutput(record, sent, reason = "Canon did not accept it") {
+  async function finishErrandOutput(record, sent, reason = "Canon did not accept it") {
     const id = record.errand;
     const known = latest(id) ?? { version: 1, id, kind: "post", conversationId: record.conversationId, createdAt: record.createdAt };
     const ok = sent === "delivered";
@@ -4877,9 +4944,108 @@ ${JSON.stringify(result, null, 2)}`);
       errands?.put({ ...known, status: ok ? "sent" : "refused", ...ok ? {} : { reason }, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
       log(`Errand ${id} (post) ${ok ? "sent" : `refused: ${reason}`} in ${record.conversationId}.`);
     }
-    journal.remove(record.turnId);
+    await endpoint.finishCompletion(record.turnId);
   }
   __name(finishErrandOutput, "finishErrandOutput");
+  async function outsideTurn(input) {
+    const { conversationId, turnId: turnId2, text: text3, mls: mls2, errand } = input;
+    const record = {
+      turnId: turnId2,
+      conversationId,
+      createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      inputs: [],
+      text: text3,
+      options: { messageId: keyed().text("final", conversationId, turnId2) },
+      notice: false,
+      ...errand ? { errand } : {},
+      ...input.proactive ? { proactive: true } : {},
+      mls: mls2
+    };
+    await saveOutput(record);
+    return record;
+  }
+  __name(outsideTurn, "outsideTurn");
+  const refusal = /* @__PURE__ */ __name((status, code, message2) => new CanonApiError(status, JSON.stringify({ code, message: message2 })), "refusal");
+  function sendOutside(command) {
+    const { conversationId, text: text3 } = command;
+    if (command.privateContext !== void 0 || command.sourceLabel !== void 0) {
+      return Promise.reject(refusal(400, "ENCRYPTED_TEXT_ONLY", "Encrypted text carries no private context or source label"));
+    }
+    const turnId2 = `turn-${sha2564(JSON.stringify(["canon.runner.communicate", conversationId, command.messageId ?? randomUUID2()])).slice(0, 32)}`;
+    const conflict = /* @__PURE__ */ __name(() => refusal(409, "MESSAGE_ID_CONFLICT", "This messageId was already sent with other text"), "conflict");
+    const known = proactive.get(turnId2);
+    if (known) return known.text === text3 ? known.result : Promise.reject(conflict());
+    const result = (async () => {
+      let record = await savedOutput(turnId2);
+      const done = record ? void 0 : await savedOutput(`${turnId2}:sent`);
+      if (record ? record.text !== text3 : done && done.sent.fingerprint !== textFingerprint(text3)) throw conflict();
+      if (done) return sendResult(done.sent.outcome, conversationId, done.options.messageId);
+      if (!record) {
+        const room2 = await errandRoom(conversationId, "post");
+        if (typeof room2 === "string") throw refusal(403, "CONVERSATION_UNAVAILABLE", `This runner cannot send to ${conversationId}: ${room2}`);
+        if (outboundClosed && !room2.ownerRoom) {
+          throw refusal(403, "OUTBOUND_NOT_ALLOWED", "This agent's outbound policy is closed: it answers messages, and writes unprompted only to its owner");
+        }
+        record = await outsideTurn({ conversationId, turnId: turnId2, text: text3, mls: room2.mls, proactive: command.messageId !== void 0 });
+      }
+      const sent = await publish(record);
+      if (sent !== "pending") await finishProactive(record, sent);
+      return sendResult(sent, conversationId, record.options.messageId);
+    })().finally(() => proactive.delete(turnId2));
+    proactive.set(turnId2, { text: text3, result });
+    return result;
+  }
+  __name(sendOutside, "sendOutside");
+  async function finishProactive(record, outcome) {
+    const id = `${record.turnId}:sent`;
+    if (!record.proactive || await savedOutput(id)) return endpoint.finishCompletion(record.turnId);
+    await endpoint.replaceCompletion(record.turnId, toCompletion({
+      turnId: id,
+      conversationId: record.conversationId,
+      createdAt: record.createdAt,
+      inputs: [],
+      text: "",
+      options: { messageId: record.options.messageId },
+      notice: false,
+      sent: { fingerprint: textFingerprint(record.text), outcome }
+    }));
+  }
+  __name(finishProactive, "finishProactive");
+  function sendResult(sent, conversationId, messageId) {
+    if (sent === "delivered") return { status: "messaged", conversationId, messageId };
+    if (sent === "refused") throw refusal(409, "MESSAGE_REFUSED", "Canon did not accept the message; the conversation's members may have changed");
+    throw refusal(202, "OPERATION_PENDING", "The message is saved and will be sent when Canon is reachable; call again with the same messageId to learn how it went");
+  }
+  __name(sendResult, "sendResult");
+  async function startConversation(command) {
+    if (!mlsOn) throw refusal(403, "MLS_DEVICE_REQUIRED", "This runner has no MLS device, so it can start no conversation");
+    const input = {
+      targetUserId: command.principalId,
+      text: command.text,
+      messageId: command.messageId ?? randomUUID2(),
+      selection: command.selection ?? (command.action === "start_conversation" ? { mode: "new" } : { mode: "latest_or_new" })
+    };
+    const result = await endpoint.startWithheldOpener(input).catch(async (error) => {
+      const { code, operationId } = error;
+      if (code !== "OPERATION_PENDING" || typeof operationId !== "string") throw error;
+      const receipt = await endpoint.waitForOperation(operationId);
+      if (receipt.status !== "succeeded" || !receipt.result) throw error;
+      return receipt.result;
+    });
+    if ("reason" in result) {
+      if (PLAINTEXT_START.includes(result.reason)) throw refusal(403, "ENCRYPTED_ROOM_REQUIRED", "Canon would make that conversation plaintext, so nothing was sent");
+      return { status: result.status, reason: result.reason };
+    }
+    if ("requestId" in result) return { status: result.status, requestId: result.requestId };
+    return {
+      status: "messaged",
+      conversationId: result.conversationId,
+      messageId: result.messageId ?? input.messageId,
+      ...result.created !== void 0 ? { created: result.created } : {},
+      ...result.reused !== void 0 ? { reused: result.reused } : {}
+    };
+  }
+  __name(startConversation, "startConversation");
   const latest = /* @__PURE__ */ __name((id) => errandsById.get(id) ?? errands?.get(id), "latest");
   const openErrand = /* @__PURE__ */ __name((record) => record.kind === "errand" && !!record.conversationId && !["pending", "cancelled", "expired", "refused", "rejected"].includes(record.status), "openErrand");
   const aliveErrand = /* @__PURE__ */ __name((record) => record.kind === "errand" && (["pending", "running"].includes(record.status) || openErrand(record)), "aliveErrand");
@@ -4898,7 +5064,7 @@ ${JSON.stringify(result, null, 2)}`);
     pump();
   }
   __name(enqueueErrand, "enqueueErrand");
-  const errandTurnId = /* @__PURE__ */ __name((id) => `turn-${sha2563(JSON.stringify(["canon.runner.errand-turn", id])).slice(0, 32)}`, "errandTurnId");
+  const errandTurnId = /* @__PURE__ */ __name((id) => `turn-${sha2564(JSON.stringify(["canon.runner.errand-turn", id])).slice(0, 32)}`, "errandTurnId");
   const errandFacts = /* @__PURE__ */ __name((record) => Object.freeze({
     id: record.id,
     why: record.why,
@@ -5080,11 +5246,9 @@ ${JSON.stringify(result, null, 2)}`);
     }
     const kind = failed ? "failed" : "final";
     const out = {
-      version: 1,
       turnId: turn.id,
       conversationId: origin.room,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      audience: null,
       inputs: [],
       text: text3,
       notice: failed,
@@ -5093,7 +5257,7 @@ ${JSON.stringify(result, null, 2)}`);
       options: { messageId: keyed().text(kind, origin.room, turn.id) }
     };
     try {
-      saveOutput(out);
+      await saveOutput(out);
     } catch (error) {
       warn(`errand ${record.id}: its report could not be journaled; it stays in the record`)(error);
       saveErrand({ ...closing, report: text3, reported: "refused", reason: "its report: it could not be saved for sending" });
@@ -5105,7 +5269,7 @@ ${JSON.stringify(result, null, 2)}`);
       await stopOutput(out);
       const { reported: _reported, ...withheld2 } = latest(record.id) ?? closing;
       saveErrand({ ...withheld2, status: "cancelled", reason: STOPPED_ERRAND[turn.reason] ?? "stopped" });
-    } else if (sent !== "pending") finishErrandOutput(out, sent);
+    } else if (sent !== "pending") await finishErrandOutput(out, sent);
     turn.live.end(sent === "delivered" ? "answered" : stopped() ? "stopped" : "ended");
   }
   __name(deliverReport, "deliverReport");
@@ -5179,7 +5343,7 @@ ${JSON.stringify(result, null, 2)}`);
       if (await endpoint.getConversationContentMode(conversationId).catch(() => "unavailable") !== "mls-dev-text") {
         throw new ConnectorRelayError(403, "CONNECTOR_RELAY_NOT_ENCRYPTED", "The relay serves only encrypted conversations its agent is in");
       }
-      const journaled = journal.list().find((candidate) => candidate.turnId === id);
+      const journaled = await savedOutput(id);
       if (journaled) return { text: journaled.text, record: journaled };
       const { messages } = await readAgain(() => endpoint.query(
         "get_messages",
@@ -5190,22 +5354,20 @@ ${JSON.stringify(result, null, 2)}`);
       const { audience } = await relayRoom(conversationId);
       if (Date.now() >= deadline) throw relayBusy();
       const record = {
-        version: 1,
         turnId: id,
         conversationId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        audience: null,
         inputs: [],
         text: text3,
         options: { messageId: id },
         notice: false,
         mls: audience
       };
-      saveOutput(record);
+      await saveOutput(record);
       return { text: text3, record };
     })();
-    const sent = ready.then(({ record, settled }) => settled ?? publish(record).then((result) => {
-      if (result !== "pending") journal.remove(id);
+    const sent = ready.then(({ record, settled }) => settled ?? publish(record).then(async (result) => {
+      if (result !== "pending") await endpoint.finishCompletion(id);
       return result;
     }));
     const entry = { ready, sent };
@@ -5230,7 +5392,7 @@ ${JSON.stringify(result, null, 2)}`);
       client = new CanonClient(options.apiKey, connection.apiBaseUrl, {
         environmentId: connection.environmentId,
         streamUrl: connection.streamUrl,
-        stateDirectory: join7(home, "endpoint"),
+        stateDirectory: join8(home, "endpoint"),
         ...options.client ? { client: options.client } : {},
         // Below Canon's client floor nothing can work, wherever the refusal surfaces: a query, an operation or the stream.
         ...options.onFatal ? { onClientUpdateRequired: /* @__PURE__ */ __name((error) => options.onFatal(error), "onClientUpdateRequired") } : {},
@@ -5278,29 +5440,30 @@ ${JSON.stringify(result, null, 2)}`);
       }
       scope = JSON.stringify([identity.environmentId, agentId, identity.ownershipVersion ?? 0, identity.installationId]);
       if (mlsOn) {
-        mlsIds = createMlsIds(privateKey(join7(home, "runner", options.environmentId, agentId, "mls-ids", `${sha2563(scope).slice(0, 32)}.key`), MLS_ID_KEY_BYTES));
+        mlsIds = createMlsIds(privateKey(join8(home, "runner", options.environmentId, agentId, "mls-ids", `${sha2564(scope).slice(0, 32)}.key`), MLS_ID_KEY_BYTES));
         mlsAsks = createMlsAsks({
           endpoint,
           agentId,
-          directory: join7(home, "runner", options.environmentId, agentId, "asks", sha2563(scope).slice(0, 32)),
+          directory: join8(home, "runner", options.environmentId, agentId, "asks", sha2564(scope).slice(0, 32)),
           assertAudience,
           sessionForDestructive: options.sessionApprovalForDestructive === true,
           log
         }, approvalScope);
       }
-      journal = createCompletedOutputJournal(join7(home, "runner", options.environmentId, agentId, "finals"), scope, {
-        label: "agent runner",
-        validate: /* @__PURE__ */ __name((record) => typeof record.text === "string" && typeof record.options?.messageId === "string" && Array.isArray(record.inputs) && typeof record.notice === "boolean" && (record.mls === void 0 || !!record.mls && typeof record.mls === "object") && (record.parts === void 0 || Number.isSafeInteger(record.parts)) && (record.errand === void 0 || typeof record.errand === "string"), "validate")
-      });
+      await importFinals(
+        join8(home, "runner", options.environmentId, agentId, "finals"),
+        scope,
+        { valid: isOutputFile, save: /* @__PURE__ */ __name((record) => endpoint.saveCompletion(toCompletion(record)), "save"), warn }
+      );
       if (!options.relay && !driver.capabilities.remote) {
         errands = errandJournal(errandsDirectory(home, options.environmentId, agentId));
-        errandScope = sha2563(scope).slice(0, 32);
+        errandScope = sha2564(scope).slice(0, 32);
         const pending = errands.list().filter((record) => record.kind === "tell" && record.status === "pending").sort((a, b) => (a.createdAt ?? "").localeCompare(b.createdAt ?? "") || a.id.localeCompare(b.id));
         for (const note of pending) {
           if (note.scope === errandScope) notes.set(note.conversationId, [...notes.get(note.conversationId) ?? [], note]);
           else settleNote(note.conversationId, note, "expired", void 0, "it was left under another owner or installation");
         }
-        const reports = new Map(journal.list().flatMap((output) => output.errand ? [[output.errand, output]] : []));
+        const reports = new Map((await outputs()).flatMap((output) => output.errand ? [[output.errand, output]] : []));
         for (const record of errands.list().filter(aliveErrand)) {
           const report = reports.get(record.id);
           if (record.scope !== errandScope) saveErrand({ ...record, status: "expired", reason: "it was left under another owner or installation" });
@@ -5340,11 +5503,11 @@ ${JSON.stringify(result, null, 2)}`);
         onError: warn("event stream")
       }));
       if (errands) {
-        const journaled = /* @__PURE__ */ __name((id) => journal.list().some((record) => record.errand === id), "journaled");
+        const journaled = /* @__PURE__ */ __name(async (id) => (await outputs()).some((record) => record.errand === id), "journaled");
         try {
           errandInbox2 = watchErrandInbox(
             errandsDirectory(home, options.environmentId, agentId),
-            { taken: /* @__PURE__ */ __name((id) => errands.has(id) || journaled(id), "taken"), take: takeErrand },
+            { taken: /* @__PURE__ */ __name(async (id) => errands.has(id) || journaled(id), "taken"), take: takeErrand },
             { log }
           );
         } catch (error) {
@@ -5391,7 +5554,8 @@ ${JSON.stringify(result, null, 2)}`);
     },
     async communicate(input) {
       if (!client) throw new Error("Start the runner before sending");
-      return activeCall(() => client.communicate(parseCommunicateToolInput(input)));
+      const command = parseCommunicateToolInput(input);
+      return activeCall(() => command.action === "message_existing" ? sendOutside(command) : command.action === "start_conversation" || command.action === "start_direct" ? startConversation(command) : client.communicate(command));
     },
     async relayRead(conversationId, page = {}) {
       touch();
@@ -5418,7 +5582,7 @@ ${JSON.stringify(result, null, 2)}`);
         throw new ConnectorRelayError(400, "CONNECTOR_RELAY_INVALID", "A send needs a messageId and 1 byte to 32 KiB of text");
       }
       const deadline = options2.deadline ?? Date.now() + CONNECTOR_RELAY_ANSWER_WITHIN_MS;
-      const id = `relay-send-${sha2563(JSON.stringify([conversationId, messageId])).slice(0, 32)}`;
+      const id = `relay-send-${sha2564(JSON.stringify([conversationId, messageId])).slice(0, 32)}`;
       let entry = relaySends.get(id);
       if (!entry) relaySends.set(id, entry = prepareRelaySend(conversationId, id, text3, deadline));
       const prepared = await beforeDeadline(activeCall(() => entry.ready), deadline);
@@ -5435,7 +5599,7 @@ ${JSON.stringify(result, null, 2)}`);
       if (!options.relay || !client) throw new ConnectorRelayError(403, "CONNECTOR_RELAY_UNAVAILABLE", "This runner is not a relay");
       if (!mlsOn) throw new ConnectorRelayError(503, "CONNECTOR_RELAY_NO_DEVICE", "The relay has no MLS device");
       const deadline = startOptions.deadline ?? Date.now() + CONNECTOR_RELAY_ANSWER_WITHIN_MS;
-      const identity = { messageId, historyMessageId: `relay-start-${sha2563(messageId).slice(0, 32)}` };
+      const identity = { messageId, historyMessageId: `relay-start-${sha2564(messageId).slice(0, 32)}` };
       const answer = await within(
         activeCall(() => endpoint.startWithheldOpener({
           targetUserId,
@@ -5460,7 +5624,7 @@ ${JSON.stringify(result, null, 2)}`);
       }
       const result = answer.result;
       if ("reason" in result) {
-        if (result.reason === "opening-text-required") {
+        if (PLAINTEXT_START.includes(result.reason)) {
           throw new ConnectorRelayError(403, "CONNECTOR_RELAY_NOT_ENCRYPTED", "The relay serves only encrypted conversations its agent is in");
         }
         return { ...identity, status: result.status, reason: result.reason };