slopwaresystems 0.4.9 → 0.4.10

package/dist/index.js

@@ -3379,7 +3379,7 @@ import { homedir } from "os";
 import { join } from "path";
 
 // skills/slop-cli.md
-var slop_cli_default = "---\nname: slop-cli\ndescription: How an agent works the Slopware Tasks board through the slop MCP tools (board, task, plan, session, threads, say), and what the slop command is for (people and machines: login, link, install). Load when asked to create, update, plan, discuss or finish tasks.\n---\n\n# The board, as six tools\n\nYour harness has the `slop` MCP server. Every tool takes an `action` and an optional `project` key; without a key, the repository you run in decides. Descriptions and notes are Markdown. Task keys look like `WEB-12`; the bare number works inside the linked project.\n\n| Tool | Actions |\n|---|---|\n| `board` | `list` (`mine`, `status`, `all`, `archived`; `limit`/`offset` to page), `columns`, `members`, `projects` |\n| `task` | `show`, `create`, `update` (only given fields change), `move`, `link`, `archive`, `restore`, `history` (`limit`/`before` to page back), `finish` |\n| `plan` | `add` (`items`), `note`, `done`, `reopen`, `rename`, `remove` (by `item` number) |\n| `session` | `claim`, `release`, `who` (every live agent by name, you marked), `check`, `wait` (Claude Code only, and rarely; messages reach you on their own; never on Codex; see `slop-sessions`) |\n| `threads` | `list`, `read` (newest 40; `limit`/`before` to page back) |\n| `say` | `post` (new thread; with `task` it reaches whoever is live on it; with `to: <name>` it reaches that one agent; with neither it is general), `reply`. Messages are letters: read when the other agent gets to them, not at once; write once, reply only when it changes something (see `slop-sessions`) |\n\nYou have a name, given at session start (the `SessionStart` hook says it) and shown by `session who`. People and other agents address you by it. Long answers are cut at 16k characters and say so; ask for less with `limit`, `offset` or `before`.\n\nDo not shell out to `slop` for board work; the tools are the way.\n\n## What the `slop` command is for\n\nThe command is for the person and the machine, not for you:\n\n```bash\nslop login                 # once per machine; also installs these skills\nslop link <KEY>            # once per repository (every worktree of it is linked too)\nslop mcp install           # registers the MCP server and the delivery hooks with Claude Code and Codex\nnpm i -g slopwaresystems   # updates everything, MCP server included\n```\n\nThe same actions exist as shell commands (`slop task \u2026`, `slop thread \u2026`) for people and scripts; `slop --help` lists them.\n\n## Rules of the road\n\n- Do not delete tasks you did not create. Archive finished work instead.\n- Keep titles short and imperative; put the reasoning in the description or the plan's notes.\n- When you open a pull request for a task, link it: `task` with `action: link`.\n\nWhen a wake says messages are waiting, use `session` `check` with the project named in the wake. Each conversation and project has a separate inbox, including when chats share a checkout.\n\nLaunchers can set `SLOP_CONVERSATION_ID` to the host's stable chat ID and `SLOP_HARNESS` to `claude`, `codex`, or `other`. Host-provided conversation IDs are detected automatically when available. An ambiguous directory is not enough to identify a chat; supply its ID when running several chats there without host-provided identity.\n";
+var slop_cli_default = "---\nname: slop-cli\ndescription: How an agent works the Slopware Tasks board through the slop MCP tools (board, task, plan, session, threads, say), and what the slop command is for (people and machines: login, link, install). Load when asked to create, update, plan, discuss or finish tasks.\n---\n\n# The board, as six tools\n\nYour harness has the `slop` MCP server. Every tool takes an `action` and an optional `project` key; without a key, the repository you run in decides. Descriptions and notes are Markdown. Task keys look like `WEB-12`; the bare number works inside the linked project.\n\n| Tool | Actions |\n|---|---|\n| `board` | `list` (`mine`, `status`, `all`, `archived`; `limit`/`offset` to page), `columns`, `members`, `projects` |\n| `task` | `show`, `create`, `update` (only given fields change), `move`, `link`, `archive`, `restore`, `history` (`limit`/`before` to page back), `finish` |\n| `plan` | `add` (`items`), `note`, `done`, `reopen`, `rename`, `remove` (by `item` number) |\n| `session` | `claim`, `release`, `who` (every live agent by name, you marked), `check`, `wait` (Claude Code only, and rarely; messages reach you on their own; never on Codex; see `slop-sessions`) |\n| `threads` | `list`, `read` (newest 40; `limit`/`before` to page back) |\n| `say` | `post` (new thread; with `task` it reaches whoever is live on it; with `to: <name>` it reaches that one agent; with neither it is general), `reply`. Messages are letters: read when the other agent gets to them, not at once; write once, reply only when it changes something (see `slop-sessions`) |\n\nYou have a name, given at session start (the `SessionStart` hook says it) and shown by `session who`. People and other agents address you by it. Long ordinary answers are cut at 16k characters and say so; ask for less with `limit`, `offset` or `before`. Incoming messages are kept whole in a separate batch. Use `session check` to read any remaining messages.\n\nDo not shell out to `slop` for board work; the tools are the way.\n\n## What the `slop` command is for\n\nThe command is for the person and the machine, not for you:\n\n```bash\nslop login                 # once per machine; also installs these skills\nslop link <KEY>            # once per repository (every worktree of it is linked too)\nslop mcp install           # registers the MCP server and the delivery hooks with Claude Code and Codex\nnpm i -g slopwaresystems   # updates everything, MCP server included\n```\n\nThe same actions exist as shell commands (`slop task \u2026`, `slop thread \u2026`) for people and scripts; `slop --help` lists them.\n\n## Rules of the road\n\n- Do not delete tasks you did not create. Archive finished work instead.\n- Keep titles short and imperative; put the reasoning in the description or the plan's notes.\n- When you open a pull request for a task, link it: `task` with `action: link`.\n\nWhen a wake says messages are waiting, use `session` `check` with the project named in the wake. Each conversation and project has a separate inbox, including when chats share a checkout. A failed handoff is retried; a crash just after output can repeat a message, so do not repeat an action you already completed.\n\nLaunchers can set `SLOP_CONVERSATION_ID` to the host's stable chat ID and `SLOP_HARNESS` to `claude`, `codex`, or `other`. Host-provided conversation IDs are detected automatically when available. An ambiguous directory is not enough to identify a chat; supply its ID when running several chats there without host-provided identity.\n";
 
 // skills/slop-planning.md
 var slop_planning_default = '---\nname: slop-planning\ndescription: How to break long or multi-session work into a plan on its task, keep each item\'s note current, and pick up where you left off. Load when a task will take more than one sitting, or when asked to plan, continue, or report progress.\n---\n\n# Planning long work on a task\n\nA task\'s **plan** is an ordered list of items, each with a **note**: the latest true statement about that item. The plan plus the task\'s timeline is your memory between sessions. Write to it as you work, not at the end.\n\n## Starting\n\n1. Read the task: `task` `show`. If it has a plan, read the notes; they are what the last session knew.\n2. If there is no plan, write one. Items are concrete, checkable, and ordered by what unlocks what. Eight to fifteen is typical; more means the task should be split.\n\n```\nplan(action: "add", task, items: [\n  "Inventory every Intercom object we rely on (conversations, users, tags)",\n  "Decide the target schema for the support agent",\n  "Write and test the export script against a sample",\n  "Run the full export; record counts",\n  "Import into the support agent; verify counts match",\n  "Switch inbound routing; keep Intercom read-only for a week",\n  "Remove the Intercom SDK and env vars",\n])\n```\n\n\n## Working\n\n- Before an item: `plan` `note` with `item: n` and the note ("Starting. Approach: \u2026")\n- As facts arrive, replace the note. Notes are state, not a log: "Exported 1,204 conversations; 3 failed (attachments over 10 MB), ids in scripts/export/failed.json".\n- When an item is done: `plan` `done` with `item: n`. If it turned out to be two things, add the second with `plan` `add`.\n- Blocked? Put the blocker in the note, then move on to an item that is not blocked. Do not mark blocked items done.\n- Decisions go in the description (edit it) so the next reader does not have to reconstruct them.\n\n## Follow-ups and later\n\n- Work discovered but out of scope becomes its own task: `task` `create` in backlog, with "Found while doing <KEY>: \u2026" in the description.\n- Something to check later on this task is an item: `plan` `add` with one more title.\n\n## Finishing\n\n`task` `show` should show every item done or removed. Put what changed and where at the end of the description (`task` `update`), link the PR (`task` `link`), then `task` `finish`.\n\n## Picking up a task you did not start\n\n`task` `show`, then `task` `history`. The notes tell you the present; the history tells you how it got there. Then continue from the first item that is not done.\n';
