openhivemind 0.1.0 → 0.2.0

package/dist/cli.js

@@ -532,8 +532,8 @@ var require_graceful_fs = __commonJS({
       fs2.createReadStream = createReadStream;
       fs2.createWriteStream = createWriteStream;
       var fs$readFile = fs2.readFile;
-      fs2.readFile = readFile7;
-      function readFile7(path, options2, cb) {
+      fs2.readFile = readFile8;
+      function readFile8(path, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$readFile(path, options2, cb);
@@ -709,7 +709,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open4(that.path, that.flags, that.mode, function(err, fd) {
+        open5(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -729,7 +729,7 @@ var require_graceful_fs = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open4(that.path, that.flags, that.mode, function(err, fd) {
+        open5(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -746,8 +746,8 @@ var require_graceful_fs = __commonJS({
         return new fs2.WriteStream(path, options2);
       }
       var fs$open = fs2.open;
-      fs2.open = open4;
-      function open4(path, flags, mode, cb) {
+      fs2.open = open5;
+      function open5(path, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path, flags, mode, cb);
@@ -1623,7 +1623,7 @@ var require_proper_lockfile = __commonJS({
 });
 
 // src/cli.ts
-import { readdir as readdir6, readFile as readFile6 } from "fs/promises";
+import { readdir as readdir6, readFile as readFile7 } from "fs/promises";
 import { resolve as resolve3 } from "path";
 
 // ../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -3217,11 +3217,11 @@ function FromProperties7(value) {
     Acc[K] = Readonly(FromValue(value[K], false));
   return Acc;
 }
-function ConditionalReadonly(T, root) {
-  return root === true ? T : Readonly(T);
+function ConditionalReadonly(T, root2) {
+  return root2 === true ? T : Readonly(T);
 }
-function FromValue(value, root) {
-  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt2() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
+function FromValue(value, root2) {
+  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root2) : IsIterator(value) ? ConditionalReadonly(Any(), root2) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root2) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root2) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt2() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
 }
 function Const(T, options2) {
   return CreateType(FromValue(T, true), options2);
@@ -4487,8 +4487,8 @@ var Invite = Type.Object({
   expires_at: Timestamp
 });
 var empty = Type.Object({});
-function route(method, path, params, body, response, query, status = 200) {
-  return { method, path, params, body, response, query, status };
+function route(method, path, params, body, response, query2, status = 200) {
+  return { method, path, params, body, response, query: query2, status };
 }
 var sessionId = Type.Object({ id: Id });
 var ok = Type.Object({ ok: Type.Literal(true) });
@@ -4548,8 +4548,10 @@ var routes = {
       around: Type.Optional(Type.Integer({ minimum: 1 })),
       context: Type.Optional(Type.Integer({ minimum: 0, maximum: 100, default: 10 })),
       last: Type.Optional(Type.Integer({ minimum: 1, maximum: 500 })),
+      cursor: Type.Optional(string()),
       kind: Type.Optional(Kind2),
-      maxChars: Type.Optional(Type.Integer({ minimum: 1, maximum: 2e5, default: 2e4 }))
+      maxChars: Type.Optional(Type.Integer({ minimum: 1, maximum: 2e5, default: 2e4 })),
+      wholeMessages: Type.Optional(Type.Boolean())
     })
   ),
   search: route(
@@ -7160,6 +7162,10 @@ var record = (value) => value !== null && typeof value === "object" && !Array.is
 var str = (value, fallback = "") => typeof value === "string" ? value : fallback;
 var num = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
 var list = (value) => Array.isArray(value) ? value : [];
+var INJECTED_WRAPPER = /<system-reminder>[\s\S]*?<\/system-reminder>|<command-name>[\s\S]*?<\/command-name>|<command-message>[\s\S]*?<\/command-message>|<command-args>[\s\S]*?<\/command-args>/g;
+function stripInjectedPrompt(text) {
+  return text.replace(INJECTED_WRAPPER, "").trim();
+}
 function parseRecords(source, rows, previous) {
   const messages = previous?.messages.map((message) => ({ ...message })) ?? [];
   const meta2 = {};
@@ -7194,16 +7200,27 @@ function parseRecords(source, rows, previous) {
       if (data.cwd) meta2.cwd = str(data.cwd);
       if (data.version) meta2.version = str(data.version);
       if (branch) meta2.branch = branch;
+      if (data.type === "ai-title") {
+        const title = str(data.aiTitle, str(payload.aiTitle));
+        if (title.trim()) meta2.title = title;
+        return;
+      }
       if (data.type !== "user" && data.type !== "assistant") return;
+      if (data.type === "user" && data.isMeta) return;
       model = str(message.model) || model;
       const kind = data.isCompactSummary ? "summary" : data.type === "user" ? "prompt" : "reply";
+      const clean = (text) => kind === "prompt" ? stripInjectedPrompt(text) : text;
       const before = messages.length;
-      if (typeof message.content === "string") emit2(kind, message.content, "text");
-      else
+      if (typeof message.content === "string") {
+        const text = clean(message.content);
+        if (text) emit2(kind, text, "text");
+      } else
         list(message.content).forEach((value, blockIndex) => {
           const block = record(value);
-          if (block.type === "text") emit2(kind, str(block.text), String(blockIndex));
-          else if (block.type === "tool_use")
+          if (block.type === "text") {
+            const text = clean(str(block.text));
+            if (text) emit2(kind, text, String(blockIndex));
+          } else if (block.type === "tool_use")
             emit2(
               "tool_call",
               toolSummary(str(block.name), block.input),
@@ -7325,10 +7342,10 @@ import { stat as stat5 } from "fs/promises";
 
 // src/capture.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { mkdir as mkdir2, readFile, open as open2, readdir, stat as stat2, realpath } from "fs/promises";
+import { mkdir as mkdir2, readFile, open as open3, readdir, stat as stat2, realpath } from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
-import { homedir as homedir2 } from "os";
-import { join as join2, relative, isAbsolute, resolve } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3, relative, isAbsolute, resolve } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 
@@ -7383,6 +7400,136 @@ function errorClass(error) {
   return error instanceof Error ? error.name : "unknown";
 }
 
+// src/harnesses/opencode.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var dataHome = () => process.env["XDG_DATA_HOME"] || join2(homedir2(), ".local/share");
+var opencodeDatabase = () => join2(dataHome(), "opencode", "opencode.db");
+var PLACEHOLDER = /^New session\b/;
+function open2(path) {
+  const { DatabaseSync } = __require(["node", "sqlite"].join(":"));
+  return new DatabaseSync(path, { readOnly: true, timeout: 2e3 });
+}
+function query(path, run) {
+  const database = open2(path);
+  try {
+    return run(database);
+  } finally {
+    database.close();
+  }
+}
+function safely(fallback, run) {
+  try {
+    return run();
+  } catch {
+    return fallback;
+  }
+}
+var str2 = (value) => typeof value === "string" ? value : "";
+function sessionRow(path, sessionId2) {
+  return query(
+    path,
+    (database) => database.prepare("SELECT parent_id, directory, title, version FROM session WHERE id = ?").get(sessionId2)
+  );
+}
+function opencodeTitle(path, sessionId2) {
+  const title = safely(void 0, () => sessionRow(path, sessionId2))?.title;
+  return title && !PLACEHOLDER.test(title) ? title : void 0;
+}
+function root(path, row) {
+  let id = row.parent_id;
+  for (let depth = 1; id && depth <= 8; depth++) {
+    const parent = sessionRow(path, id);
+    if (!parent?.parent_id) return { id, depth };
+    id = parent.parent_id;
+  }
+  return void 0;
+}
+function opencodeEvent(input) {
+  const value = input ?? {};
+  const sessionId2 = str2(value["sessionId"]);
+  if (!sessionId2) throw new Error("Hook input is missing sessionId");
+  const transcriptPath = str2(value["dbPath"]) || opencodeDatabase();
+  const row = sessionRow(transcriptPath, sessionId2);
+  if (!row) throw new Error("No opencode session for this id");
+  const title = PLACEHOLDER.test(row.title) ? "" : row.title;
+  const parent = root(transcriptPath, row);
+  return {
+    sessionId: sessionId2,
+    transcriptPath,
+    cwd: row.directory || str2(value["cwd"]),
+    source: "opencode",
+    ...row.version ? { version: row.version } : {},
+    ...title ? { title } : {},
+    ...parent ? { parentId: parent.id, spawnDepth: parent.depth } : {}
+  };
+}
+function opencodeChildren(event) {
+  const children2 = [];
+  safely(
+    void 0,
+    () => query(event.transcriptPath, (database) => {
+      const statement = database.prepare(
+        "SELECT id, directory, title, version FROM session WHERE parent_id = ?"
+      );
+      let frontier = [event.sessionId];
+      for (let depth = 1; frontier.length && depth <= 8; depth++) {
+        const next = [];
+        for (const parent of frontier)
+          for (const row of statement.all(parent)) {
+            const id = str2(row["id"]);
+            const title = str2(row["title"]);
+            next.push(id);
+            children2.push({
+              sessionId: id,
+              transcriptPath: event.transcriptPath,
+              cwd: str2(row["directory"]) || event.cwd,
+              source: "opencode",
+              parentId: event.sessionId,
+              spawnDepth: depth,
+              ...str2(row["version"]) ? { version: str2(row["version"]) } : {},
+              ...title && !PLACEHOLDER.test(title) ? { title } : {},
+              ...event.completed ? { completed: true } : {}
+            });
+          }
+        frontier = next;
+      }
+    })
+  );
+  return children2;
+}
+function opencodeRecords(path, sessionId2, cursor) {
+  return query(path, (database) => {
+    const messages = database.prepare(
+      `SELECT m.id AS id, m.time_created AS created, m.data AS data,
+                max(m.time_updated,
+                    coalesce((SELECT max(p.time_updated) FROM part p WHERE p.message_id = m.id), 0))
+                  AS updated
+         FROM message m WHERE m.session_id = ? ORDER BY m.time_created, m.id`
+    ).all(sessionId2);
+    const parts = database.prepare("SELECT id, data FROM part WHERE message_id = ? ORDER BY id");
+    let next = cursor;
+    const records = [];
+    for (const message of messages) {
+      const updated = Number(message["updated"] ?? 0);
+      if (updated > next) next = updated;
+      if (updated <= cursor) continue;
+      records.push({
+        id: str2(message["id"]),
+        created_at: Number(message["created"] ?? 0),
+        info: JSON.parse(str2(message["data"]) || "{}"),
+        parts: parts.all(str2(message["id"])).map(
+          (part) => ({
+            ...JSON.parse(str2(part["data"]) || "{}"),
+            id: str2(part["id"])
+          })
+        )
+      });
+    }
+    return { records, cursor: next };
+  });
+}
+
 // src/capture.ts
 var exec = promisify(execFile);
 var TITLE_MAX = 120;
@@ -7393,8 +7540,11 @@ function deriveTitle(text) {
   const boundary = cut.lastIndexOf(" ");
   return (boundary > 0 ? cut.slice(0, boundary) : cut).trimEnd() + "\u2026";
 }
-function inside(path, root) {
-  const rel = relative(root, path);
+function placeholderTitle(title) {
+  return !title || /^(untitled(?: session)?|new chat)$/i.test(title.trim());
+}
+function inside(path, root2) {
+  const rel = relative(root2, path);
   return rel === "" || !rel.startsWith("../") && rel !== ".." && !isAbsolute(rel);
 }
 async function allowed(cwd, config) {
@@ -7404,18 +7554,18 @@ async function allowed(cwd, config) {
     resolveAll(config.roots),
     resolveAll(config.exclude)
   ]);
-  return !exclude.some((root) => inside(path, root)) && (!roots.length || roots.some((root) => inside(path, root)));
+  return !exclude.some((root2) => inside(path, root2)) && (!roots.length || roots.some((root2) => inside(path, root2)));
 }
 async function patterns2(cwd) {
   const result = [];
-  let root = cwd;
+  let root2 = cwd;
   try {
-    root = (await exec("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { timeout: 5e3 })).stdout.trim();
+    root2 = (await exec("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { timeout: 5e3 })).stdout.trim();
   } catch {
   }
   for (const path of [
-    join2(root, ".openhivemind-ignore"),
-    join2(homedir2(), ".config/openhivemind/ignore")
+    join3(root2, ".openhivemind-ignore"),
+    join3(homedir3(), ".config/openhivemind/ignore")
   ]) {
     try {
       result.push(...ignorePatterns(await readFile(path, "utf8")));
@@ -7428,7 +7578,7 @@ async function patterns2(cwd) {
 }
 async function readState(folder, event) {
   try {
-    return JSON.parse(await readFile(join2(folder, "state.json"), "utf8"));
+    return JSON.parse(await readFile(join3(folder, "state.json"), "utf8"));
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
       throw error;
@@ -7445,7 +7595,7 @@ async function readState(folder, event) {
     };
   }
 }
-var sessionFolder = (config, source, sessionId2) => join2(stateRoot(config), source, digest(sessionId2));
+var sessionFolder = (config, source, sessionId2) => join3(stateRoot(config), source, digest(sessionId2));
 var UNSPOOLED_STATUSES = /* @__PURE__ */ new Set(["excluded", "no origin", "sensitive locator"]);
 var wasSpooled = (status) => !UNSPOOLED_STATUSES.has(status);
 async function capture(event, config, options2 = {}) {
@@ -7471,7 +7621,7 @@ async function capture(event, config, options2 = {}) {
   };
   if (JSON.stringify(scrubValue(locator, extra)) !== JSON.stringify(locator))
     return { status: "sensitive locator", chunks: 0, bytes: 0 };
-  const root = stateRoot(config);
+  const root2 = stateRoot(config);
   const folder = sessionFolder(config, event.source, event.sessionId);
   await mkdir2(folder, { recursive: true, mode: 448 });
   const release = await import_proper_lockfile.default.lock(folder, {
@@ -7483,28 +7633,45 @@ async function capture(event, config, options2 = {}) {
     let state = await readState(folder, event);
     const files = (await readdir(folder)).filter((name) => name.endsWith(".batch.json")).sort();
     for (const name of files) {
-      const envelope2 = JSON.parse(await readFile(join2(folder, name), "utf8"));
+      const envelope2 = JSON.parse(await readFile(join3(folder, name), "utf8"));
       if (envelope2.after.generation > state.generation) state = envelope2.after;
     }
-    const info = await stat2(event.transcriptPath);
-    const restart = info.ino !== state.inode || info.size < state.offset;
-    const offset = restart ? 0 : state.offset;
-    const file = await open2(event.transcriptPath, "r");
-    let buffer;
-    try {
-      buffer = Buffer.alloc(Math.min(info.size - offset, options2.readWindow ?? 16 * 1024 * 1024));
-      const result = await file.read(buffer, 0, buffer.length, offset);
-      buffer = buffer.subarray(0, result.bytesRead);
-    } finally {
-      await file.close();
-    }
-    const end = buffer.lastIndexOf(10);
-    if (end < 0 && offset + buffer.length < info.size)
-      return { status: "line exceeds window", chunks: 0, bytes: 0 };
     const closing = Boolean(event.completed) && Boolean(state.meta) && !state.meta?.completed;
-    if (end < 0 && !closing) return { status: "no complete records", chunks: 0, bytes: 0 };
-    const lines = buffer.subarray(0, end + 1).toString("utf8").split("\n").filter(Boolean);
-    const records = lines.map((line) => JSON.parse(line));
+    const eventTitle = event.title ? deriveTitle(scrubValue(event.title, extra)) : void 0;
+    const titleChanged = Boolean(state.meta && eventTitle && eventTitle !== state.meta.title);
+    let records;
+    let offset;
+    let inode;
+    let restart = false;
+    if (event.source === "opencode") {
+      const read = opencodeRecords(event.transcriptPath, event.sessionId, state.offset);
+      records = read.records;
+      offset = read.cursor;
+      inode = state.inode;
+      if (!records.length && !closing && !titleChanged)
+        return { status: "no complete records", chunks: 0, bytes: 0 };
+    } else {
+      const info = await stat2(event.transcriptPath);
+      restart = info.ino !== state.inode || info.size < state.offset;
+      inode = info.ino;
+      const from = restart ? 0 : state.offset;
+      const file = await open3(event.transcriptPath, "r");
+      let buffer;
+      try {
+        buffer = Buffer.alloc(Math.min(info.size - from, options2.readWindow ?? 16 * 1024 * 1024));
+        const result = await file.read(buffer, 0, buffer.length, from);
+        buffer = buffer.subarray(0, result.bytesRead);
+      } finally {
+        await file.close();
+      }
+      const end = buffer.lastIndexOf(10);
+      if (end < 0 && from + buffer.length < info.size)
+        return { status: "line exceeds window", chunks: 0, bytes: 0 };
+      if (end < 0 && !closing && !titleChanged)
+        return { status: "no complete records", chunks: 0, bytes: 0 };
+      offset = from + end + 1;
+      records = buffer.subarray(0, end + 1).toString("utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    }
     const parsed = parseRecords(event.source, records, {
       messages: restart ? [] : state.pending,
       seenUsage: restart ? [] : state.seenUsage,
@@ -7524,7 +7691,13 @@ async function capture(event, config, options2 = {}) {
         cwd: event.cwd,
         branch: safe.meta.branch ?? state.meta?.branch ?? "",
         branches: [.../* @__PURE__ */ new Set([...state.meta?.branches ?? [], safe.meta.branch ?? ""])],
-        title: state.meta?.title ?? (event.title ? deriveTitle(event.title) : void 0) ?? (firstPrompt ? deriveTitle(firstPrompt) : void 0) ?? "Untitled session",
+        // Native harness names are more useful than a prompt-derived fallback and may only be
+        // written after an earlier capture. The title is scrubbed before it is clamped.
+        title: (() => {
+          const native = (safe.meta.title ? deriveTitle(safe.meta.title) : void 0) ?? eventTitle;
+          const prompt = firstPrompt ? deriveTitle(firstPrompt) : void 0;
+          return (!placeholderTitle(native) ? native : void 0) ?? (!placeholderTitle(state.meta?.title) ? state.meta?.title : void 0) ?? prompt ?? native ?? state.meta?.title ?? "Untitled session";
+        })(),
         started_at: state.meta?.started_at ?? safe.messages[0]?.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
         completed: Boolean(state.meta?.completed || event.completed),
         spawn_depth: state.meta?.spawn_depth ?? event.spawnDepth ?? 0,
@@ -7571,8 +7744,8 @@ async function capture(event, config, options2 = {}) {
     }
     const after = {
       generation: state.generation + 1,
-      offset: offset + end + 1,
-      inode: info.ino,
+      offset,
+      inode,
       recordIndex: (restart ? 0 : state.recordIndex) + records.length,
       nextSeq,
       entries,
@@ -7593,24 +7766,28 @@ async function capture(event, config, options2 = {}) {
       }
       batch.push(message);
     }
-    if (batch.length || state.meta?.completed !== meta2.completed)
+    const published = Boolean(state.published || Object.keys(state.entries).length);
+    const metaChanged = Boolean(
+      published && state.meta && JSON.stringify(state.meta) !== JSON.stringify(meta2)
+    );
+    if (batch.length || metaChanged)
       payloads.push({ protocolVersion: 1, chunkId: randomUUID2(), meta: meta2, messages: batch });
     if (options2.dryRun) return { status: "dry run", chunks: payloads.length, bytes: 0, payloads };
     const envelope = { chunks: payloads, after };
     const serialized = JSON.stringify(envelope);
-    const pendingSize = await spoolBytes(root);
+    const pendingSize = await spoolBytes(root2);
     if (pendingSize + Buffer.byteLength(serialized) > (config.spoolLimit ?? 256 * 1024 * 1024)) {
-      await atomic(join2(folder, "state.json"), { ...state, event, paused: true });
+      await atomic(join3(folder, "state.json"), { ...state, event, paused: true });
       return { status: "paused", chunks: 0, bytes: 0 };
     }
     if (payloads.length) {
       await atomic(
-        join2(folder, String(after.generation).padStart(16, "0") + ".batch.json"),
+        join3(folder, String(after.generation).padStart(16, "0") + ".batch.json"),
         envelope
       );
       await options2.afterChunk?.();
     }
-    await atomic(join2(folder, "state.json"), after);
+    await atomic(join3(folder, "state.json"), after);
     return {
       status: "captured",
       chunks: payloads.length,
@@ -7620,19 +7797,19 @@ async function capture(event, config, options2 = {}) {
     await release();
   }
 }
-async function spoolBytes(root) {
+async function spoolBytes(root2) {
   let total = 0;
-  for (const file of await readdir(root, { recursive: true, withFileTypes: true })) {
+  for (const file of await readdir(root2, { recursive: true, withFileTypes: true })) {
     if (file.isFile() && file.name.endsWith(".batch.json"))
-      total += (await stat2(join2(file.parentPath, file.name))).size;
+      total += (await stat2(join3(file.parentPath, file.name))).size;
   }
   return total;
 }
 
 // src/harnesses/claude-code.ts
 import { readFile as readFile2, readdir as readdir2, stat as stat3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname2, join as join3 } from "path";
+import { homedir as homedir4 } from "os";
+import { basename, dirname as dirname2, join as join4 } from "path";
 function claudeCodeEvent(input) {
   if (!input || typeof input !== "object") throw new Error("Hook input is not an object");
   const value = input;
@@ -7651,8 +7828,28 @@ function claudeCodeEvent(input) {
     ...event === "SessionEnd" ? { completed: true } : {}
   };
 }
+async function claudeCodeTitle(transcriptPath) {
+  let lines;
+  try {
+    lines = (await readFile2(transcriptPath, "utf8")).split("\n").filter(Boolean);
+  } catch {
+    return void 0;
+  }
+  for (let index = lines.length - 1; index >= 0; index--) {
+    try {
+      const record3 = JSON.parse(lines[index]);
+      if (record3.type !== "ai-title") continue;
+      const direct = record3.aiTitle;
+      const payload = record3.payload;
+      const title = typeof direct === "string" ? direct : payload?.aiTitle;
+      if (typeof title === "string" && title.trim()) return title;
+    } catch {
+    }
+  }
+  return void 0;
+}
 async function claudeCodeChildren(event) {
-  const folder = join3(dirname2(event.transcriptPath), event.sessionId, "subagents");
+  const folder = join4(dirname2(event.transcriptPath), event.sessionId, "subagents");
   const names = (await readdir2(folder).catch(() => [])).filter(
     (name) => /^agent-.+\.jsonl$/.test(name)
   );
@@ -7660,13 +7857,13 @@ async function claudeCodeChildren(event) {
   for (const name of names.sort()) {
     const agentId = name.slice("agent-".length, -".jsonl".length);
     const meta2 = JSON.parse(
-      await readFile2(join3(folder, name.replace(/\.jsonl$/, ".meta.json")), "utf8").catch(
+      await readFile2(join4(folder, name.replace(/\.jsonl$/, ".meta.json")), "utf8").catch(
         () => "{}"
       )
     );
     children2.push({
       sessionId: `${event.sessionId}:${agentId}`,
-      transcriptPath: join3(folder, name),
+      transcriptPath: join4(folder, name),
       cwd: event.cwd,
       source: event.source,
       parentId: event.sessionId,
@@ -7683,11 +7880,11 @@ async function claudeCodeLocate(input) {
   let transcriptPath = input;
   if (!input.endsWith(".jsonl")) {
     if (!/^[0-9a-f-]{8,}$/i.test(input)) return void 0;
-    const root = join3(homedir3(), ".claude/projects");
-    const projects = await readdir2(root).catch(() => []);
+    const root2 = join4(homedir4(), ".claude/projects");
+    const projects = await readdir2(root2).catch(() => []);
     const candidates = (await Promise.all(
       projects.map(async (project) => {
-        const path = join3(root, project, input + ".jsonl");
+        const path = join4(root2, project, input + ".jsonl");
         return await stat3(path).catch(() => void 0) ? path : void 0;
       })
     )).filter((path) => path !== void 0);
@@ -7738,15 +7935,45 @@ async function claudeCodeLocate(input) {
 import { basename as basename3 } from "path";
 
 // src/harnesses/codex.ts
-import { open as open3, readdir as readdir3 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { basename as basename2, dirname as dirname3, join as join4, sep } from "path";
+import { open as open4, readFile as readFile3, readdir as readdir3 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { basename as basename2, dirname as dirname3, join as join5, sep } from "path";
 var FIRST_LINE = 64 * 1024;
 var ROLLOUT = /^rollout-.+\.jsonl$/;
-var sessionsRoot = () => join4(process.env["CODEX_HOME"] || join4(homedir4(), ".codex"), "sessions");
+var sessionsRoot = () => join5(process.env["CODEX_HOME"] || join5(homedir5(), ".codex"), "sessions");
+var codexHome = () => process.env["CODEX_HOME"] || join5(homedir5(), ".codex");
 var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+async function codexTitle(sessionId2) {
+  try {
+    const lines = (await readFile3(join5(codexHome(), "session_index.jsonl"), "utf8")).split("\n").filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index--) {
+      try {
+        const item = record2(JSON.parse(lines[index]));
+        if (item.id === sessionId2 && typeof item.thread_name === "string" && item.thread_name.trim())
+          return item.thread_name;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    const { DatabaseSync } = __require(["node", "sqlite"].join(":"));
+    const database = new DatabaseSync(join5(codexHome(), "state_5.sqlite"), { readOnly: true });
+    try {
+      const row = database.prepare("SELECT title, name, first_user_message FROM threads WHERE id = ?").get(sessionId2);
+      for (const field of ["title", "name", "first_user_message"]) {
+        const title = row?.[field];
+        if (typeof title === "string" && title.trim()) return title;
+      }
+    } finally {
+      database.close();
+    }
+  } catch {
+  }
+  return void 0;
+}
 async function meta(path) {
-  const file = await open3(path, "r");
+  const file = await open4(path, "r");
   let text;
   try {
     const buffer = Buffer.alloc(FIRST_LINE);
@@ -7774,12 +8001,12 @@ async function meta(path) {
   };
 }
 async function findRollout(sessionId2) {
-  const root = sessionsRoot();
-  const files = await readdir3(root, { recursive: true, withFileTypes: true }).catch(() => []);
+  const root2 = sessionsRoot();
+  const files = await readdir3(root2, { recursive: true, withFileTypes: true }).catch(() => []);
   const match = files.find(
     (file) => file.isFile() && ROLLOUT.test(file.name) && file.name.endsWith(`-${sessionId2}.jsonl`)
   );
-  return match && join4(match.parentPath, match.name);
+  return match && join5(match.parentPath, match.name);
 }
 async function codexEvent(input) {
   if (!input || typeof input !== "object") throw new Error("Hook input is not an object");
@@ -7794,11 +8021,13 @@ async function codexEvent(input) {
   const given = value["transcript_path"];
   const transcriptPath = typeof given === "string" && given ? given : await findRollout(sessionId2);
   if (!transcriptPath) throw new Error("No rollout file for this Codex session");
+  const title = await codexTitle(sessionId2);
   return {
     sessionId: sessionId2,
     transcriptPath,
     cwd,
     source: "codex",
+    ...title ? { title } : {},
     ...name === "SessionEnd" ? { completed: true } : {}
   };
 }
@@ -7811,7 +8040,7 @@ function days(folder) {
   const pad = (value) => String(value).padStart(2, "0");
   return [
     folder,
-    join4(
+    join5(
       parts.slice(0, -3).join(sep),
       String(next.getUTCFullYear()),
       pad(next.getUTCMonth() + 1),
@@ -7825,7 +8054,7 @@ async function codexChildren(event) {
   for (const folder of days(dirname3(event.transcriptPath))) {
     const names = (await readdir3(folder).catch(() => [])).filter((name) => name !== own && ROLLOUT.test(name)).sort();
     for (const name of names) {
-      const path = join4(folder, name);
+      const path = join5(folder, name);
       const child = await meta(path);
       if (!child.id || child.parent !== event.sessionId) continue;
       children2.push({
@@ -7846,6 +8075,8 @@ async function codexChildren(event) {
 // src/harnesses/index.ts
 var ROLLOUT2 = /^rollout-.+\.jsonl$/;
 function hookEvent(input) {
+  if (input?.["source"] === "opencode")
+    return Promise.resolve(opencodeEvent(input));
   const path = input?.["transcript_path"];
   const codex = typeof path !== "string" || !path || ROLLOUT2.test(basename3(path));
   return codex ? codexEvent(input) : Promise.resolve(claudeCodeEvent(input));
@@ -7853,8 +8084,14 @@ function hookEvent(input) {
 function children(event) {
   if (event.parentId) return Promise.resolve([]);
   if (event.source === "claude-code") return claudeCodeChildren(event);
+  if (event.source === "opencode") return Promise.resolve(opencodeChildren(event));
   return event.source === "codex" ? codexChildren(event) : Promise.resolve([]);
 }
+async function refreshEvent(event) {
+  if (event.parentId) return event;
+  const title = event.source === "codex" ? await codexTitle(event.sessionId) : event.source === "claude-code" ? await claudeCodeTitle(event.transcriptPath) : opencodeTitle(event.transcriptPath, event.sessionId);
+  return title ? { ...event, title } : event;
+}
 
 // src/commands/sync.ts
 var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
@@ -7862,8 +8099,8 @@ import { mkdir as mkdir4 } from "fs/promises";
 
 // src/upload.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
-import { mkdir as mkdir3, readFile as readFile3, readdir as readdir4, rename as rename2, rm as rm2, stat as stat4 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir3, readFile as readFile4, readdir as readdir4, rename as rename2, rm as rm2, stat as stat4 } from "fs/promises";
+import { dirname as dirname4, join as join6 } from "path";
 import { setTimeout as delay } from "timers/promises";
 var ATTEMPTS = 4;
 var REJECTIONS = 3;
@@ -7901,8 +8138,10 @@ async function deliver(api, path, envelope, externalId, options2) {
     remaining.shift();
     sent++;
   }
-  if (!remaining.length) await rm2(path, { force: true });
-  else if (sent || outcome.kind === "permanent")
+  if (!remaining.length) {
+    await atomic(join6(dirname4(path), "state.json"), { ...envelope.after, published: true });
+    await rm2(path, { force: true });
+  } else if (sent || outcome.kind === "permanent")
     await atomic(path, {
       ...envelope,
       chunks: remaining,
@@ -7913,8 +8152,8 @@ async function deliver(api, path, envelope, externalId, options2) {
 async function outstanding(event, config) {
   const info = await stat4(event.transcriptPath).catch(() => void 0);
   if (!info) return false;
-  const state = await readFile3(
-    join5(sessionFolder(config, event.source, event.sessionId), "state.json"),
+  const state = await readFile4(
+    join6(sessionFolder(config, event.source, event.sessionId), "state.json"),
     "utf8"
   ).catch(() => void 0);
   if (!state) return true;
@@ -7923,20 +8162,20 @@ async function outstanding(event, config) {
 }
 async function dropSession(folder, state) {
   for (const name of await readdir4(folder))
-    if (name.endsWith(".batch.json")) await rm2(join5(folder, name), { force: true });
-  await atomic(join5(folder, "state.json"), { ...state, tombstoned: true });
+    if (name.endsWith(".batch.json")) await rm2(join6(folder, name), { force: true });
+  await atomic(join6(folder, "state.json"), { ...state, tombstoned: true });
 }
 async function drain(config, options2 = {}, resumed = false) {
-  const root = stateRoot(config);
-  await mkdir3(root, { recursive: true, mode: 448 });
+  const root2 = stateRoot(config);
+  await mkdir3(root2, { recursive: true, mode: 448 });
   const api = createApi(config.server, config.token, options2.transport);
   const errors = [];
   let sent = 0;
   let stopped = false;
-  const files = (await readdir4(root, { recursive: true, withFileTypes: true })).filter((file) => file.isFile() && file.name.endsWith(".batch.json")).sort((a, b) => a.name.localeCompare(b.name));
+  const files = (await readdir4(root2, { recursive: true, withFileTypes: true })).filter((file) => file.isFile() && file.name.endsWith(".batch.json")).sort((a, b) => a.name.localeCompare(b.name));
   for (const item of files) {
     if (stopped) break;
-    const path = join5(item.parentPath, item.name);
+    const path = join6(item.parentPath, item.name);
     let release;
     try {
       release = await import_proper_lockfile2.default.lock(item.parentPath, { stale: 1e4, update: 3e3, retries: 0 });
@@ -7944,7 +8183,7 @@ async function drain(config, options2 = {}, resumed = false) {
       continue;
     }
     try {
-      const envelope = JSON.parse(await readFile3(path, "utf8"));
+      const envelope = JSON.parse(await readFile4(path, "utf8"));
       const event = envelope.after.event;
       if (!await allowed(event.cwd, config)) {
         errors.push("excluded pending session");
@@ -7952,7 +8191,7 @@ async function drain(config, options2 = {}, resumed = false) {
       }
       const state = await readState(item.parentPath, event);
       if (envelope.after.generation > state.generation)
-        await atomic(join5(item.parentPath, "state.json"), envelope.after);
+        await atomic(join6(item.parentPath, "state.json"), envelope.after);
       const result = await deliver(api, path, envelope, event.sessionId, options2);
       sent += result.sent;
       if (result.outcome.kind === "gone") await dropSession(item.parentPath, envelope.after);
@@ -7984,27 +8223,28 @@ async function drain(config, options2 = {}, resumed = false) {
       await release();
     }
   }
-  const states = (await readdir4(root, { recursive: true, withFileTypes: true })).filter(
+  const states = (await readdir4(root2, { recursive: true, withFileTypes: true })).filter(
     (file) => file.isFile() && file.name === "state.json"
   );
   let restarted = false;
   for (const item of states) {
-    const path = join5(item.parentPath, item.name);
-    const state = JSON.parse(await readFile3(path, "utf8"));
-    const behind = await stat4(state.event.transcriptPath).then(
+    const path = join6(item.parentPath, item.name);
+    const state = JSON.parse(await readFile4(path, "utf8"));
+    const event = await refreshEvent(state.event);
+    const behind = event.source === "opencode" || await stat4(event.transcriptPath).then(
       (info) => info.size > state.offset || info.ino !== state.inode,
       () => false
     );
-    if (state.paused || behind) {
+    if (state.paused || behind || event.title !== state.event.title) {
       try {
-        restarted = (await capture(state.event, config)).chunks > 0 || restarted;
+        restarted = (await capture(event, config)).chunks > 0 || restarted;
       } catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
           await atomic(path, { ...state, gap: true });
         else errors.push("recapture failed");
       }
     }
-    for (const child of await children(state.event)) {
+    for (const child of await children(event)) {
       if (!await outstanding(child, config)) continue;
       try {
         restarted = (await capture(child, config)).chunks > 0 || restarted;
@@ -8019,7 +8259,7 @@ async function drain(config, options2 = {}, resumed = false) {
   }
   return {
     sent,
-    pending: (await readdir4(root, { recursive: true })).filter(
+    pending: (await readdir4(root2, { recursive: true })).filter(
       (name) => name.endsWith(".batch.json")
     ).length,
     errors
@@ -8029,16 +8269,16 @@ async function drain(config, options2 = {}, resumed = false) {
 // src/commands/sync.ts
 var uploaderLock = { stale: 6e4, update: 1e4, retries: 0 };
 async function uploaderRunning(config) {
-  const root = stateRoot(config);
-  await mkdir4(root, { recursive: true, mode: 448 });
-  return import_proper_lockfile3.default.check(root, uploaderLock);
+  const root2 = stateRoot(config);
+  await mkdir4(root2, { recursive: true, mode: 448 });
+  return import_proper_lockfile3.default.check(root2, uploaderLock);
 }
 async function sync(config, options2 = {}) {
-  const root = stateRoot(config);
-  await mkdir4(root, { recursive: true, mode: 448 });
+  const root2 = stateRoot(config);
+  await mkdir4(root2, { recursive: true, mode: 448 });
   let release;
   try {
-    release = await import_proper_lockfile3.default.lock(root, uploaderLock);
+    release = await import_proper_lockfile3.default.lock(root2, uploaderLock);
   } catch {
     return { sent: 0, pending: 0, errors: [], skipped: true };
   }
@@ -8094,19 +8334,32 @@ async function beam(input, config, options2 = {}) {
 }
 
 // src/commands/doctor.ts
-import { readFile as readFile5, readdir as readdir5, stat as stat6 } from "fs/promises";
-import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { readFile as readFile6, readdir as readdir5, stat as stat6 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
 
 // src/config.ts
-import { readFile as readFile4 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
-var configPath = () => join6(homedir5(), ".config/openhivemind/config.json");
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+var configPath = () => join7(homedir6(), ".config/openhivemind/config.json");
+var NOT_CONFIGURED = "No hive configured. Connect this machine with the token on stdin: wl-paste | openhivemind setup <url> (pbpaste on macOS).";
 async function loadConfig() {
-  const value = JSON.parse(await readFile4(configPath(), "utf8"));
+  let raw;
+  try {
+    raw = await readFile5(configPath(), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error(NOT_CONFIGURED);
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid configuration at ${configPath()}; run openhivemind setup <url> again`);
+  }
   if (!value || typeof value.server !== "string" || typeof value.token !== "string" || typeof value.org !== "string" || !Array.isArray(value.roots) || !Array.isArray(value.exclude))
-    throw new Error("Invalid configuration; run setup");
+    throw new Error(`Invalid configuration at ${configPath()}; run openhivemind setup <url> again`);
   return value;
 }
 async function saveConfig(config) {
@@ -8115,7 +8368,7 @@ async function saveConfig(config) {
 
 // src/commands/doctor.ts
 async function spoolReport(config) {
-  const root = stateRoot(config);
+  const root2 = stateRoot(config);
   const report = {
     sessions: 0,
     pending: 0,
@@ -8125,15 +8378,15 @@ async function spoolReport(config) {
     sources: [],
     bytes: 0
   };
-  const files = await readdir5(root, { recursive: true, withFileTypes: true }).catch(() => []);
+  const files = await readdir5(root2, { recursive: true, withFileTypes: true }).catch(() => []);
   for (const file of files) {
     if (!file.isFile()) continue;
-    const path = join7(file.parentPath, file.name);
+    const path = join8(file.parentPath, file.name);
     if (file.name.endsWith(".dead")) report.dead++;
     else if (file.name.endsWith(".batch.json")) report.pending++;
     else if (file.name === "state.json") {
       report.sessions++;
-      const state = JSON.parse(await readFile5(path, "utf8"));
+      const state = JSON.parse(await readFile6(path, "utf8"));
       if (!report.sources.includes(state.event.source)) report.sources.push(state.event.source);
       if (state.paused) report.paused.push(state.event.sessionId);
       if (state.gap) report.gap.push(state.event.sessionId);
@@ -8141,14 +8394,14 @@ async function spoolReport(config) {
       if (!report.last || when > report.last) report.last = when;
     }
   }
-  report.bytes = await spoolBytes(root).catch(() => 0);
+  report.bytes = await spoolBytes(root2).catch(() => 0);
   return report;
 }
 async function ignoreProblems() {
   const problems = [];
-  const path = join7(homedir6(), ".config/openhivemind/ignore");
+  const path = join8(homedir7(), ".config/openhivemind/ignore");
   try {
-    ignorePatterns(await readFile5(path, "utf8"));
+    ignorePatterns(await readFile6(path, "utf8"));
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
       problems.push(
@@ -8158,19 +8411,32 @@ async function ignoreProblems() {
   return problems;
 }
 async function pluginInstalled() {
-  const installed = await readFile5(
-    join7(homedir6(), ".claude/plugins/installed_plugins.json"),
+  const installed = await readFile6(
+    join8(homedir7(), ".claude/plugins/installed_plugins.json"),
     "utf8"
   ).catch(() => "{}");
   const value = JSON.parse(installed);
   return Object.keys(value.plugins ?? {}).some((name) => name.startsWith("openhivemind@"));
 }
 async function codexPluginEnabled() {
-  const home = process.env["CODEX_HOME"] || join7(homedir6(), ".codex");
-  const config = await readFile5(join7(home, "config.toml"), "utf8").catch(() => "");
+  const home = process.env["CODEX_HOME"] || join8(homedir7(), ".codex");
+  const config = await readFile6(join8(home, "config.toml"), "utf8").catch(() => "");
   const section = config.split(/^\[/m).find((part) => part.startsWith('plugins."openhivemind@'));
   return Boolean(section) && !/^enabled\s*=\s*false/m.test(section);
 }
+async function opencodePluginInstalled() {
+  const home = join8(process.env["XDG_CONFIG_HOME"] || join8(homedir7(), ".config"), "opencode");
+  for (const folder of ["plugin", "plugins"])
+    if ((await readdir5(join8(home, folder)).catch(() => [])).some(
+      (name) => name.startsWith("openhivemind.")
+    ))
+      return true;
+  for (const name of ["opencode.json", "opencode.jsonc", "config.json"]) {
+    const config = await readFile6(join8(home, name), "utf8").catch(() => "");
+    if (/"plugin"\s*:\s*\[[^\]]*openhivemind/.test(config)) return true;
+  }
+  return false;
+}
 async function doctor() {
   const lines = [];
   let ok2 = true;
@@ -8184,8 +8450,8 @@ async function doctor() {
     const mode = ((await stat6(configPath())).mode & 511).toString(8);
     lines.push(`Configuration: ${configPath()} (mode ${mode})`);
     if (mode !== "600") fail("  the configuration file should be mode 600");
-  } catch {
-    fail(`Configuration: missing or invalid at ${configPath()}; run openhivemind setup <url>`);
+  } catch (error) {
+    fail(`Configuration: ${error instanceof Error ? error.message : `invalid at ${configPath()}`}`);
     return { lines, ok: ok2 };
   }
   try {
@@ -8217,6 +8483,9 @@ async function doctor() {
   lines.push(
     `Codex CLI plugin: ${!await codexPluginEnabled() ? "not installed (run codex plugin marketplace add openhivemind/openhivemind, then codex plugin add openhivemind@openhivemind)" : spool.sources.includes("codex") ? "installed, bundled hooks fire" : "installed, but no turn has been captured yet; its hooks run only once trusted from the Codex TUI"}`
   );
+  lines.push(
+    `opencode plugin: ${!await opencodePluginInstalled() ? "not installed (link client/plugins/opencode/openhivemind.js into ~/.config/opencode/plugin/)" : spool.sources.includes("opencode") ? "installed, session.idle fires" : "installed, but no session has been captured yet"}`
+  );
   for (const problem of await ignoreProblems()) fail(problem);
   lines.push(
     `Capture: ${spool.sessions} session(s), last ${spool.last ?? "never"}; spool ${spool.bytes} bytes in ${spool.pending} chunk file(s)`
@@ -8228,12 +8497,12 @@ async function doctor() {
   if (spool.gap.length)
     fail(`  permanent gap, transcript gone: ${spool.gap.slice(0, 5).join(", ")}`);
   if (spool.dead) fail(`  ${spool.dead} chunk(s) rejected permanently and set aside`);
-  const upgrade = await readFile5(upgradePath(config), "utf8").catch(() => "");
+  const upgrade = await readFile6(upgradePath(config), "utf8").catch(() => "");
   if (upgrade) {
     const value = JSON.parse(upgrade);
     fail(`  upgrade client: uploads stopped at ${value.at} (${value.detail})`);
   }
-  lines.push(`Log: ${join7(stateHome(), "hook.log")}`);
+  lines.push(`Log: ${join8(stateHome(), "hook.log")}`);
   return { lines, ok: ok2 };
 }
 
@@ -8411,14 +8680,19 @@ function truncate(text, max = 200) {
   const flat = text.replace(/\s+/g, " ").trim();
   return flat.length > max ? `${flat.slice(0, max)}\u2026 (truncated)` : flat;
 }
+function describeRequestError(server, error, fallback) {
+  if (error instanceof ApiError) return error.message;
+  const detail = error instanceof Error ? error.message : fallback;
+  return `Hive ${server} unreachable (${detail}); run openhivemind doctor`;
+}
 
 // src/commands/search.ts
 var SEARCH_LIMIT_CAP = 100;
 var DEFAULT_LIMIT = 20;
 var MAX_SNIPPETS_PER_SESSION = 3;
 async function search(config, flags) {
-  const query = flags.rest.join(" ").trim();
-  if (!query)
+  const query2 = flags.rest.join(" ").trim();
+  if (!query2)
     return {
       lines: [
         "Usage: openhivemind search <query...> [--remote --author --branch --since --until --kind --mine --limit --context --regex --case-sensitive --format plain|md]"
@@ -8434,7 +8708,7 @@ async function search(config, flags) {
   try {
     response = await createApi(config.server, config.token)(routes.search, {
       body: {
-        query,
+        query: query2,
         regex: flags.has("regex") || void 0,
         caseSensitive: flags.has("case-sensitive") || void 0,
         context: context.value,
@@ -8443,7 +8717,7 @@ async function search(config, flags) {
     });
   } catch (error) {
     return {
-      lines: [error instanceof Error ? error.message : "Search request failed"],
+      lines: [describeRequestError(config.server, error, "Search request failed")],
       exitCode: 2
     };
   }
@@ -8512,13 +8786,13 @@ async function sessions(config, flags) {
   }
   const parsed = filters(flags);
   if (parsed.error) return { lines: [parsed.error], exitCode: 2 };
-  const query = { ...parsed.value, since };
+  const query2 = { ...parsed.value, since };
   let response;
   try {
-    response = await createApi(config.server, config.token)(routes.sessions, { query });
+    response = await createApi(config.server, config.token)(routes.sessions, { query: query2 });
   } catch (error) {
     return {
-      lines: [error instanceof Error ? error.message : "Sessions request failed"],
+      lines: [describeRequestError(config.server, error, "Sessions request failed")],
       exitCode: 2
     };
   }
@@ -8597,7 +8871,10 @@ async function show(config, flags) {
       query: matcher ? { last: MATCH_SCAN_WINDOW, maxChars: MATCH_SCAN_MAX_CHARS } : { last }
     });
   } catch (error) {
-    return { lines: [error instanceof Error ? error.message : "Show request failed"], exitCode: 2 };
+    return {
+      lines: [describeRequestError(config.server, error, "Show request failed")],
+      exitCode: 2
+    };
   }
   let messages = response.messages;
   if (matcher) {
@@ -8636,7 +8913,7 @@ async function main() {
     return;
   }
   if (command === "--version") {
-    console.log("0.1.0");
+    console.log("0.2.0");
     return;
   }
   if (command === "skills") {
@@ -8644,7 +8921,7 @@ async function main() {
     const names = (await readdir6(folder)).sort();
     if (args[0]) {
       if (!names.includes(args[0])) throw new Error("Unknown skill");
-      console.log(await readFile6(resolve3(folder, args[0], "SKILL.md"), "utf8"));
+      console.log(await readFile7(resolve3(folder, args[0], "SKILL.md"), "utf8"));
     } else console.log(names.join("\n"));
     return;
   }
@@ -8656,8 +8933,13 @@ async function main() {
         "Usage: openhivemind setup <url> [--token <pat>] [--root <dir>] [--exclude <dir>] [--read-only]"
       );
     const given = flags.get("token");
+    if (!given && process.stdin.isTTY)
+      throw new Error(
+        `Pipe the token in: wl-paste | openhivemind ${command} ${command === "setup" ? "<url>" : "--server <url>"} (pbpaste on macOS), or pass --token <pat>`
+      );
     const token = given && given !== "-" ? given : (await readStdin()).trim();
-    if (!token) throw new Error("A personal access token is required: --token <pat> or on stdin");
+    if (!token)
+      throw new Error("A personal access token is required on stdin or via --token <pat>");
     const config = await login({
       server,
       token,