wherdr 1.3.1 → 1.3.3

package/.output/server/chunks/_/projectBoard.mjs

@@ -1,6 +1,73 @@
 import { execFile } from 'node:child_process';
 import path from 'node:path';
-import { aF as currentMachineSlots, aG as paneBaseMachine, H as HerdrError, m as machineFor, aD as HERDR_CHILD_ENV, aE as HERDR_BIN, aB as herdrOn, aH as projectOf, aI as isProjectThread } from '../nitro/nitro.mjs';
+import { u as currentMachineSlots, q as paneBaseMachine, H as HerdrError, v as machineFor, x as herdrOn, y as HERDR_CHILD_ENV, z as HERDR_BIN, n as projectOf, B as isProjectThread } from '../nitro/nitro.mjs';
+
+const ESCAPES = { b: "\b", t: "	", n: "\n", f: "\f", r: "\r", e: "\x1B", '"': '"', "\\": "\\" };
+function unescapeBasic(s) {
+  return s.replace(/\\[ \t]*\n\s*/g, "").replace(/\\(u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[\s\S])/g, (all, x) => {
+    var _a;
+    if (x.length > 1) {
+      const code = Number.parseInt(x.slice(1), 16);
+      return code <= 1114111 ? String.fromCodePoint(code) : all;
+    }
+    return (_a = ESCAPES[x]) != null ? _a : all;
+  });
+}
+function closing(text, from, quote, basic) {
+  for (let i = from; i < text.length; i++) {
+    if (basic && text[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (quote.length === 1 && text[i] === "\n") return -1;
+    if (text.startsWith(quote, i)) {
+      if (quote.length === 3) while (text[i + 3] === quote[0]) i++;
+      return i;
+    }
+  }
+  return -1;
+}
+const HEADER = /^[ \t]*\[\[?[ \t]*([A-Za-z0-9_.-]+)[ \t]*\]\]?[ \t]*(?:#.*)?$/;
+const KEY = /^[ \t]*([A-Za-z0-9_-]+)[ \t]*=[ \t]*/;
+function tomlTables(input) {
+  const text = String(input || "").replace(/\r\n?/g, "\n");
+  let table = { name: "", strings: {}, bare: {} };
+  const tables = [table];
+  let at = 0;
+  while (at < text.length) {
+    const eol = text.indexOf("\n", at);
+    const line = text.slice(at, eol < 0 ? text.length : eol);
+    let next = eol < 0 ? text.length : eol + 1;
+    const header = HEADER.exec(line);
+    const m = header ? null : KEY.exec(line);
+    if (header) {
+      table = { name: header[1], strings: {}, bare: {} };
+      tables.push(table);
+    } else if (m) {
+      const start = at + m[0].length;
+      const quote = ['"""', "'''", '"', "'"].find((q) => text.startsWith(q, start));
+      if (quote) {
+        const basic = quote[0] === '"';
+        const end = closing(text, start + quote.length, quote, basic);
+        if (end >= 0) {
+          let raw = text.slice(start + quote.length, end);
+          if (quote.length === 3 && raw.startsWith("\n")) raw = raw.slice(1);
+          table.strings[m[1]] = basic ? unescapeBasic(raw) : raw;
+          const after = text.indexOf("\n", end + quote.length);
+          next = after < 0 ? text.length : after + 1;
+        }
+      } else {
+        const value = line.slice(m[0].length).split("#")[0].trim();
+        if (value) table.bare[m[1]] = value;
+      }
+    }
+    at = next;
+  }
+  return tables;
+}
+function tomlStrings(front) {
+  return Object.assign({}, ...tomlTables(front).map((t) => t.strings));
+}
 
 const fold = (s) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
 const KINDS = [
@@ -21,8 +88,12 @@ function listKind(title) {
 }
 const THREAD_ID = /\bt-\d{4,}\b/i;
 const TASK_LINE = /^[-*+]\s+(?:\[([ xX])\](?:\s+|$))?(.*)$/;
-const OWNER = /\s*\(([^()]{1,48})\)\s*$/;
-const REFS = /\s*\[\s*t-\d{4,}(?:\s*[,;\s]\s*t-\d{4,})*\s*\]/gi;
+const OWNER = /\(([^()]{1,48})\)\s*$/;
+const REFS = /\s*\[\s*t-\d{4,}(?:(?:\s+|\s*[,;]\s*)t-\d{4,})*\s*\]/gi;
+const CAUSE = /^\s*(?:bloqu[eé]e? par|blocked by)\s*:\s*(.+)$/i;
+const ANSI = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+const CONTROL = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069]/g;
+const MAX_LINE = 2e3;
 const BADGE_COLORS = ["red", "orange", "amber", "green", "teal", "blue", "violet", "pink", "gray"];
 const BADGE = /\[b:\s*([#\w-]*)\s*\((.*?)\)\](?:\(\s*((?:[^\s()]|\([^\s()]*\))*)\s*\))?/gi;
 function badgeColor(raw) {
@@ -47,32 +118,36 @@ function badgeTarget(raw) {
 }
 function takeBadges(input) {
   const badges = [];
-  const text = input.replace(BADGE, (all, color, label, target) => {
+  const text = input.replace(BADGE, (all, color, label, target2) => {
     const t = label.replace(/\s+/g, " ").trim();
     if (!t) return all;
-    badges.push({ text: t, color: badgeColor(color), ...badgeTarget(target) || {} });
+    badges.push({ text: t, color: badgeColor(color), ...badgeTarget(target2) || {} });
     return " ";
   });
   return badges.length ? { text: text.replace(/\s{2,}/g, " ").trim(), badges } : { text: input, badges };
 }
 function parseTaskLine(line, kind = null) {
   var _a;
-  const m = TASK_LINE.exec(line.trim());
+  if (line.length > MAX_LINE) return null;
+  const m = TASK_LINE.exec(line.replace(ANSI, "").replace(/\t/g, " ").replace(CONTROL, "").trim());
   if (!m) return null;
   const free = takeBadges(m[2].trim());
   let text = free.text.replace(REFS, "").trim();
   let owner = null;
   const o = OWNER.exec(text);
-  if (o && o.index > 0 && !(text[o.index] === "(" && text[o.index - 1] === "]")) {
+  if (o && o.index > 0 && text[o.index - 1] !== "]") {
     owner = o[1].trim();
     text = text.slice(0, o.index).trim();
   }
   let reason;
   if (kind === "blocked") {
-    const cause = /\s+—\s*(?:bloqu[eé]e? par|blocked by)\s*:\s*(.+)$/i.exec(text);
-    if ((_a = cause == null ? void 0 : cause[1]) == null ? void 0 : _a.trim()) {
+    for (let at = text.indexOf("\u2014"); at > 0; at = text.indexOf("\u2014", at + 1)) {
+      if (!/\s/.test(text[at - 1])) continue;
+      const cause = CAUSE.exec(text.slice(at + 1));
+      if (!((_a = cause == null ? void 0 : cause[1]) == null ? void 0 : _a.trim())) continue;
       reason = cause[1].trim();
-      text = text.slice(0, cause.index).trim();
+      text = text.slice(0, at).trim();
+      break;
     }
   }
   if (!text) text = free.badges.map((b) => b.text).join(" \xB7 ");
@@ -80,19 +155,27 @@ function parseTaskLine(line, kind = null) {
   const ref = owner && THREAD_ID.exec(owner);
   return { text, done: m[1] === "x" || m[1] === "X", owner, thread: ref ? ref[0].toLowerCase() : null, ...reason ? { reason } : {}, ...free.badges.length ? { badges: free.badges } : {} };
 }
+function headingTitle(raw) {
+  var _a;
+  if (!raw.startsWith("##") || !/\s/.test((_a = raw[2]) != null ? _a : "")) return null;
+  const body = raw.slice(2).trim();
+  if (!body) return null;
+  return body.replace(/#+$/, "").trim() || body[0];
+}
 function parseTasks(md) {
   const lists = [];
   let cur = null;
   let fence = false;
   for (const raw of String(md || "").replace(/\r\n?/g, "\n").split("\n")) {
+    if (raw.length > MAX_LINE) continue;
     if (/^\s*(```|~~~)/.test(raw)) {
       fence = !fence;
       continue;
     }
     if (fence) continue;
-    const h = /^##\s+(.+?)\s*#*\s*$/.exec(raw);
-    if (h) {
-      cur = { title: h[1], kind: listKind(h[1]), tasks: [] };
+    const title = headingTitle(raw);
+    if (title) {
+      cur = { title, kind: listKind(title), tasks: [] };
       lists.push(cur);
       continue;
     }
@@ -128,6 +211,8 @@ function normalizeThreads(raw) {
       created: str(r.created),
       agentName: str(r.agent_name) || null,
       machine: str(r.machine),
+      profile: str(r.profile) || str(r.agent),
+      stateLine: str(r.state_line).trim(),
       activity: str(r.activity).trim(),
       percent: typeof r.percent === "number" && Number.isFinite(r.percent) ? Math.max(0, Math.min(100, Math.round(r.percent))) : null,
       pr: /^https:\/\//.test(str(r.pr)) ? str(r.pr) : "",
@@ -156,10 +241,9 @@ function splitThreads(list) {
 function maxParallelThreads(projectMd) {
   const m = /^\+\+\+\r?\n([\s\S]*?)\r?\n\+\+\+/.exec(String(projectMd || ""));
   if (!m) return null;
-  const top = m[1].split(/^\s*\[/m)[0];
-  const v = /^\s*max_parallel_threads\s*=\s*(\d+)\s*(?:#.*)?$/m.exec(top);
-  if (!v) return 10;
-  const n = Number(v[1]);
+  const v = tomlTables(m[1])[0].bare.max_parallel_threads;
+  if (v === void 0 || !/^\d+$/.test(v)) return 10;
+  const n = Number(v);
   return n >= 1 ? n : null;
 }
 
@@ -210,27 +294,34 @@ async function version(t) {
   const v = `${tasks ? `${tasks.size}.${tasks.mtimeMs}` : "-"}|${threads ? threads.mtimeMs : "-"}|${project ? project.mtimeMs : "-"}`;
   return { v, tasks: (tasks == null ? void 0 : tasks.isFile) ? tasks : null, project: (project == null ? void 0 : project.isFile) ? project : null };
 }
-function threadList(t) {
-  const root = path.posix.dirname(t.dir);
+const REMOTE_RUN = 'export HERDR_BIN_PATH="$1" HERDR_SESSION="$2"; bin="$3"; shift 3; exec "$bin" "$@"';
+function runProjectCommand(t, args, timeoutMs = 15e3, maxBytes = 1024 * 1024) {
   const session = t.m.session && t.m.session !== "default" ? t.m.session : "";
   const remote = t.m.exec;
   if (remote) {
     const herdrBin = t.m.bin || "herdr";
-    return remote('HERDR_BIN_PATH="$1" HERDR_SESSION="$2" exec "$3" --root "$4" thread list "$5" --json', [herdrBin, session, t.bin, root, t.slug], { timeoutMs: 15e3 }).then((r) => {
-      if (r.code !== 0) throw new Error(r.stderr.trim().split("\n").pop() || `code ${r.code}`);
-      if (r.stdout.length > THREADS_BYTES) throw new Error("thread list too long");
-      return r.stdout.toString("utf8");
+    return remote(REMOTE_RUN, [herdrBin, session, t.bin, ...args], { timeoutMs }).then((r) => {
+      var _a;
+      return r.stdout.length > maxBytes ? { code: 1, stdout: "", stderr: "output too long" } : { code: (_a = r.code) != null ? _a : 1, stdout: r.stdout.toString("utf8"), stderr: r.stderr };
     });
   }
   const env = { ...HERDR_CHILD_ENV, HERDR_BIN_PATH: HERDR_BIN };
   if (session) env.HERDR_SESSION = session;
-  return new Promise((resolve, reject) => {
-    execFile(t.bin, ["--root", root, "thread", "list", t.slug, "--json"], { env, timeout: 15e3, maxBuffer: THREADS_BYTES }, (err, out, stderr) => {
-      if (err) reject(new Error(String(stderr || err.message).trim().split("\n").pop()));
-      else resolve(String(out));
-    });
+  return new Promise((resolve) => {
+    execFile(t.bin, args, { env, timeout: timeoutMs, maxBuffer: maxBytes }, (err, out, stderr) => resolve({
+      code: err ? typeof err.code === "number" ? err.code : 1 : 0,
+      stdout: String(out),
+      stderr: String(stderr || (err ? err.message : ""))
+    }));
   });
 }
+const projectsRoot = (t) => path.posix.dirname(t.dir);
+async function threadList(t) {
+  const r = await runProjectCommand(t, ["--root", projectsRoot(t), "thread", "list", t.slug, "--json"], 15e3, THREADS_BYTES);
+  if (r.code !== 0) throw new Error(r.stderr.trim().split("\n").pop() || `code ${r.code}`);
+  if (r.stdout.length > THREADS_BYTES) throw new Error("thread list too long");
+  return r.stdout;
+}
 const lastThreads = /* @__PURE__ */ new Map();
 async function readProjectBoard(pane, since) {
   const t = await target(pane);
@@ -271,5 +362,5 @@ async function readThreadReport(pane, id) {
   return { id, text, truncated: st.size > REPORT_BYTES };
 }
 
-export { readThreadReport as a, binaryOn as b, readProjectBoard as r };
+export { target as a, binaryOn as b, runProjectCommand as c, tomlTables as d, readThreadReport as e, normalizeThreads as n, projectsRoot as p, readProjectBoard as r, tomlStrings as t };
 //# sourceMappingURL=projectBoard.mjs.map

package/.output/server/chunks/_/projectDocs.mjs

@@ -0,0 +1,106 @@
+import { d as tomlTables, a as target } from './projectBoard.mjs';
+import { H as HerdrError } from '../nitro/nitro.mjs';
+
+const front = (md) => {
+  var _a, _b;
+  return (_b = (_a = /^\+\+\+\r?\n([\s\S]*?)\r?\n\+\+\+/.exec(String(md || ""))) == null ? void 0 : _a[1]) != null ? _b : null;
+};
+const cut = (s, max) => (s || "").replace(/\s+/g, " ").trim().slice(0, max);
+function parseProjectSettings(projectMd) {
+  var _a, _b;
+  const f = front(projectMd);
+  if (f === null) return null;
+  const tables = tomlTables(f);
+  const strings = tables[0].strings;
+  const raw = (key) => tables[0].bare[key];
+  const defaults = [];
+  const pick = (key, value, fallback) => {
+    if (value !== void 0) return value;
+    defaults.push(key);
+    return fallback;
+  };
+  const int = (key) => {
+    const v = raw(key);
+    return v !== void 0 && /^\d{1,6}$/.test(v) ? Number(v) : void 0;
+  };
+  const bool = (key) => {
+    const v = raw(key);
+    return v === "true" ? true : v === "false" ? false : void 0;
+  };
+  const settings = {
+    name: cut(pick("name", strings.name, ""), 200),
+    goal: cut(pick("goal", strings.goal, ""), 2e3),
+    // `*_agent`: the keys' names before profiles.
+    coordinatorProfile: cut(pick("coordinatorProfile", (_a = strings.coordinator_profile) != null ? _a : strings.coordinator_agent, "claude"), 60),
+    threadProfile: cut(pick("threadProfile", (_b = strings.thread_profile) != null ? _b : strings.thread_agent, "claude"), 60),
+    maxParallelThreads: pick("maxParallelThreads", int("max_parallel_threads"), 10),
+    autoResolveDays: pick("autoResolveDays", int("auto_resolve_days"), 7),
+    nudge: pick("nudge", bool("nudge"), true),
+    mute: pick("mute", bool("mute"), false),
+    repos: tables.filter((t) => t.name === "repos").slice(0, 50).map((t) => ({ path: cut(t.strings.path, 1024), machine: cut(t.strings.machine, 120) })).filter((r) => r.path),
+    defaults
+  };
+  return settings;
+}
+const MEMORY_INDEX = "MEMORY.md";
+const MEMORY_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}\.md$/;
+const memoryFileOk = (name) => typeof name === "string" && MEMORY_FILE_RE.test(name) && !name.includes("..");
+function parseMemoryIndex(indexMd) {
+  const out = [];
+  for (const line of String(indexMd || "").replace(/\r\n?/g, "\n").split("\n")) {
+    const m = /^\s*[-*+]\s+\[([^\]]+)\]\((?:\.\/)?memory\/([^)\s]+)\)\s*(?:[:—–-]\s*)?(.*)$/.exec(line);
+    if (!m || !memoryFileOk(m[2]) || out.some((x) => x.name === m[2])) continue;
+    out.push({ name: m[2], title: cut(m[1], 160), hook: cut(m[3], 400) });
+  }
+  return out;
+}
+function memoryFiles(indexMd, names) {
+  const files = names.filter(memoryFileOk);
+  const listed = parseMemoryIndex(indexMd || "");
+  const out = [];
+  if (indexMd !== null) out.push({ name: MEMORY_INDEX, title: MEMORY_INDEX, hook: "", index: true });
+  for (const l of listed) out.push(files.includes(l.name) ? l : { ...l, missing: true });
+  for (const name of files.filter((n) => !listed.some((l) => l.name === n)).sort()) out.push({ name, title: name, hook: "" });
+  return out;
+}
+
+const PROJECT_HEAD_BYTES = 32 * 1024;
+const INDEX_BYTES = 128 * 1024;
+const MEMORY_BYTES = 256 * 1024;
+const MEMORY_FILES_MAX = 300;
+async function head(t, file, max) {
+  const st = await t.m.fs.stat(file).catch(() => null);
+  if (!st || !st.isFile) return null;
+  const text = (await t.m.fs.read(file, 0, Math.min(st.size, max))).toString("utf8");
+  return { text, truncated: st.size > max };
+}
+async function settingsOn(t) {
+  const file = await head(t, `${t.dir}/PROJECT.md`, PROJECT_HEAD_BYTES);
+  const settings = file && parseProjectSettings(file.text);
+  if (!settings) throw new HerdrError("no_settings", "project settings not found");
+  return { settings };
+}
+async function memoryOn(t) {
+  const [index, names] = await Promise.all([
+    head(t, `${t.dir}/${MEMORY_INDEX}`, INDEX_BYTES),
+    t.m.fs.readdir(`${t.dir}/memory`).catch(() => [])
+  ]);
+  return { files: memoryFiles(index ? index.text : null, names.slice(0, MEMORY_FILES_MAX * 4)).slice(0, MEMORY_FILES_MAX) };
+}
+async function memoryFileOn(t, name) {
+  if (name !== MEMORY_INDEX && !memoryFileOk(name)) throw new HerdrError("bad_memory", "invalid memory file");
+  const file = await head(t, name === MEMORY_INDEX ? `${t.dir}/${MEMORY_INDEX}` : `${t.dir}/memory/${name}`, MEMORY_BYTES);
+  if (!file) throw new HerdrError("no_memory", "memory file not found");
+  return { name, ...file };
+}
+async function need(pane) {
+  const t = await target(pane);
+  if (!t) throw new HerdrError("no_project", "project not found");
+  return t;
+}
+const readProjectSettings = async (pane) => settingsOn(await need(pane));
+const readProjectMemory = async (pane) => memoryOn(await need(pane));
+const readMemoryFile = async (pane, name) => memoryFileOn(await need(pane), name);
+
+export { readMemoryFile as a, readProjectSettings as b, readProjectMemory as r };
+//# sourceMappingURL=projectDocs.mjs.map

package/.output/server/chunks/_/projectInbox.mjs

@@ -0,0 +1,135 @@
+import { p as projectSlugOk, l as lastLine } from './projectThreads.mjs';
+import { t as tomlStrings, a as target, p as projectsRoot, c as runProjectCommand } from './projectBoard.mjs';
+import { H as HerdrError } from '../nitro/nitro.mjs';
+import { s as stripAnsi } from './pluginPolicy.mjs';
+
+const INBOX_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+const inboxIdOk = (id) => typeof id === "string" && INBOX_ID_RE.test(id) && !id.includes("..");
+const INBOX_BODY_MAX = 2e3;
+function parseInboxItem(fileText) {
+  const text = String(fileText || "").replace(/\r\n?/g, "\n");
+  if (!text.startsWith("+++\n")) return null;
+  const rest = text.slice(4);
+  const cut = rest.indexOf("\n+++\n");
+  const front = cut >= 0 ? rest.slice(0, cut) : rest.endsWith("\n+++") ? rest.slice(0, -4) : null;
+  if (front === null) return null;
+  const f = tomlStrings(front);
+  if (!inboxIdOk(f.id)) return null;
+  const oneLine = (s, max) => (s || "").replace(/\s+/g, " ").trim().slice(0, max);
+  const body = cut >= 0 ? rest.slice(cut + 5).replace(/^\n+|\n+$/g, "") : "";
+  return {
+    id: f.id,
+    kind: oneLine(f.kind, 40),
+    subject: oneLine(f.subject, 120),
+    event: oneLine(f.event, 120),
+    summary: oneLine(f.summary, 1e3),
+    created: oneLine(f.created, 40),
+    body: body.length > INBOX_BODY_MAX ? `${body.slice(0, INBOX_BODY_MAX)}\u2026` : body
+  };
+}
+const sortInbox = (items) => [...items].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+function inboxDoneArgs(root, slug, ids) {
+  if (!root.startsWith("/")) throw new Error("invalid projects root");
+  if (!projectSlugOk(slug)) throw new Error("invalid project");
+  if (!ids.length || ids.length > 50 || !ids.every(inboxIdOk)) throw new Error("invalid inbox item");
+  return ["--root", root, "inbox", "done", slug, ...ids];
+}
+function routineListArgs(root, slug) {
+  if (!root.startsWith("/")) throw new Error("invalid projects root");
+  if (!projectSlugOk(slug)) throw new Error("invalid project");
+  return ["--root", root, "routine", "list", slug];
+}
+function parseRoutineList(output) {
+  const routines = [];
+  const broken = [];
+  for (const line of String(output || "").replace(/\r\n?/g, "\n").split("\n")) {
+    const cols = line.split("	");
+    if (cols.length === 2 && cols[1].startsWith("config-error:")) {
+      broken.push({ file: cols[0].trim().slice(0, 120), error: cols[1].slice("config-error:".length).trim().slice(0, 300) });
+      continue;
+    }
+    if (cols.length !== 5 || !cols[0].trim() || cols[2] !== "enabled" && cols[2] !== "disabled") continue;
+    routines.push({
+      name: cols[0].trim().slice(0, 120),
+      schedule: cols[1].trim().slice(0, 120),
+      enabled: cols[2] === "enabled",
+      kind: cols[3].trim().slice(0, 160),
+      when: cols[4].split(" \xB7 ").map((s) => s.trim().slice(0, 160)).filter(Boolean)
+    });
+  }
+  return { routines, broken };
+}
+
+const INBOX_MAX = 100;
+const ITEM_BYTES = 8 * 1024;
+const READS_AT_ONCE = 8;
+const seen = /* @__PURE__ */ new Map();
+const SEEN_MAX = 2e3;
+async function inboxOn(t) {
+  var _a;
+  const dir = `${t.dir}/inbox`;
+  const names = await t.m.fs.readdir(dir).catch(() => []);
+  const ids = names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -3)).filter(inboxIdOk).sort();
+  const items = [];
+  const wanted = ids.slice(0, INBOX_MAX);
+  const stats = await t.m.fs.statMany(wanted.map((id) => `${dir}/${id}.md`));
+  const base = `${(_a = t.m.key) != null ? _a : ""}|${dir}/`;
+  const todo = [];
+  const found = /* @__PURE__ */ new Map();
+  wanted.forEach((id, i) => {
+    const st = stats[i];
+    if (!st || !st.isFile || st.size <= 0) return;
+    const known = seen.get(base + id);
+    if (known && known.size === st.size && known.mtimeMs === st.mtimeMs) {
+      if (known.item) found.set(id, known.item);
+    } else todo.push({ id, size: st.size, mtimeMs: st.mtimeMs });
+  });
+  for (let i = 0; i < todo.length; i += READS_AT_ONCE) {
+    await Promise.all(todo.slice(i, i + READS_AT_ONCE).map(async ({ id, size, mtimeMs }) => {
+      const text = await t.m.fs.read(`${dir}/${id}.md`, 0, Math.min(size, ITEM_BYTES)).then((b) => b.toString("utf8")).catch(() => null);
+      if (text === null) return;
+      const parsed = parseInboxItem(text.length >= ITEM_BYTES && !text.includes("\n+++\n") ? "" : text);
+      const item = parsed && parsed.id === id ? parsed : null;
+      seen.set(base + id, { size, mtimeMs, item });
+      if (item) found.set(id, item);
+    }));
+  }
+  for (const item of found.values()) items.push(item);
+  const here = new Set(ids);
+  for (const key of seen.keys()) if (key.startsWith(base) && !here.has(key.slice(base.length))) seen.delete(key);
+  while (seen.size > SEEN_MAX) seen.delete(seen.keys().next().value);
+  return { items: sortInbox(items), total: items.length + (ids.length - wanted.length) };
+}
+async function inboxDoneOn(t, id) {
+  let args;
+  try {
+    args = inboxDoneArgs(projectsRoot(t), t.slug, [id]);
+  } catch (e) {
+    throw new HerdrError("bad_item", e.message);
+  }
+  const r = await runProjectCommand(t, args, 15e3);
+  if (r.code !== 0) throw new HerdrError("inbox_failed", lastLine(stripAnsi(r.stderr || r.stdout)) || `code ${r.code}`);
+  return { ok: true };
+}
+async function routinesOn(t) {
+  let args;
+  try {
+    args = routineListArgs(projectsRoot(t), t.slug);
+  } catch (e) {
+    throw new HerdrError("bad_project", e.message);
+  }
+  const r = await runProjectCommand(t, args, 15e3);
+  if (r.code !== 0) throw new HerdrError("routines_failed", lastLine(stripAnsi(r.stderr || r.stdout)) || `code ${r.code}`);
+  return parseRoutineList(stripAnsi(r.stdout));
+}
+async function need(pane) {
+  const t = await target(pane);
+  if (!t) throw new HerdrError("no_project", "project not found");
+  return t;
+}
+const readInbox = async (pane) => inboxOn(await need(pane));
+const markInboxDone = async (pane, id) => inboxDoneOn(await need(pane), id);
+const readRoutines = async (pane) => routinesOn(await need(pane));
+
+export { readRoutines as a, markInboxDone as m, readInbox as r };
+//# sourceMappingURL=projectInbox.mjs.map

package/.output/server/chunks/_/projectThreads.mjs

@@ -0,0 +1,46 @@
+import { n as normalizeThreads } from './projectBoard.mjs';
+
+const THREAD_ID_RE = /^t-\d{4,}$/;
+const PROJECT_SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$/;
+const projectSlugOk = (slug) => PROJECT_SLUG_RE.test(slug) && !slug.includes("..");
+const THREAD_ACTIONS = ["stop", "restart", "ack", "resolve"];
+const isThreadAction = (v) => THREAD_ACTIONS.includes(v);
+const THREAD_TIMEOUT_MS = { show: 15e3, stop: 2e4, ack: 15e3, restart: 9e4, resolve: 18e4 };
+function threadCommandArgs(command, root, slug, id) {
+  if (!root.startsWith("/")) throw new Error("invalid projects root");
+  if (!projectSlugOk(slug)) throw new Error("invalid project");
+  if (!THREAD_ID_RE.test(id)) throw new Error("invalid thread");
+  if (command !== "show" && !isThreadAction(command)) throw new Error("invalid action");
+  return ["--root", root, "thread", command, slug, id, ...command === "show" ? ["--json"] : []];
+}
+const str = (v) => typeof v === "string" ? v : "";
+const NEXT_MAX = 20;
+function normalizeThreadDetail(raw) {
+  const base = normalizeThreads([raw])[0];
+  if (!base) return null;
+  const r = raw;
+  const hash = str(r.report_hash);
+  return {
+    ...base,
+    note: str(r.note).trim(),
+    error: str(r.error).trim().slice(0, 600),
+    kind: str(r.kind),
+    agent: str(r.agent),
+    branch: str(r.branch),
+    base: str(r.base),
+    prState: str(r.pr_state),
+    prReview: str(r.pr_review),
+    next: (Array.isArray(r.next) ? r.next : []).filter((x) => typeof x === "string" && Boolean(x.trim())).slice(0, NEXT_MAX).map((x) => x.trim().slice(0, 300)),
+    acked: Boolean(hash) && str(r.acked_report_hash) === hash,
+    hasPane: Boolean(str(r.pane_id)),
+    keptWorktree: r.kept_worktree === true,
+    resolvedReason: str(r.resolved_reason)
+  };
+}
+function lastLine(text) {
+  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  return (lines[lines.length - 1] || "").replace(/^error:\s*/i, "").slice(0, 400);
+}
+
+export { THREAD_ID_RE as T, THREAD_TIMEOUT_MS as a, isThreadAction as i, lastLine as l, normalizeThreadDetail as n, projectSlugOk as p, threadCommandArgs as t };
+//# sourceMappingURL=projectThreads.mjs.map

package/.output/server/chunks/_/projectThreads2.mjs

@@ -0,0 +1,61 @@
+import { i as isThreadAction, T as THREAD_ID_RE, l as lastLine, n as normalizeThreadDetail, a as THREAD_TIMEOUT_MS, t as threadCommandArgs } from './projectThreads.mjs';
+import { H as HerdrError } from '../nitro/nitro.mjs';
+import { s as stripAnsi } from './pluginPolicy.mjs';
+import { a as target, c as runProjectCommand, p as projectsRoot } from './projectBoard.mjs';
+
+function argsFor(command, t, id) {
+  try {
+    return threadCommandArgs(command, projectsRoot(t), t.slug, id);
+  } catch (e) {
+    throw new HerdrError("bad_thread", e.message);
+  }
+}
+async function threadDetailOn(t, id) {
+  const r = await runProjectCommand(t, argsFor("show", t, id), THREAD_TIMEOUT_MS.show);
+  if (r.code !== 0) throw new HerdrError("thread_failed", lastLine(stripAnsi(r.stderr || r.stdout)) || `code ${r.code}`);
+  let raw;
+  try {
+    raw = JSON.parse(r.stdout);
+  } catch {
+    throw new HerdrError("thread_failed", "unreadable thread record");
+  }
+  const detail = normalizeThreadDetail(raw);
+  if (!detail || detail.id !== id) throw new HerdrError("thread_failed", "unreadable thread record");
+  return detail;
+}
+const busy = /* @__PURE__ */ new Set();
+async function threadActionOn(t, id, action) {
+  var _a;
+  const args = argsFor(action, t, id);
+  const key = `${(_a = t.m.key) != null ? _a : ""}|${t.dir}|${id}`;
+  if (busy.has(key)) throw new HerdrError("thread_busy", "an action is already running on this thread");
+  busy.add(key);
+  try {
+    const r = await runProjectCommand(t, args, THREAD_TIMEOUT_MS[action]);
+    const out = stripAnsi(r.stdout).trim();
+    if (r.code !== 0) {
+      throw new HerdrError("thread_failed", lastLine(stripAnsi(r.stderr || r.stdout)) || `code ${r.code}`);
+    }
+    return { output: out.slice(-2e3) };
+  } finally {
+    busy.delete(key);
+  }
+}
+async function where(pane, id) {
+  if (typeof id !== "string" || !THREAD_ID_RE.test(id)) throw new HerdrError("bad_thread", "invalid thread");
+  const t = await target(pane);
+  if (!t) throw new HerdrError("no_project", "project not found");
+  return { t, id };
+}
+async function readThreadDetail(pane, rawId) {
+  const { t, id } = await where(pane, rawId);
+  return { thread: await threadDetailOn(t, id) };
+}
+async function runThreadAction(pane, rawId, action, guard = (_t, run) => run()) {
+  if (!isThreadAction(action)) throw new HerdrError("bad_action", "Invalid action");
+  const { t, id } = await where(pane, rawId);
+  return guard(t, () => threadActionOn(t, id, action));
+}
+
+export { runThreadAction as a, readThreadDetail as r };
+//# sourceMappingURL=projectThreads2.mjs.map

package/.output/server/chunks/_/projectsActions.mjs

@@ -1,4 +1,4 @@
-import { o as fmt } from '../nitro/nitro.mjs';
+import { E as fmt } from '../nitro/nitro.mjs';
 
 const PROJECT_INPUTS = {
   new: ["name"],

package/.output/server/chunks/_/projectsPlugin.mjs

@@ -1,6 +1,6 @@
 import { promises, constants } from 'node:fs';
 import path from 'node:path';
-import { H as HerdrError, o as fmt, aB as herdrOn } from '../nitro/nitro.mjs';
+import { H as HerdrError, E as fmt, x as herdrOn } from '../nitro/nitro.mjs';
 
 const PROJECTS_REPO = "eliasstravik/herdr-projects";
 const PROJECTS_INSTALL_ARGS = ["plugin", "install", PROJECTS_REPO, "--yes"];