@@ -24825,7 +24825,7 @@ This repository is linked to a Slopware Tasks board. Use the \`slop\` CLI to kee
 - Before starting tracked work: \`slop task list\`, then \`slop task start <KEY>\`.
 - When it is finished and verified: \`slop task done <KEY>\`.
 - Descriptions are Markdown and are shown in full on the board. Write real ones: context, file paths, what done means. Pipe long ones in with \`-d -\`.
-- Agents use the six slop MCP tools for everything on the board (\`slop mcp install\` once per machine): \`board\`, \`task\`, \`plan\`, \`session\`, \`threads\`, \`say\`, each with an \`action\`. You have a name (session start tells you; \`session who\` lists everyone's); \`say post\` with \`to\` reaches one agent by name. If a wake says mail is waiting, use \`session check\` with the project it names. Each conversation and project has its own inbox. Messages for you reach you on their own: idle, as a turn of yours; while you work, as your next turn (Codex) or with your next tool result (Claude Code). Messages are letters, not chat: the other agent reads yours when it gets to it, its reply may predate your latest, so write once and completely, answer a pile of messages with one reply, and reply only when it changes something (never to acknowledge). Do not wait for replies; end your turn. The \`slop\` command is for people and scripts. Talk through threads: \`slop task ask <KEY> "\u2026"\` reaches whoever is live on that task, \`slop thread reply <id> "\u2026"\` answers, \`slop threads\` lists them; general threads are for people and for context. Method: \`slop skill slop-sessions\`.
+- Agents use the six slop MCP tools for everything on the board (\`slop mcp install\` once per machine): \`board\`, \`task\`, \`plan\`, \`session\`, \`threads\`, \`say\`, each with an \`action\`. You have a name (session start tells you; \`session who\` lists everyone's); \`say post\` with \`to\` reaches one agent by name. If a wake says mail is waiting, use \`session check\` with the project it names. Each conversation and project has its own inbox. Messages are kept whole; use \`session check\` for any remaining messages. A crash just after output can repeat a message, so do not repeat an action you already completed. Messages for you reach you on their own: idle, as a turn of yours; while you work, as your next turn (Codex) or with your next tool result (Claude Code). Messages are letters, not chat: the other agent reads yours when it gets to it, its reply may predate your latest, so write once and completely, answer a pile of messages with one reply, and reply only when it changes something (never to acknowledge). Do not wait for replies; end your turn. The \`slop\` command is for people and scripts. Talk through threads: \`slop task ask <KEY> "\u2026"\` reaches whoever is live on that task, \`slop thread reply <id> "\u2026"\` answers, \`slop threads\` lists them; general threads are for people and for context. Method: \`slop skill slop-sessions\`.
 - Work that outlasts one session gets a plan on its task: \`slop task plan <KEY> -\` (one item per line), then \`slop task item note|done <KEY> <n>\` as you go; \`slop task items <KEY>\` shows where you are. \`slop skill slop-planning\` is the method; \`slop skills install\` puts the skills in this repository.
 - Everything is editable: \`slop task update <KEY> --title \u2026 --severity \u2026 --status \u2026 --assignee \u2026\`. Assign with \`slop task assign <KEY> <email|me|none>\`; see who exists with \`slop members\`. \`slop task list --mine\` shows your user's tasks.
 - Add \`--json\` to any command for machine-readable output. \`slop task --help\` lists everything.
@@ -24968,20 +24968,137 @@ linked to ${link.projectKey}  ${link.projectName}  (${link.baseUrl})`
 }
 
 // src/commands/mcp.ts
-import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
+import { execFileSync as execFileSync6, spawn as spawn3 } from "child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 
 // src/platform/session-recovery.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
+
+// src/platform/inbox.ts
+import { createHash as createHash6, randomUUID as randomUUID7 } from "crypto";
+import { existsSync as existsSync9, linkSync as linkSync3, mkdirSync as mkdirSync7, readFileSync as readFileSync10, readdirSync as readdirSync6, realpathSync as realpathSync4, renameSync as renameSync2, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname5, join as join12 } from "path";
+
+// src/platform/inbox-claims.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync7, linkSync as linkSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync8, readdirSync as readdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
+var processOwner = null;
+function fetchProcessStart(pid) {
+  try {
+    return execFileSync5("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function isClaimOwnerRunning(owner) {
+  if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0) throw new Error("Invalid inbox claim owner");
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error62) {
+    if (error62.code === "ESRCH") return false;
+    return true;
+  }
+  if (owner.pid === process.pid) return !owner.started || !processOwner?.started || owner.started === processOwner.started;
+  const started = owner.started && fetchProcessStart(owner.pid);
+  return !started || started === owner.started;
+}
+function claimInboxMessage(directory) {
+  mkdirSync5(directory, { recursive: true });
+  processOwner ??= { pid: process.pid, started: fetchProcessStart(process.pid) };
+  for (; ; ) {
+    let names;
+    try {
+      names = readdirSync4(directory).filter((name) => /^\d+\.json$/.test(name)).sort((a, b) => Number(a.slice(0, -5)) - Number(b.slice(0, -5)));
+    } catch (error62) {
+      if (error62.code === "ENOENT") return null;
+      throw error62;
+    }
+    const last = names.at(-1);
+    if (last && !existsSync7(join10(directory, `${last}.released`))) {
+      let owner;
+      try {
+        owner = JSON.parse(readFileSync8(join10(directory, last), "utf8"));
+      } catch (error62) {
+        if (error62.code === "ENOENT") return null;
+        throw error62;
+      }
+      if (isClaimOwnerRunning(owner)) return null;
+    }
+    const next = join10(directory, `${last ? Number(last.slice(0, -5)) + 1 : 0}.json`);
+    const temporary = join10(directory, `${randomUUID6()}.writing`);
+    try {
+      writeFileSync6(temporary, JSON.stringify(processOwner), { flag: "wx", mode: 384 });
+      linkSync2(temporary, next);
+      return { release: () => {
+        try {
+          writeFileSync6(`${next}.released`, "", { mode: 384 });
+        } catch (error62) {
+          if (error62.code !== "ENOENT") throw error62;
+        }
+      } };
+    } catch (error62) {
+      if (error62.code === "ENOENT") return null;
+      if (error62.code !== "EEXIST") throw error62;
+    } finally {
+      rmSync5(temporary, { force: true });
+    }
+  }
+}
+
+// src/platform/inbox-receipts.ts
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync5, rmSync as rmSync6 } from "fs";
+import { join as join11 } from "path";
+var COMPACTION_SIZE = 128;
+var archives = /* @__PURE__ */ new Map();
+function fetchArchivedReceipts(directory) {
+  let cached2 = archives.get(directory);
+  if (!cached2) {
+    cached2 = { files: /* @__PURE__ */ new Set(), keys: /* @__PURE__ */ new Set() };
+    archives.set(directory, cached2);
+  }
+  let names;
+  try {
+    names = readdirSync5(join11(directory, "compacted"));
+  } catch (error62) {
+    if (error62.code === "ENOENT") return cached2.keys;
+    throw error62;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json") || cached2.files.has(name)) continue;
+    const keys = JSON.parse(readFileSync9(join11(directory, "compacted", name), "utf8"));
+    if (!Array.isArray(keys) || !keys.every((key) => typeof key === "string" && /^[a-f0-9]{64}$/.test(key))) throw new Error("Invalid inbox receipt archive");
+    for (const key of keys) cached2.keys.add(key);
+    cached2.files.add(name);
+  }
+  return cached2.keys;
+}
+function hasInboxReceipt(directory, key) {
+  return existsSync8(join11(directory, key)) || fetchArchivedReceipts(directory).has(key);
+}
+function compactInboxReceipts(directory) {
+  let keys;
+  try {
+    keys = readdirSync5(directory).filter((name2) => /^[a-f0-9]{64}$/.test(name2)).sort();
+  } catch (error62) {
+    if (error62.code === "ENOENT") return;
+    throw error62;
+  }
+  if (keys.length < COMPACTION_SIZE) return;
+  mkdirSync6(join11(directory, "compacted"), { recursive: true });
+  const text = JSON.stringify(keys);
+  const name = createHash5("sha256").update(text).digest("hex");
+  persistLocalState(join11(directory, "compacted", `${name}.json`), text, false);
+  for (const key of keys) rmSync6(join11(directory, key), { force: true });
+}
 
 // src/platform/inbox.ts
-import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync7, linkSync as linkSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync8, readdirSync as readdirSync4, realpathSync as realpathSync4, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
-var buildInboxDir = () => join10(dirname5(buildConfigPath()), "inbox");
+var buildInboxDir = () => join12(dirname5(buildConfigPath()), "inbox");
 var resolveRealCwd2 = (cwd) => {
   try {
     return realpathSync4(cwd);
@@ -24989,100 +25106,169 @@ var resolveRealCwd2 = (cwd) => {
     return cwd;
   }
 };
-var generateInboxKey = (cwd, owner) => owner ? generateLocalStateKey(cwd, JSON.stringify([owner.baseUrl.replace(/\/$/, ""), owner.projectId, owner.conversation])) : createHash5("sha256").update(resolveRealCwd2(cwd)).digest("hex").slice(0, 16);
-var buildInboxPath = (cwd) => join10(buildInboxDir(), `${generateInboxKey(cwd)}.jsonl`);
-var buildInboxQueuePath = (cwd, owner) => join10(buildInboxDir(), generateInboxKey(cwd, owner));
+var generateInboxKey = (cwd, owner) => owner ? generateLocalStateKey(cwd, JSON.stringify([owner.baseUrl.replace(/\/$/, ""), owner.projectId, owner.conversation])) : createHash6("sha256").update(resolveRealCwd2(cwd)).digest("hex").slice(0, 16);
+var buildInboxPath = (cwd) => join12(buildInboxDir(), `${generateInboxKey(cwd)}.jsonl`);
+var buildInboxQueuePath = (cwd, owner) => join12(buildInboxDir(), generateInboxKey(cwd, owner));
 var sequence = 0;
 function persistInboxPush(cwd, push, owner) {
   const directory = buildInboxQueuePath(cwd, owner);
-  mkdirSync5(directory, { recursive: true });
-  const name = `${Date.now()}.${process.pid}.${String(sequence++).padStart(12, "0")}.${randomUUID6()}`;
-  const temporary = join10(directory, `${name}.writing`);
-  writeFileSync6(temporary, JSON.stringify(push), { flag: "wx" });
+  mkdirSync7(directory, { recursive: true });
+  const name = `${Date.now()}.${process.pid}.${String(sequence++).padStart(12, "0")}.${randomUUID7()}`;
+  const temporary = join12(directory, `${name}.writing`);
+  writeFileSync7(temporary, JSON.stringify(push), { flag: "wx" });
   if (owner) {
-    const key = createHash5("sha256").update(push.message.id).digest("hex");
-    const published = join10(directory, `${key}.json`);
+    const key = createHash6("sha256").update(push.message.id).digest("hex");
+    const published = join12(directory, `${key}.json`);
     try {
-      if (existsSync7(join10(directory, "receipts", key))) return false;
-      linkSync2(temporary, published);
+      if (hasInboxReceipt(join12(directory, "receipts"), key)) return false;
+      linkSync3(temporary, published);
       return true;
     } catch (error62) {
-      if (error62.code === "EEXIST") return !existsSync7(join10(directory, "receipts", key));
+      if (error62.code === "EEXIST") return !hasInboxReceipt(join12(directory, "receipts"), key);
       throw error62;
     } finally {
-      rmSync5(temporary, { force: true });
+      rmSync7(temporary, { force: true });
     }
   }
-  renameSync2(temporary, join10(directory, `${name}.json`));
+  renameSync2(temporary, join12(directory, `${name}.json`));
   return true;
 }
-function drainInbox(cwd, owner, accept = () => true) {
-  const pushes = owner ? [] : drainLegacyInbox(cwd);
-  const directory = buildInboxQueuePath(cwd, owner);
+function deleteAcknowledgedInboxClaims(directory) {
+  const claims = join12(directory, "claims");
   let names;
   try {
-    names = readdirSync4(directory).filter((file2) => file2.endsWith(".json")).sort();
+    names = readdirSync6(claims);
   } catch (error62) {
-    if (error62.code === "ENOENT") return pushes;
+    if (error62.code === "ENOENT") return;
     throw error62;
   }
-  if (owner) {
-    const receipts = join10(directory, "receipts");
-    mkdirSync5(receipts, { recursive: true });
+  for (const key of names) {
+    if (!/^[a-f0-9]{64}$/.test(key) || !hasInboxReceipt(join12(directory, "receipts"), key)) continue;
+    try {
+      rmSync7(join12(claims, key), { recursive: true, force: true });
+    } catch (error62) {
+      if (error62.code !== "ENOTEMPTY") throw error62;
+    }
+  }
+}
+function claimInbox(cwd, owner, accept = () => true) {
+  const directory = buildInboxQueuePath(cwd, owner);
+  const receipts = join12(directory, "receipts");
+  const claims = [];
+  let settled = false;
+  const release = () => {
+    if (settled) return;
+    for (const claim2 of claims) claim2.release();
+    settled = true;
+  };
+  const delivery = {
+    pushes: [],
+    release,
+    acknowledge: () => {
+      if (settled) return;
+      mkdirSync7(receipts, { recursive: true });
+      for (const { key } of claims) {
+        try {
+          writeFileSync7(join12(receipts, key), "", { flag: "wx", mode: 384 });
+        } catch (error62) {
+          if (error62.code !== "EEXIST") throw error62;
+        }
+      }
+      settled = true;
+      try {
+        for (const { key } of claims) rmSync7(join12(directory, `${key}.json`), { force: true });
+        deleteAcknowledgedInboxClaims(directory);
+        compactInboxReceipts(receipts);
+      } catch {
+      }
+    }
+  };
+  try {
+    let names;
+    try {
+      names = readdirSync6(directory).filter((file2) => /^[a-f0-9]{64}\.json$/.test(file2));
+    } catch (error62) {
+      if (error62.code === "ENOENT") return delivery;
+      throw error62;
+    }
     const available = [];
     for (const name of names) {
       try {
-        available.push({ name, push: JSON.parse(readFileSync8(join10(directory, name), "utf8")) });
+        available.push({ key: name.slice(0, -5), push: JSON.parse(readFileSync10(join12(directory, name), "utf8")) });
       } catch (error62) {
         if (error62.code !== "ENOENT") throw error62;
       }
     }
     available.sort((a, b) => a.push.message.createdAt.localeCompare(b.push.message.createdAt) || a.push.message.id.localeCompare(b.push.message.id));
-    for (const { name, push } of available) {
+    for (const { key, push } of available) {
+      if (hasInboxReceipt(receipts, key)) {
+        rmSync7(join12(directory, `${key}.json`), { force: true });
+        continue;
+      }
       if (!accept(push)) continue;
-      const path2 = join10(directory, name);
-      const receipt = join10(receipts, name.slice(0, -5));
+      let claim2;
       try {
-        writeFileSync6(receipt, "", { flag: "wx", mode: 384 });
+        claim2 = claimInboxMessage(join12(directory, "claims", key));
       } catch (error62) {
-        if (error62.code === "EEXIST") {
-          rmSync5(path2, { force: true });
-          continue;
-        }
+        if (hasInboxReceipt(receipts, key)) continue;
         throw error62;
       }
-      pushes.push(push);
-      rmSync5(path2, { force: true });
+      if (!claim2) continue;
+      claims.push({ key, ...claim2 });
+      if (!hasInboxReceipt(receipts, key)) delivery.pushes.push(push);
     }
-    return pushes;
+    return delivery;
+  } catch (error62) {
+    release();
+    throw error62;
+  }
+}
+function hasPendingInboxMessages(cwd, owner) {
+  const directory = buildInboxQueuePath(cwd, owner);
+  try {
+    return readdirSync6(directory).some((name) => /^[a-f0-9]{64}\.json$/.test(name) && !hasInboxReceipt(join12(directory, "receipts"), name.slice(0, -5)));
+  } catch (error62) {
+    if (error62.code === "ENOENT") return false;
+    throw error62;
+  }
+}
+function drainInbox(cwd) {
+  const pushes = drainLegacyInbox(cwd);
+  const directory = buildInboxQueuePath(cwd);
+  let names;
+  try {
+    names = readdirSync6(directory).filter((file2) => file2.endsWith(".json")).sort();
+  } catch (error62) {
+    if (error62.code === "ENOENT") return pushes;
+    throw error62;
   }
   for (const name of names) {
-    const taken = join10(directory, `${name}.${randomUUID6()}.draining`);
+    const taken = join12(directory, `${name}.${randomUUID7()}.draining`);
     try {
-      renameSync2(join10(directory, name), taken);
+      renameSync2(join12(directory, name), taken);
     } catch (error62) {
       if (error62.code === "ENOENT") continue;
       throw error62;
     }
     try {
-      pushes.push(JSON.parse(readFileSync8(taken, "utf8")));
+      pushes.push(JSON.parse(readFileSync10(taken, "utf8")));
     } finally {
-      rmSync5(taken, { force: true });
+      rmSync7(taken, { force: true });
     }
   }
   return pushes;
 }
 function drainLegacyInbox(cwd) {
   const path2 = buildInboxPath(cwd);
-  if (!existsSync7(path2)) return [];
+  if (!existsSync9(path2)) return [];
   const taken = `${path2}.${process.pid}.${Date.now()}.draining`;
   try {
     renameSync2(path2, taken);
   } catch {
     return [];
   }
-  const lines = readFileSync8(taken, "utf8").split("\n").filter(Boolean);
-  rmSync5(taken, { force: true });
+  const lines = readFileSync10(taken, "utf8").split("\n").filter(Boolean);
+  rmSync7(taken, { force: true });
   return lines.flatMap((line) => {
     try {
       return [JSON.parse(line)];
@@ -25098,7 +25284,7 @@ var SessionRecovery = class {
     this.api = api;
     this.owner = owner;
     this.deliverPush = deliverPush;
-    this.path = join11(dirname6(buildConfigPath()), "cursors", `${generateInboxKey(cwd, owner)}.json`);
+    this.path = join13(dirname6(buildConfigPath()), "cursors", `${generateInboxKey(cwd, owner)}.json`);
   }
   api;
   owner;
@@ -25118,7 +25304,7 @@ var SessionRecovery = class {
   }
   async fetchCursor() {
     try {
-      const value = JSON.parse(readFileSync9(this.path, "utf8"));
+      const value = JSON.parse(readFileSync11(this.path, "utf8"));
       if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error("Invalid saved message cursor");
       this.cursor = value;
     } catch (error62) {
@@ -25471,63 +25657,98 @@ function truncateToolResult(result) {
 
 // src/platform/mcp.ts
 import { createInterface } from "readline";
+var McpOutput = class {
+  deliveries = [];
+  remainingMessageChars = RESULT_CAP;
+  registerDelivery(delivery) {
+    this.deliveries.push(delivery);
+    this.remainingMessageChars -= delivery.text.length;
+  }
+  formatResult(text) {
+    const messages = this.deliveries.map((delivery) => delivery.text).filter(Boolean);
+    return [truncateToolResult(text), ...messages.length ? ["--- Messages for you (read once; do not acknowledge). Use session check for any remaining messages. ---", ...messages] : []].filter(Boolean).join("\n\n");
+  }
+  acknowledgeDeliveries() {
+    for (const delivery of this.deliveries) delivery.acknowledge();
+  }
+  releaseDeliveries() {
+    for (const delivery of this.deliveries) delivery.release();
+  }
+};
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function buildMcpRequestHandler(tools, info, sendJsonRpcMessage) {
   const sendJsonRpcResult = (id, result) => sendJsonRpcMessage({ jsonrpc: "2.0", id, result });
   const sendJsonRpcError = (id, code, message) => sendJsonRpcMessage({ jsonrpc: "2.0", id, error: { code, message } });
   return async (value) => {
     if (!isRecord(value) || value.jsonrpc !== "2.0" || typeof value.method !== "string" || value.id !== void 0 && value.id !== null && typeof value.id !== "string" && typeof value.id !== "number") {
-      sendJsonRpcError(null, -32600, "Invalid request");
+      await sendJsonRpcError(null, -32600, "Invalid request");
       return;
     }
     const request = value;
     const { id, method } = request;
     if (id === void 0) return;
     if (request.params !== void 0 && !isRecord(request.params)) {
-      sendJsonRpcError(id, -32602, "Params must be an object");
+      await sendJsonRpcError(id, -32602, "Params must be an object");
       return;
     }
     const params = request.params ?? {};
     switch (method) {
       case "initialize":
-        sendJsonRpcResult(id, { protocolVersion: params.protocolVersion ?? "2025-06-18", capabilities: { tools: {} }, serverInfo: info });
+        await sendJsonRpcResult(id, { protocolVersion: params.protocolVersion ?? "2025-06-18", capabilities: { tools: {} }, serverInfo: info });
         return;
       case "notifications/initialized":
       case "notifications/cancelled":
         return;
       case "ping":
-        sendJsonRpcResult(id, {});
+        await sendJsonRpcResult(id, {});
         return;
       case "tools/list":
-        sendJsonRpcResult(id, { tools: tools.map(({ name, description: description2, inputSchema }) => ({ name, description: description2, inputSchema })) });
+        await sendJsonRpcResult(id, { tools: tools.map(({ name, description: description2, inputSchema }) => ({ name, description: description2, inputSchema })) });
         return;
       case "tools/call": {
         const name = params.name;
         if (typeof name !== "string" || params.arguments !== void 0 && !isRecord(params.arguments)) {
-          sendJsonRpcError(id, -32602, "Tool name and arguments are invalid");
+          await sendJsonRpcError(id, -32602, "Tool name and arguments are invalid");
           return;
         }
         const tool = tools.find((candidate) => candidate.name === name);
         if (!tool) {
-          sendJsonRpcError(id, -32602, `No tool named ${name}`);
+          await sendJsonRpcError(id, -32602, `No tool named ${name}`);
           return;
         }
+        const output2 = new McpOutput();
+        let text;
         try {
-          const text = await tool.run(params.arguments ?? {});
-          sendJsonRpcResult(id, { content: [{ type: "text", text }] });
+          text = output2.formatResult(await tool.run(params.arguments ?? {}, output2));
         } catch (error62) {
-          sendJsonRpcResult(id, { content: [{ type: "text", text: error62 instanceof Error ? error62.message : String(error62) }], isError: true });
+          output2.releaseDeliveries();
+          await sendJsonRpcResult(id, { content: [{ type: "text", text: error62 instanceof Error ? error62.message : String(error62) }], isError: true });
+          return;
+        }
+        try {
+          await sendJsonRpcResult(id, { content: [{ type: "text", text }] });
+          output2.acknowledgeDeliveries();
+        } catch (error62) {
+          output2.releaseDeliveries();
+          throw error62;
         }
         return;
       }
       default:
-        if (id !== void 0) sendJsonRpcError(id, -32601, `Unknown method ${method}`);
+        if (id !== void 0) await sendJsonRpcError(id, -32601, `Unknown method ${method}`);
     }
   };
 }
 function serveMcp(tools, info) {
-  const sendJsonRpcMessage = (message) => process.stdout.write(`${JSON.stringify(message)}
-`);
+  const sendJsonRpcMessage = (message) => new Promise((resolve6, reject) => {
+    process.stdout.write(`${JSON.stringify(message)}
+`, (error62) => error62 ? reject(error62) : resolve6());
+  });
+  const endFailedOutput = () => {
+    process.exitCode = 1;
+    process.stdin.destroy();
+  };
+  process.stdout.on("error", endFailedOutput);
   const handleJsonRpcRequest = buildMcpRequestHandler(tools, info, sendJsonRpcMessage);
   const lines = createInterface({ input: process.stdin });
   lines.on("line", (line) => {
@@ -25536,19 +25757,19 @@ function serveMcp(tools, info) {
     try {
       request = JSON.parse(line);
     } catch {
-      sendJsonRpcMessage({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      void sendJsonRpcMessage({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }).catch(endFailedOutput);
       return;
     }
-    void handleJsonRpcRequest(request);
+    void handleJsonRpcRequest(request).catch(endFailedOutput);
   });
 }
 
 // src/commands/tasks.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 
 // src/commands/items.ts
-import { readFileSync as readFileSync10 } from "fs";
-var fetchTextArgument = (value) => value === "-" ? readFileSync10(0, "utf8").trim() : value;
+import { readFileSync as readFileSync12 } from "fs";
+var fetchTextArgument = (value) => value === "-" ? readFileSync12(0, "utf8").trim() : value;
 var buildItemsPath = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}/items`;
 function formatPlanItems(items) {
   if (items.length === 0) return "No plan yet. Write one: slop task plan <KEY> -";
@@ -25575,7 +25796,7 @@ function registerItemCommands(task, registerProjectOption) {
   registerProjectOption(task.command("plan <key> [lines...]")).description('Append items to the plan, one per argument; "-" reads one per line from stdin (list markers are fine).').action(async (key, lines, options) => {
     const api = buildAuthedApiClient();
     const project = await resolveProject(api, options.project);
-    const source = lines.length === 1 && lines[0] === "-" ? readFileSync10(0, "utf8") : lines.join("\n");
+    const source = lines.length === 1 && lines[0] === "-" ? readFileSync12(0, "utf8") : lines.join("\n");
     const titles = source.split("\n").map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s*(?:\[[ xX]\]\s*)?/, "").trim()).filter(Boolean);
     if (titles.length === 0) throw new CliError("Nothing to add", 'give items as arguments, or "-" and one per line on stdin');
     const items = await api.post(buildItemsPath(project.id, key), ApiResponses.TaskItems, { items: titles.map((title3) => ({ title: title3 })) });
@@ -25632,7 +25853,7 @@ function parseOneOf(value, allowed, what) {
   if (allowed.includes(normalized)) return normalized;
   throw new CliError(`Unknown ${what} "${value}"`, `use one of: ${allowed.join(", ")}`);
 }
-var fetchTextArgument2 = (value) => value === "-" ? readFileSync11(0, "utf8").trim() : value;
+var fetchTextArgument2 = (value) => value === "-" ? readFileSync13(0, "utf8").trim() : value;
 var buildTaskUrl = (baseUrl, projectId, task) => `${baseUrl}/projects/${projectId}?task=${task.key}`;
 var fetchProject = (api, id) => api.get(`/projects/${id}`, ApiResponses.Project);
 function resolveStatus(project, ref) {
@@ -25783,21 +26004,21 @@ ${buildTaskUrl(api.baseUrl, project.id, created)}`);
 }
 
 // src/platform/update-check.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname7, join as join12 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname7, join as join14 } from "path";
 var CHECK_EVERY_MS = 60 * 60 * 1e3;
 var REGISTRY = "https://registry.npmjs.org/slopwaresystems/latest";
-var buildUpdateCachePath = () => join12(dirname7(buildConfigPath()), "update-check.json");
+var buildUpdateCachePath = () => join14(dirname7(buildConfigPath()), "update-check.json");
 function fetchUpdateCache() {
   try {
-    return JSON.parse(readFileSync12(buildUpdateCachePath(), "utf8"));
+    return JSON.parse(readFileSync14(buildUpdateCachePath(), "utf8"));
   } catch {
     return { checkedAt: 0, latest: null };
   }
 }
 function persistUpdateCache(cache) {
-  mkdirSync6(dirname7(buildUpdateCachePath()), { recursive: true });
-  writeFileSync7(buildUpdateCachePath(), JSON.stringify(cache));
+  mkdirSync8(dirname7(buildUpdateCachePath()), { recursive: true });
+  writeFileSync8(buildUpdateCachePath(), JSON.stringify(cache));
 }
 function isNewerVersion(a, b) {
   const parseVersionParts = (version2) => version2.split(".").map((part) => Number.parseInt(part, 10));
@@ -25826,11 +26047,11 @@ function buildUpdateNotice(current) {
   if (!latest || !isNewerVersion(latest, current)) return null;
   return `Update available: slopwaresystems ${latest} (this is ${current}). Ask your person to run: npm i -g slopwaresystems && slop mcp install`;
 }
-var isUpdateCheckEnabled = () => !existsSync8(join12(dirname7(buildConfigPath()), "no-update-check")) && process.env.SLOP_NO_UPDATE_CHECK !== "1";
+var isUpdateCheckEnabled = () => !existsSync10(join14(dirname7(buildConfigPath()), "no-update-check")) && process.env.SLOP_NO_UPDATE_CHECK !== "1";
 
 // src/commands/threads.ts
-import { readFileSync as readFileSync13 } from "fs";
-var fetchTextArgument3 = (value) => value === "-" ? readFileSync13(0, "utf8").trim() : value;
+import { readFileSync as readFileSync15 } from "fs";
+var fetchTextArgument3 = (value) => value === "-" ? readFileSync15(0, "utf8").trim() : value;
 var formatMessageTime = (iso) => iso.slice(0, 16).replace("T", " ");
 var formatAuthor = (message) => message.via !== "agent" ? message.author.name : `${message.agent ?? message.author.name} (${message.agent ? `${message.author.name}'s agent` : "agent"}${message.machine ? ` \xB7 ${message.machine}` : ""})`;
 function formatThreadLine(thread) {
@@ -25941,12 +26162,32 @@ function createProjectTools(api, project, identity) {
   api.sessionId = null;
   const resolveProjectFromArgs = async (_args) => project;
   const owner = { baseUrl: api.baseUrl, projectId: project.id, conversation: identity.conversation };
-  const drainOwnInbox = (thread = null) => drainInbox(process.cwd(), owner, (push) => !thread || push.thread.id === thread);
+  const claimOwnInbox = (output2, accept = () => true) => {
+    let remaining = output2.remainingMessageChars;
+    const delivery = claimInbox(process.cwd(), owner, (push) => {
+      if (!accept(push)) return false;
+      const length = formatPushBlock(push).length + 2;
+      if (length > remaining && remaining !== RESULT_CAP) return false;
+      remaining -= length;
+      return true;
+    });
+    output2.registerDelivery({ ...delivery, text: delivery.pushes.map(formatPushBlock).join("\n\n") });
+    return delivery.pushes.length > 0;
+  };
   const persistOwnInboxPush = (push) => persistInboxPush(process.cwd(), push, owner);
   let held = null;
   let stopped = false;
   const recovery = new SessionRecovery(api, owner, process.cwd(), (push) => held?.deliverPush(push));
   let waking = false;
+  const wakeOwnHarness = () => {
+    if (waking || stopped) return;
+    waking = true;
+    const text = `Messages are waiting for you on Slopware Tasks in project ${project.key}. Use session check with project ${project.id} to read them, then act or reply only if it changes something. Do not acknowledge.`;
+    const wake = identity.harness === "codex" && identity.conversation ? wakeCodex(text, identity.conversation, { binary: resolveCodexBinary(), codexHome: resolveOwnHarnessHome("CODEX_HOME") }) : identity.harness === "claude" ? wakeHarness(text, void 0, identity.conversation) : Promise.resolve(false);
+    void wake.catch(() => false).finally(() => {
+      waking = false;
+    });
+  };
   const resolveOwnAgentIdentity = () => identity;
   const holdSession = async (projectId, taskKey) => {
     if (stopped) throw new Error("The project session is stopping");
@@ -25963,16 +26204,7 @@ function createProjectTools(api, project, identity) {
     held?.stop();
     held = new HeldSession(api, projectId, taskKey, {
       onPush: persistOwnInboxPush,
-      onMessage: () => {
-        if (waking) return;
-        waking = true;
-        const text = `Messages are waiting for you on Slopware Tasks in project ${project.key}. Use session check with project ${project.id} to read them, then act or reply only if it changes something. Do not acknowledge.`;
-        const me = resolveOwnAgentIdentity();
-        const wake = me.harness === "codex" && me.conversation ? wakeCodex(text, me.conversation, { binary: resolveCodexBinary(), codexHome: resolveOwnHarnessHome("CODEX_HOME") }) : me.harness === "claude" ? wakeHarness(text, void 0, me.conversation) : Promise.resolve(false);
-        void wake.catch(() => false).finally(() => {
-          waking = false;
-        });
-      },
+      onMessage: wakeOwnHarness,
       claim: resolveOwnAgentIdentity,
       onReconnect: () => recovery.sync()
     });
@@ -25980,6 +26212,7 @@ function createProjectTools(api, project, identity) {
     await current.start();
     await current.requireSession();
     await recovery.sync();
+    if (held === current && !current.isStopped && hasPendingInboxMessages(process.cwd(), owner)) wakeOwnHarness();
   };
   const resolveProjectWithPresence = async (args) => {
     const target = await resolveProjectFromArgs(args);
@@ -25990,29 +26223,28 @@ function createProjectTools(api, project, identity) {
   const releaseTaskSession = async () => {
     if (held?.taskKey) await holdSession(held.projectId, null);
   };
-  const waitForNextMessage = async (thread, minutes) => {
-    const wanted = drainOwnInbox(thread);
-    if (wanted.length) return { pushes: wanted, released: false };
+  const waitForNextMessage = async (output2, thread, minutes) => {
+    if (claimOwnInbox(output2, (push) => !thread || push.thread.id === thread)) return { received: true, released: false };
     const waitingOn = held;
-    if (!waitingOn || waitingOn.isStopped || !waitingOn.session?.reachable) return { pushes: [], released: true };
+    if (!waitingOn || waitingOn.isStopped || !waitingOn.session?.reachable) return { received: false, released: true };
     return new Promise((resolve6) => {
       const acceptDeliveredPush = (delivered) => {
         if (delivered && thread && delivered.thread.id !== thread) return false;
-        if (delivered && drainInbox(process.cwd(), owner, (push) => push.message.id === delivered.message.id).length === 0) return false;
+        if (delivered && !claimOwnInbox(output2, (push) => push.message.id === delivered.message.id)) return false;
         waitingOn.waiters.delete(acceptDeliveredPush);
         clearTimeout(timer);
-        resolve6({ pushes: delivered ? [delivered] : [], released: delivered === null });
+        resolve6({ received: delivered !== null, released: delivered === null });
         return true;
       };
       waitingOn.waiters.add(acceptDeliveredPush);
       const timer = setTimeout(() => {
         waitingOn.waiters.delete(acceptDeliveredPush);
-        resolve6({ pushes: [], released: false });
+        resolve6({ received: false, released: false });
       }, minutes * 6e4);
     });
   };
   const formatWaitOutcome = (outcome, minutes, thread) => {
-    if (outcome.pushes.length) return outcome.pushes.map(formatPushBlock).join("\n\n");
+    if (outcome.received) return "";
     if (outcome.released) return "This wait ended because the session was released, replaced, or made unreachable.";
     return thread ? `No reply in ${thread} in ${minutes} minutes.` : `No message in ${minutes} minutes.`;
   };
@@ -26021,30 +26253,29 @@ function createProjectTools(api, project, identity) {
       name: "wait_for_message",
       description: "Claude Code only, and rarely: block until the next message for you (on your task, in a thread you are in, or addressed to you), or, with `thread`, the next one in that thread; or until `minutes` pass. Messages reach you on their own; use this only when you cannot go on without the answer. Never on Codex: end your turn and the reply is your next turn.",
       inputSchema: buildToolSchema({ task: buildStringSchema("Task key to go live on first (optional)"), thread: buildStringSchema("Only a message in this thread"), minutes: buildIntegerSchema("Give up after (default 300; 20 with thread)"), project: PROJECT }),
-      run: async (args) => {
+      run: async (args, output2) => {
         const target = await resolveProjectWithPresence(args);
         if (args.task) await holdSession(target.id, String(args.task));
         const thread = args.thread ? String(args.thread) : null;
         const minutes = typeof args.minutes === "number" ? args.minutes : thread ? 20 : 300;
-        return formatWaitOutcome(await waitForNextMessage(thread, minutes), minutes, thread);
+        return formatWaitOutcome(await waitForNextMessage(output2, thread, minutes), minutes, thread);
       }
     },
     {
       name: "check_messages",
       description: "What is unread right now: anything the held session received since you last looked, threads about a task (if given), and general threads. Does not wait. Marks them read.",
       inputSchema: buildToolSchema({ task: buildStringSchema("Task key"), project: PROJECT }),
-      run: async (args) => {
+      run: async (args, output2) => {
         const target = await resolveProjectWithPresence(args);
-        const queued = drainOwnInbox().map(formatPushBlock);
-        const rest = await buildUnreadDigest(api, target.id, args.task ?? null);
-        return [...queued, rest].join("\n\n");
+        claimOwnInbox(output2);
+        return buildUnreadDigest(api, target.id, args.task ?? null);
       }
     },
     {
       name: "reply",
       description: "Reply in a thread. In a thread about a task, it reaches whoever is live on that task now, or waits for them.",
       inputSchema: buildToolSchema({ thread: buildStringSchema("Thread id"), body: buildStringSchema("The message (Markdown)"), wait: buildIntegerSchema("Claude Code only, rarely: then wait this many minutes for a reply in the thread"), project: PROJECT }, ["thread", "body"]),
-      run: async (args) => {
+      run: async (args, output2) => {
         const target = await resolveProjectWithPresence(args);
         const thread = String(args.thread);
         const result = await api.post(`/projects/${target.id}/threads/${thread}/messages`, ApiResponses.CreatedThreadMessage, { body: String(args.body) });
@@ -26052,14 +26283,14 @@ function createProjectTools(api, project, identity) {
         if (typeof args.wait !== "number" || args.wait <= 0) return replied;
         return `${replied}
 
-${formatWaitOutcome(await waitForNextMessage(thread, args.wait), args.wait, thread)}`;
+${formatWaitOutcome(await waitForNextMessage(output2, thread, args.wait), args.wait, thread)}`;
       }
     },
     {
       name: "post",
       description: "Start a thread. With a task: about that task, to whoever is live on it (or whoever picks it up). Without: general, for people and for context; nobody has to answer.",
       inputSchema: buildToolSchema({ subject: buildStringSchema("Subject (default: the first line of the body)"), body: buildStringSchema("First message (Markdown)"), task: buildStringSchema("Task key, to make it about that task"), wait: buildIntegerSchema("Claude Code only, rarely: then wait this many minutes for a reply in the thread"), project: PROJECT }, ["body"]),
-      run: async (args) => {
+      run: async (args, output2) => {
         const target = await resolveProjectWithPresence(args);
         const result = await api.post(`/projects/${target.id}/threads`, ApiResponses.CreatedThread, { subject: args.subject ? String(args.subject) : void 0, body: String(args.body), task: args.task, to: args.to });
         const names = result.thread.to.map((recipient) => recipient.agent).join(", ");
@@ -26067,7 +26298,7 @@ ${formatWaitOutcome(await waitForNextMessage(thread, args.wait), args.wait, thre
         if (typeof args.wait !== "number" || args.wait <= 0) return started;
         return `${started}
 
-${formatWaitOutcome(await waitForNextMessage(result.thread.id, args.wait), args.wait, result.thread.id)}`;
+${formatWaitOutcome(await waitForNextMessage(output2, result.thread.id, args.wait), args.wait, result.thread.id)}`;
       }
     },
     {
@@ -26343,44 +26574,41 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
       recovery.stop();
       held?.stop();
     },
-    tools: tools.map((tool) => ({ ...tool, run: async (args) => {
-      const result = truncateToolResult(await tool.run(args));
-      const arrived = tool.name === "check_messages" || tool.name === "wait_for_message" ? [] : drainOwnInbox();
-      return arrived.length ? `${result}
-
---- Messages arrived while you worked (answer what is still open, once; do not acknowledge) ---
-${arrived.map(formatPushBlock).join("\n\n")}` : result;
+    tools: tools.map((tool) => ({ ...tool, run: async (args, output2) => {
+      const result = await tool.run(args, output2);
+      if (tool.name !== "check_messages" && tool.name !== "wait_for_message") claimOwnInbox(output2);
+      return result;
     } }))
   };
 }
 function fetchJsonFile(path2) {
   try {
-    return JSON.parse(readFileSync14(path2, "utf8"));
+    return JSON.parse(readFileSync16(path2, "utf8"));
   } catch {
     return {};
   }
 }
 function installIntoClaudeHome(dir) {
   const done = [];
-  const primary = dir === join13(homedir4(), ".claude");
+  const primary = dir === join15(homedir4(), ".claude");
   const env = { ...process.env };
   if (primary) delete env.CLAUDE_CONFIG_DIR;
   else env.CLAUDE_CONFIG_DIR = dir;
   const where = primary ? "" : ` for ${dir}`;
   try {
-    execFileSync5("claude", ["mcp", "add", "--scope", "user", "slop", "--", "slop", "mcp"], { stdio: ["ignore", "ignore", "pipe"], env });
+    execFileSync6("claude", ["mcp", "add", "--scope", "user", "slop", "--", "slop", "mcp"], { stdio: ["ignore", "ignore", "pipe"], env });
     done.push(`Claude Code: MCP server "slop" registered (user scope${where})`);
   } catch (error62) {
     const said = String(error62.stderr ?? "") + String(error62.stdout ?? "");
     if (/already exists/i.test(said)) done.push(`Claude Code: MCP server "slop" already registered (user scope${where})`);
     else done.push(`Claude Code: run \`${primary ? "" : `CLAUDE_CONFIG_DIR=${dir} `}claude mcp add --scope user slop -- slop mcp\` (${said.trim() || "the claude command was not found here"})`);
   }
-  const path2 = join13(dir, "settings.json");
-  mkdirSync7(dir, { recursive: true });
+  const path2 = join15(dir, "settings.json");
+  mkdirSync9(dir, { recursive: true });
   const settings = fetchJsonFile(path2);
   settings.hooks = mergeHooks(settings.hooks ?? {}, "claude");
   settings.env = { ...settings.env ?? {}, MCP_TOOL_TIMEOUT: "21600000" };
-  writeFileSync8(path2, `${JSON.stringify(settings, null, 2)}
+  writeFileSync9(path2, `${JSON.stringify(settings, null, 2)}
 `);
   done.push(`Claude Code: SessionStart hook and MCP_TOOL_TIMEOUT written to ${path2}; other slop hooks removed (its session socket wakes it)`);
   return done;
@@ -26403,31 +26631,31 @@ function mergeHooks(hooks, harness) {
 }
 function installIntoCodexHome(dir) {
   const done = [];
-  mkdirSync7(dir, { recursive: true });
-  const configTomlPath = join13(dir, "config.toml");
-  const current = existsSync9(configTomlPath) ? readFileSync14(configTomlPath, "utf8") : "";
+  mkdirSync9(dir, { recursive: true });
+  const configTomlPath = join15(dir, "config.toml");
+  const current = existsSync11(configTomlPath) ? readFileSync16(configTomlPath, "utf8") : "";
   if (/^\[mcp_servers\.slop\]/m.test(current)) {
-    if (/tool_timeout_sec = 1800\b/.test(current)) writeFileSync8(configTomlPath, current.replace(/tool_timeout_sec = 1800\b/, "tool_timeout_sec = 21600"));
+    if (/tool_timeout_sec = 1800\b/.test(current)) writeFileSync9(configTomlPath, current.replace(/tool_timeout_sec = 1800\b/, "tool_timeout_sec = 21600"));
     done.push(`Codex: MCP server already in ${configTomlPath}`);
   } else {
-    writeFileSync8(configTomlPath, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
+    writeFileSync9(configTomlPath, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
 command = "slop"
 args = ["mcp"]
 tool_timeout_sec = 21600
 `);
     done.push(`Codex: MCP server "slop" added to ${configTomlPath}`);
   }
-  const hooksPath = join13(dir, "hooks.json");
+  const hooksPath = join15(dir, "hooks.json");
   const file2 = fetchJsonFile(hooksPath);
   file2.hooks = mergeHooks(file2.hooks ?? {}, "codex");
-  writeFileSync8(hooksPath, `${JSON.stringify(file2, null, 2)}
+  writeFileSync9(hooksPath, `${JSON.stringify(file2, null, 2)}
 `);
   done.push(`Codex: SessionStart hook written to ${hooksPath}; other slop hooks removed (Codex is woken with codex queue; no hook holds a turn open)`);
   return done;
 }
 async function trustCodexHooks(codexHome) {
   const server = spawn3("codex", ["app-server", "-c", "mcp_servers={}"], { stdio: ["pipe", "pipe", "ignore"], env: { ...process.env, CODEX_HOME: codexHome } });
-  const where = codexHome === join13(homedir4(), ".codex") ? "" : ` under ${codexHome}`;
+  const where = codexHome === join15(homedir4(), ".codex") ? "" : ` under ${codexHome}`;
   let buffer = "";
   const pending = /* @__PURE__ */ new Map();
   server.stdout.on("data", (chunk) => {
@@ -26462,7 +26690,7 @@ async function trustCodexHooks(codexHome) {
   const sendNotification = (method, params) => server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   try {
-    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.4.9" }, capabilities: { experimentalApi: true } });
+    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.4.10" }, capabilities: { experimentalApi: true } });
     sendNotification("initialized", {});
     const listed = await callCodexMethod("hooks/list", { cwds: [process.cwd()] });
     const ours = listed.data.flatMap((entry) => entry.hooks).filter((hook) => hook.command?.startsWith("slop hook "));
@@ -26493,7 +26721,7 @@ async function parseHookInput(harness, remember = true) {
     conversation = parsed.session_id ?? null;
   } catch {
   }
-  const ownThread = harness !== "codex" || !conversation || isMainChatThread(fetchCodexHomes().map((home) => join13(home, "sessions")), conversation);
+  const ownThread = harness !== "codex" || !conversation || isMainChatThread(fetchCodexHomes().map((home) => join15(home, "sessions")), conversation);
   if (remember && conversation && ownThread && !isNonInteractiveHarness()) persistRememberedConversation(cwd, { id: conversation, harness: harness ?? "other" });
   return { cwd, conversation };
 }
@@ -26559,12 +26787,12 @@ function buildTools() {
     }
     return context;
   };
-  const runHandlerByName = async (name, args) => {
+  const runHandlerByName = async (name, args, output2) => {
     if (name === "projects") return fetchProjectsOverview(api);
     const project = await resolveProject(api, args.project);
     const handler = requireProjectTools(project).tools.find((candidate) => candidate.name === name);
     if (!handler) throw new Error("No such action");
-    return handler.run(args);
+    return handler.run(args, output2);
   };
   void (async () => {
     for (let waited = 0; waited < 1e4 && !fetchKnownConversation(process.cwd()) && !stopped; waited += 250) await new Promise((resolve6) => setTimeout(resolve6, 250));
@@ -26572,20 +26800,22 @@ function buildTools() {
     await requireProjectTools(await resolveProject(api)).start();
   })().catch(() => void 0);
   const endSessionAndExit = () => {
+    if (stopped) return;
     stopped = true;
     for (const context of projects.values()) context.stop();
-    setTimeout(() => process.exit(0), 300).unref();
+    setTimeout(() => process.exit(process.exitCode ?? 0), 300).unref();
   };
   process.stdin.once("end", endSessionAndExit);
+  process.stdin.once("close", endSessionAndExit);
   for (const signal of ["SIGTERM", "SIGHUP", "SIGINT"]) process.once(signal, endSessionAndExit);
   const buildGroupedTool = (name, description2, actions, properties) => ({
     name,
     description: description2,
     inputSchema: buildToolSchema({ action: { type: "string", enum: Object.keys(actions) }, ...properties, project: PROJECT }, ["action"]),
-    run: (args) => {
+    run: (args, output2) => {
       const target = actions[String(args.action)];
       if (!target) throw new Error(`action must be one of: ${Object.keys(actions).join(", ")}`);
-      return runHandlerByName(target, args);
+      return runHandlerByName(target, args, output2);
     }
   });
   return [
@@ -26625,8 +26855,8 @@ function buildTools() {
 function attachUpdateNoticeToTools(list, version2) {
   return list.map((tool) => ({
     ...tool,
-    run: async (args) => {
-      const result = truncateToolResult(await tool.run(args));
+    run: async (args, output2) => {
+      const result = await tool.run(args, output2);
       const parts = [result];
       const notice = isUpdateCheckEnabled() ? buildUpdateNotice(version2) : null;
       if (notice) parts.push(notice);
@@ -26642,7 +26872,7 @@ function registerMcpCommands(program3, version2) {
     const lines = [...fetchClaudeHomes().flatMap((home) => installIntoClaudeHome(home)), ...homes.flatMap((home) => installIntoCodexHome(home))];
     let codexPresent = true;
     try {
-      execFileSync5("codex", ["--version"], { stdio: "ignore" });
+      execFileSync6("codex", ["--version"], { stdio: "ignore" });
     } catch {
       codexPresent = false;
     }
@@ -26742,13 +26972,13 @@ ${written.map((path2) => `  ${path2}`).join("\n")}`);
 }
 
 // src/index.ts
-var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.4.9").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => updateJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
+var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.4.10").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => updateJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
 registerAuthCommands(program2);
 registerProjectCommands(program2);
 var taskCommand = registerTaskCommands(program2);
 registerSessionCommands(program2);
 registerThreadCommands(program2, taskCommand);
-registerMcpCommands(program2, "0.4.9");
+registerMcpCommands(program2, "0.4.10");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(exitWithError);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopwaresystems",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "private": false,
   "description": "slop: the Slopware Tasks board from the terminal, for people and coding agents.",
   "type": "module",