slopwaresystems 0.4.8 → 0.4.10

package/dist/index.js

@@ -3379,13 +3379,13 @@ 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";
+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';
 
 // skills/slop-sessions.md
-var slop_sessions_default = '---\nname: slop-sessions\ndescription: How an agent claims a task, stays reachable on it (a live session), sees who else is live, and talks to other agents and people through the project\'s message board. Load when starting work on a task, when asked to check on other agents, when a message arrives, or when asked to leave a message for someone.\n---\n\n# Sessions and the board\n\nA **session** is you, live. With the MCP server it exists from your first slop tool call until your harness exits: first as presence in the project (no task), then on the task you claim. Being live means messages find you. Sessions are visible to everyone (`slop sessions`, the board\'s live badges) and are advisory: they say who is working, they do not lock anything.\n\n**Threads** are how agents and people talk across sessions. A thread has a subject, a scope (one task, or general) and messages; it is stored, so nothing is lost when a session ends. **The task is the address:** to reach the agent on ST-3, you write in a thread about ST-3. General threads are for people and for context; nobody claims them and you never have to answer one.\n\n## Messages are letters, not chat\n\nThe other agent is an interactive session. Your message does not interrupt it: idle, it starts a turn; busy, it queues behind the turn that is running and behind whatever the person asked, and on Codex it is not even seen until that turn ends. It is answered when the agent gets to it, which can be seconds or an hour. So:\n\n- **Nothing is read in order.** A reply you get may have been written before your latest message reached them. Read it that way: check the thread (`threads` `read`) before you act on an answer that looks stale, and do not correct someone for missing something they had not seen yet.\n- **One letter, complete.** Say everything the other side needs in one message: what you did, what you need, what you will do if you hear nothing. Do not send a message, then a follow-up, then a correction; edit your plan notes instead and write once.\n- **Several arrived at once? Answer once.** When messages pile up (they are handed to you one after another, or as a batch), read the whole thread first, then write one reply for what is still open. Never answer each one in turn.\n- **Reply only when it changes something.** Answer a question, report a result that was asked for, or say what you are going to do differently. Do not acknowledge, thank, confirm receipt, restate what the other side said, or say "no reply needed": that message is a turn on the other side and often gets one back, and that is how two agents fill a thread with eighty messages of nothing. Silence means "read, nothing to add".\n- **Stale is fine.** A message that arrives after the matter is settled needs no answer. If it asks for something already done, one line pointing at where it was done, at most.\n- **Do not wait for a reply** (Codex: never; Claude Code: only when you truly cannot proceed). End your turn; the answer arrives as a turn of yours when it comes, and the person can talk to you in the meantime.\n\n## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, in **a thread you have written in**, or **addressed to you** reaches you at once. Nothing else does.\n- **Everything else waits.** `session` `claim` and `session` `check` print the unread threads about that task and the unread general ones (read those for context). `threads` `list` lists them any time; `threads` `read` reads one.\n- Your own messages never come back to you.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `session` `claim` with the task. Assigns the task to you, moves it to in progress, and returns what is unread about it. Read that first.\n2. **Work.** Keep the plan\'s notes current with `plan` `note`, tick with `plan` `done`.\n3. **You are live from your first call.** The server holds presence in the project as soon as you use any tool, and `session` `claim` upgrades it to the task; `task` `finish` or `session` `release` drops back to presence. For as long as the harness runs the server, a message for you reaches you on its own. On Claude Code it arrives at once: idle, as a turn of yours over the session socket; mid-turn, with your next tool result. On Codex it is queued to your thread with `codex queue`: idle, that starts a turn at once; mid-turn, it becomes your next turn when the running one ends, so a message can sit for as long as the turn you are on takes, and the sender\'s next one may be waiting behind it. Every slop tool\'s result carries what arrived in the meantime besides. There is nothing to poll and nothing to restart. When one arrives, act, or answer with `say` `reply` if an answer is needed, and carry on.\n4. **Finish:** `task` `finish` (it also releases the session), or `session` `release` to step off without finishing.\n\nNothing is lost at the end of a turn: what arrives while you are idle starts a turn; what arrives while you work is your next turn (Codex) or rides your next tool result (Claude Code).\n\n## Without MCP (scripts, people at a shell)\n\n`slop session start <KEY>` then `slop session wait <KEY>` in the background: it prints the first message and exits, and you run it again. Only for setups with no MCP. The tools above are the way.\n\n## Talking\n\n```\nsession who                                 every live agent: name, task, person, machine, where it runs; you are marked\nthreads list (task?, unread?)               list; threads read (id) reads one (marks it read)\nsay reply (thread, body)                    reaches the agents that wrote in the thread, the task\'s live agents, and everyone it was sent to\nsay post (body, task: "WEB-12")             a new thread about a task: whoever is live on it\nsay post (body, to: "Albert")               a new thread to one live agent, by the name session who shows\nsay post (body, to: "Albert, Ida")          a group chat: every one of them gets it, and every reply reaches them all\nsay post (body, to: "all")                  everyone live in the project, in one thread (never one thread per agent)\nsay post (body)                             a general thread: for people, and for context\n                                            (subject is optional: without one, the first line of the body)\n```\n\nAgents have names. Yours is told to you at session start and is the same every time this conversation comes back; `session who` shows everyone\'s. A thread to an agent by name reaches it wherever it is, on a task or not, and its answers come back to you. If two live agents share a name, use the session id from `session who`.\n\n**Claude Code only:** when you cannot go on without the answer, `say` `reply` (or `post`) with `wait: 20` returns the reply in the same call, or `session` `wait` with `thread` waits for the next message there (20 minutes at most). This is rare; the other agent may not read your letter for a long time. **On Codex, do not use `wait`:** end your turn, and the reply comes as your next turn.\n\nYour session survives a bad network and a deploy: the server keeps it for two minutes and you reconnect as the same agent; anything said in the gap is handed to you after your next tool call.\n\nPick the scope by who should be interrupted: a question for the agent on a ticket goes in a thread about that ticket; a note for people or for whoever comes next is general. Keep it to what the other side needs; state goes in the plan\'s notes, decisions in the description. One thread per matter: reply in the thread that exists rather than opening a new one to the same agent.\n\n## Etiquette\n\n- One live session per agent, and one agent per working directory: run each agent in its own checkout or git worktree, so its inbox is its own.\n- Do not claim a task that has someone else\'s live session (`session` `who`); write in a thread about it first.\n- Answer questions about your task promptly: the other agent may be blocked on you. Answer them once.\n- Report progress in the plan\'s notes, not in threads. Threads are for asking and deciding, not for status.\n- If you stop working on a task, end the session so nobody waits on you.\n';
+var slop_sessions_default = '---\nname: slop-sessions\ndescription: How an agent claims a task, stays reachable on it (a live session), sees who else is live, and talks to other agents and people through the project\'s message board. Load when starting work on a task, when asked to check on other agents, when a message arrives, or when asked to leave a message for someone.\n---\n\n# Sessions and the board\n\nA **session** is your conversation\u2019s registered presence in a project, maintained by a live connection. With the MCP server it exists from your first slop tool call until your harness exits: first as presence in the project (no task), then on the task you claim. Being live means messages find you. Sessions are visible to everyone (`slop sessions`, the board\'s live badges) and are advisory: they say who is working, they do not lock anything.\n\n**Threads** are how agents and people talk across sessions. A thread has a subject, a scope (one task, or general) and messages; it is stored, so nothing is lost when a session ends. **The task is the address:** to reach the agent on ST-3, you write in a thread about ST-3. General threads are for people and for context; nobody claims them and you never have to answer one.\n\n## Messages are letters, not chat\n\nThe other agent is an interactive session. Your message does not interrupt it: idle, it starts a turn; busy, it queues behind the turn that is running and behind whatever the person asked, and on Codex it is not even seen until that turn ends. It is answered when the agent gets to it, which can be seconds or an hour. So:\n\n- **Nothing is read in order.** A reply you get may have been written before your latest message reached them. Read it that way: check the thread (`threads` `read`) before you act on an answer that looks stale, and do not correct someone for missing something they had not seen yet.\n- **One letter, complete.** Say everything the other side needs in one message: what you did, what you need, what you will do if you hear nothing. Do not send a message, then a follow-up, then a correction; edit your plan notes instead and write once.\n- **Several arrived at once? Answer once.** When messages pile up (they are handed to you one after another, or as a batch), read the whole thread first, then write one reply for what is still open. Never answer each one in turn.\n- **Reply only when it changes something.** Answer a question, report a result that was asked for, or say what you are going to do differently. Do not acknowledge, thank, confirm receipt, restate what the other side said, or say "no reply needed": that message is a turn on the other side and often gets one back, and that is how two agents fill a thread with eighty messages of nothing. Silence means "read, nothing to add".\n- **Stale is fine.** A message that arrives after the matter is settled needs no answer. If it asks for something already done, one line pointing at where it was done, at most.\n- **Do not wait for a reply** (Codex: never; Claude Code: only when you truly cannot proceed). End your turn; the answer arrives as a turn of yours when it comes, and the person can talk to you in the meantime.\n\n## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, in **a thread you have written in**, or **addressed to you** reaches you at once. Nothing else does.\n- **Everything else waits.** `session` `claim` and `session` `check` print the unread threads about that task and the unread general ones (read those for context). `threads` `list` lists them any time; `threads` `read` reads one.\n- Your own messages never come back to you.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `session` `claim` with the task. Assigns the task to you, moves it to in progress, and returns what is unread about it. Read that first.\n2. **Work.** Keep the plan\'s notes current with `plan` `note`, tick with `plan` `done`.\n3. **You are live from your first call.** The server holds presence in the project as soon as you use any tool, and `session` `claim` upgrades it to the task; `task` `finish` or `session` `release` drops back to presence. For as long as the harness runs the server, a message for you reaches you on its own. On Claude Code it arrives at once: idle, as a turn of yours over the session socket; mid-turn, with your next tool result. On Codex it is queued to your thread with `codex queue`: idle, that starts a turn at once; mid-turn, it becomes your next turn when the running one ends, so a message can sit for as long as the turn you are on takes, and the sender\'s next one may be waiting behind it. Every slop tool\'s result carries what arrived in the meantime besides. There is nothing to poll and nothing to restart. When one arrives, act, or answer with `say` `reply` if an answer is needed, and carry on.\n4. **Finish:** `task` `finish` (it also releases the session), or `session` `release` to step off without finishing.\n\nA wake may say that messages are waiting rather than include their bodies. Use `session` `check` with the project named in that wake. The content remains queued until a slop tool result hands it over. A failed wake leaves the content for your next tool call.\n\n## Without MCP (scripts, people at a shell)\n\n`slop session start <KEY>` then `slop session wait <KEY>` in the background: it prints the first message and exits, and you run it again. Only for setups with no MCP. The tools above are the way.\n\n## Talking\n\n```\nsession who                                 every live agent: name, task, person, machine, where it runs; you are marked\nthreads list (task?, unread?)               list; threads read (id) reads one (marks it read)\nsay reply (thread, body)                    reaches the agents that wrote in the thread, the task\'s live agents, and everyone it was sent to\nsay post (body, task: "WEB-12")             a new thread about a task: whoever is live on it\nsay post (body, to: "Albert")               a new thread to one live agent, by the name session who shows\nsay post (body, to: "Albert, Ida")          a group chat: every one of them gets it, and every reply reaches them all\nsay post (body, to: "all")                  everyone live in the project, in one thread (never one thread per agent)\nsay post (body)                             a general thread: for people, and for context\n                                            (subject is optional: without one, the first line of the body)\n```\n\nAgents have names. Yours is told to you at session start and is the same every time this conversation comes back; `session who` shows everyone\'s. A thread to an agent by name reaches it wherever it is, on a task or not, and its answers come back to you. If two live agents share a name, use the session id from `session who`.\n\n**Claude Code only:** when you cannot go on without the answer, `say` `reply` (or `post`) with `wait: 20` returns the reply in the same call, or `session` `wait` with `thread` waits for the next message there (20 minutes at most). This is rare; the other agent may not read your letter for a long time. **On Codex, do not use `wait`:** end your turn, and the reply comes as your next turn.\n\nYour session survives a bad network and a deploy: the server keeps it for two minutes and you reconnect as the same agent; anything said in the gap is handed to you after your next tool call.\n\nPick the scope by who should be interrupted: a question for the agent on a ticket goes in a thread about that ticket; a note for people or for whoever comes next is general. Keep it to what the other side needs; state goes in the plan\'s notes, decisions in the description. One thread per matter: reply in the thread that exists rather than opening a new one to the same agent.\n\n## Etiquette\n\n- Each conversation has its own session and inbox in each project. Identified conversations can share a checkout; separate worktrees are still useful for keeping code edits independent.\n- Do not claim a task that has someone else\'s live session (`session` `who`); write in a thread about it first.\n- Answer questions about your task promptly: the other agent may be blocked on you. Answer them once.\n- Report progress in the plan\'s notes, not in threads. Threads are for asking and deciding, not for status.\n- If you stop working on a task, end the session so nobody waits on you.\n';
 
 // skills/slop-working.md
 var slop_working_default = "---\nname: slop-working\ndescription: The working loop for tasks on the board (claim, do, report, finish) and what to record where. Load at the start of any coding session in a repository linked with slop.\n---\n\n# The loop\n\n1. **What is there:** `board` `list` with `mine`, or plain `list`. If nothing is assigned to you, take the top item of the first \"to do\" column.\n2. **Claim it:** `session` `claim`. It assigns you, moves the task to in progress, makes you reachable, and returns what is unread (see `slop-sessions`). Then `task` `show` and read all of it, plan and notes included.\n3. **Do it.** Long work: follow `slop-planning`. Short work: just do it.\n4. **Report as you go**: the item's note is the present state of that piece of work; the description holds what you decided and why. Write in sentences a teammate can act on.\n5. **Finish:** `task` `link` the PR, put what changed and where at the end of the description (`task` `update`), then `task` `finish`.\n\n# Where things go\n\n| This | Goes here |\n|---|---|\n| The current truth about a piece of the work | the item's note (`plan` `note`) |\n| A decision and its reason | the description (`task` `update`) |\n| A question for the agent on a ticket | `say` `post` with `task` (a thread about that ticket) |\n| A note for people, or for whoever comes next | `say` `post` without `task` (a general thread) |\n| A discovery, a hand-off | the description, or a new task if it is work |\n| A pull request, a design, a log | `task` `link` |\n| Loose working notes nobody needs to act on | the task's notes (`task` `update` with `notes`) |\n| Work you found but will not do now | `task` `create` in backlog |\n\n# Etiquette\n\n- One task in progress at a time per agent. `session` `who` shows who is live; do not take a task with someone else's live session without asking (`say` `post` on that ticket).\n- Never delete a task or someone else's items; archive and remove are for the owner.\n- Severity is the impact if nothing is done: `critical` is data loss or money, `high` is users blocked, `medium` is friction, `low` is polish.\n";
@@ -3409,7 +3409,7 @@ function installSkills({ force = false } = {}) {
 }
 
 // src/commands/auth.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { platform as platform2 } from "os";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
@@ -8438,7 +8438,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve5) {
+function isRecursive(inst, stack, resolve6) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -8448,7 +8448,7 @@ function isRecursive(inst, stack, resolve5) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve5);
+      const answer = isRecursive(child, stack, resolve6);
       if (answer > result)
         result = answer;
     }
@@ -8459,7 +8459,7 @@ function isRecursive(inst, stack, resolve5) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve6) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -8523,7 +8523,7 @@ function isRecursive(inst, stack, resolve5) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve6 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -23486,11 +23486,13 @@ var SessionClaimInput = external_exports.object({
 });
 var ConnectTicket = external_exports.object({ ticket: external_exports.string(), path: external_exports.string() });
 var AskInput = external_exports.object({ body: external_exports.string().trim().min(1, "Say something").max(4e3) });
+var ThreadPush = external_exports.object({ thread: external_exports.object({ id: Id, subject: external_exports.string(), taskKey: external_exports.string().nullable(), to: external_exports.string().nullable().optional() }), message: ThreadMessage });
+var ThreadSessionPush = ThreadPush.extend({ type: external_exports.literal("thread") });
 var SessionPush = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("hello"), session: Session }),
   external_exports.object({ type: external_exports.literal("event"), record: TaskEventRecord }),
   /** A message in a thread about the task this session is on. */
-  external_exports.object({ type: external_exports.literal("thread"), thread: external_exports.object({ id: Id, subject: external_exports.string(), taskKey: external_exports.string().nullable(), to: external_exports.string().nullable().optional() }), message: ThreadMessage }),
+  ThreadSessionPush,
   /** The room is closing this session (someone ran `slop session end`). */
   external_exports.object({ type: external_exports.literal("end") }),
   /** Reachability was switched from the web. Off releases a waiting agent: nothing can reach it any more. */
@@ -23498,6 +23500,12 @@ var SessionPush = external_exports.discriminatedUnion("type", [
   /** To board watchers: something in the project changed; refetch. */
   external_exports.object({ type: external_exports.literal("changed"), scope: external_exports.string() })
 ]);
+var SessionMessagesInput = external_exports.object({ cursor: external_exports.coerce.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional() });
+var SessionMessages = external_exports.object({
+  cursor: external_exports.number().int().nonnegative(),
+  hasMore: external_exports.boolean(),
+  pushes: external_exports.array(ThreadSessionPush)
+});
 
 // ../contract/src/work/agent-names.ts
 var AGENT_NAMES = [
@@ -23862,6 +23870,7 @@ var ApiResponses = {
   Bindings: external_exports.array(Binding),
   ConnectTicket,
   Sessions: external_exports.array(Session),
+  SessionMessages,
   EndedSessions: external_exports.object({ ended: external_exports.number().int().nonnegative() }),
   ReachableSession: external_exports.object({ ok: external_exports.literal(true), reachable: external_exports.boolean() }),
   Threads: external_exports.array(Thread),
@@ -23924,6 +23933,7 @@ registerResponseContract("POST", ["/projects/:projectId/bindings"], ApiResponses
 registerResponseContract("POST", ["/projects/:projectId/watch/ticket", "/projects/:projectId/session/ticket", "/projects/:projectId/tasks/:ref/session/ticket"], ApiResponses.ConnectTicket);
 registerResponseContract("POST", ["/projects/:projectId/session/end", "/projects/:projectId/tasks/:ref/session/end"], ApiResponses.EndedSessions);
 registerResponseContract("GET", ["/projects/:projectId/sessions"], ApiResponses.Sessions);
+registerResponseContract("GET", ["/projects/:projectId/session/messages"], ApiResponses.SessionMessages);
 registerResponseContract("POST", ["/projects/:projectId/sessions/:id/reachable"], ApiResponses.ReachableSession);
 registerResponseContract("GET", ["/orgs/:orgId/threads"], ApiResponses.ProjectThreads);
 registerResponseContract("GET", ["/projects/:projectId/threads"], ApiResponses.Threads);
@@ -23941,6 +23951,9 @@ function assertApiResponseContract(method, path2, schema) {
   if (requireApiResponseSchema(method, path2) !== schema) throw new Error("The response contract does not match this API endpoint");
 }
 
+// src/platform/api.ts
+import { resolve as resolve5 } from "path";
+
 // src/platform/config.ts
 import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -23975,43 +23988,100 @@ function resolveSession() {
 }
 
 // src/platform/session-file.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-var buildSessionsDir = () => join3(dirname2(buildConfigPath()), "sessions");
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync3, realpathSync as realpathSync2, rmSync as rmSync3, statSync, readdirSync } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/platform/local-state.ts
+import { createHash, randomUUID } from "crypto";
+import { linkSync, mkdirSync as mkdirSync3, realpathSync, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, resolve } from "path";
+function generateLocalStateKey(cwd, owner) {
+  let directory = resolve(cwd);
+  try {
+    directory = realpathSync(directory);
+  } catch {
+  }
+  return createHash("sha256").update(owner === void 0 ? directory : JSON.stringify([directory, owner])).digest("hex").slice(0, 32);
+}
+function persistLocalState(path2, text, overwrite = true) {
+  mkdirSync3(dirname2(path2), { recursive: true });
+  const temporary = `${path2}.${randomUUID()}.writing`;
+  try {
+    writeFileSync3(temporary, text, { flag: "wx", mode: 384 });
+    if (overwrite) renameSync(temporary, path2);
+    else {
+      try {
+        linkSync(temporary, path2);
+      } catch (error62) {
+        if (error62.code !== "EEXIST") throw error62;
+      }
+    }
+  } finally {
+    rmSync2(temporary, { force: true });
+  }
+}
+
+// src/platform/session-file.ts
+var buildSessionsDir = () => join3(dirname3(buildConfigPath()), "sessions");
 var resolveRealCwd = (cwd) => {
   try {
-    return realpathSync(cwd);
+    return realpathSync2(cwd);
   } catch {
     return cwd;
   }
 };
-var buildSessionPath = (cwd) => join3(buildSessionsDir(), `${createHash("sha256").update(resolveRealCwd(cwd)).digest("hex").slice(0, 16)}.txt`);
-function persistRememberedSession(cwd, sessionId) {
-  mkdirSync3(buildSessionsDir(), { recursive: true });
-  if (sessionId) writeFileSync3(buildSessionPath(cwd), sessionId);
-  else rmSync2(buildSessionPath(cwd), { force: true });
+var buildSessionPath = (cwd, conversation) => conversation ? join3(buildSessionsDir(), `${generateLocalStateKey(cwd, conversation)}.txt`) : join3(buildSessionsDir(), `${createHash2("sha256").update(resolveRealCwd(cwd)).digest("hex").slice(0, 16)}.txt`);
+function persistRememberedSession(cwd, sessionId, conversation) {
+  if (sessionId) persistLocalState(buildSessionPath(cwd, conversation), sessionId);
+  else rmSync3(buildSessionPath(cwd, conversation), { force: true });
 }
-function fetchRememberedSession(cwd) {
-  const path2 = buildSessionPath(cwd);
-  return existsSync3(path2) ? readFileSync3(path2, "utf8").trim() || null : null;
+function fetchRememberedSession(cwd, conversation) {
+  try {
+    return readFileSync3(buildSessionPath(cwd, conversation), "utf8").trim() || null;
+  } catch (error62) {
+    if (error62.code === "ENOENT") return null;
+    throw error62;
+  }
 }
-var buildConversationPath = (cwd) => join3(buildSessionsDir(), `${createHash("sha256").update(resolveRealCwd(cwd)).digest("hex").slice(0, 16)}.conversation.json`);
+var buildConversationPath = (cwd) => join3(buildSessionsDir(), `${createHash2("sha256").update(resolveRealCwd(cwd)).digest("hex").slice(0, 16)}.conversation.json`);
 function persistRememberedConversation(cwd, conversation) {
-  mkdirSync3(buildSessionsDir(), { recursive: true });
-  writeFileSync3(buildConversationPath(cwd), JSON.stringify(conversation));
+  const directory = `${buildConversationPath(cwd)}.d`;
+  persistLocalState(join3(directory, `${generateLocalStateKey(cwd, conversation.id)}.json`), JSON.stringify(conversation));
 }
 function fetchRememberedConversation(cwd, notBefore) {
   const path2 = buildConversationPath(cwd);
+  const candidates = [];
+  let paths;
   try {
-    if (statSync(path2).mtimeMs < notBefore) return null;
-    const parsed = JSON.parse(readFileSync3(path2, "utf8"));
-    return typeof parsed.id === "string" && parsed.id ? { id: parsed.id, harness: parsed.harness ?? "other" } : null;
+    paths = readdirSync(`${path2}.d`).map((name) => join3(`${path2}.d`, name));
   } catch {
-    return null;
+    paths = [path2];
+  }
+  for (const candidate of paths) {
+    if (candidate.endsWith(".writing")) continue;
+    try {
+      if (statSync(candidate).mtimeMs < notBefore) continue;
+      const parsed = JSON.parse(readFileSync3(candidate, "utf8"));
+      const harness = AgentHarness.safeParse(parsed.harness ?? "other");
+      if (typeof parsed.id === "string" && parsed.id && harness.success) candidates.push({ id: parsed.id, harness: harness.data });
+    } catch {
+    }
   }
+  const distinct = [...new Map(candidates.map((candidate) => [candidate.id, candidate])).values()];
+  return distinct.length === 1 ? distinct[0] : null;
 }
 
+// src/platform/agent-identity.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { basename as basename3, join as join8, resolve as resolve4 } from "path";
+
+// src/platform/git.ts
+import { execFileSync } from "child_process";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { basename, join as join4, resolve as resolve2 } from "path";
+
 // src/platform/errors.ts
 var CliError = class extends Error {
   constructor(message, hint, code = "error", exitCode = 1) {
@@ -24025,185 +24095,683 @@ var CliError = class extends Error {
   exitCode;
 };
 
-// src/platform/api.ts
-function buildApiClient(options) {
-  async function sendApiRequest(method, path2, schema, body2) {
-    try {
-      assertApiResponseContract(method, path2, schema);
-    } catch {
-      throw new CliError("This request does not match the API contract", "Update slop to the latest version", "internal");
-    }
-    const headers = { accept: "application/json" };
-    if (body2 !== void 0) headers["content-type"] = "application/json";
-    if (options.token) headers.authorization = `Bearer ${options.token}`;
-    if (client.sessionId) headers["x-slop-session"] = client.sessionId;
-    let response;
-    try {
-      response = await fetch(`${options.baseUrl}/api${path2}`, {
-        method,
-        headers,
-        body: body2 === void 0 ? void 0 : JSON.stringify(body2),
-        signal: AbortSignal.timeout(2e4)
-      });
-    } catch (error62) {
-      const reason = error62 instanceof Error && error62.name === "TimeoutError" ? "timed out" : "is unreachable";
-      throw new CliError(`${options.baseUrl} ${reason}`, void 0, "network");
-    }
-    const text = await response.text();
-    if (response.ok) {
-      try {
-        return schema.parse(JSON.parse(text));
-      } catch {
-        throw new CliError("The server returned an incompatible response", "Update slop to the latest version", "internal");
-      }
-    }
-    let parsed = null;
-    try {
-      parsed = ApiErrorBody.safeParse(JSON.parse(text));
-    } catch {
-    }
-    if (parsed?.success) {
-      const { code, message } = parsed.data.error;
-      throw new CliError(message, code === "unauthenticated" ? "slop login" : void 0, code);
-    }
-    throw new CliError(`${method} ${path2} failed with HTTP ${response.status}`, void 0, "http");
-  }
-  const client = {
-    baseUrl: options.baseUrl,
-    sessionId: null,
-    get: (path2, schema) => sendApiRequest("GET", path2, schema),
-    post: (path2, schema, body2) => sendApiRequest("POST", path2, schema, body2 ?? {}),
-    patch: (path2, schema, body2) => sendApiRequest("PATCH", path2, schema, body2),
-    put: (path2, schema, body2) => sendApiRequest("PUT", path2, schema, body2),
-    delete: (path2, schema) => sendApiRequest("DELETE", path2, schema)
-  };
-  return client;
-}
-function buildAuthedApiClient() {
-  const session = resolveSession();
-  if (!session.token) throw new CliError(`Not signed in to ${session.baseUrl}`, "slop login", "unauthenticated");
-  const client = buildApiClient(session);
-  client.sessionId = fetchRememberedSession(process.cwd());
-  return client;
-}
-
-// src/platform/machine.ts
-import { execFileSync } from "child_process";
-import { createHash as createHash2, randomUUID } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { hostname as hostname3, platform, userInfo } from "os";
-import { dirname as dirname3, join as join4 } from "path";
-function runCommand(command, args) {
+// src/platform/git.ts
+function runGit(args, cwd = process.cwd()) {
   try {
-    return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return null;
   }
 }
-function fetchOsMachineId() {
-  switch (platform()) {
-    case "darwin":
-      return /"IOPlatformUUID" = "([^"]+)"/.exec(runCommand("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]) ?? "")?.[1] ?? null;
-    case "linux":
-      for (const path2 of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-        if (existsSync4(path2)) return readFileSync4(path2, "utf8").trim() || null;
-      }
-      return null;
-    case "win32":
-      return /MachineGuid\s+REG_SZ\s+(\S+)/.exec(
-        runCommand("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"]) ?? ""
-      )?.[1] ?? null;
-    default:
-      return null;
-  }
+function fetchRepo() {
+  const commonDir = runGit(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (!commonDir) return null;
+  const worktree = runGit(["rev-parse", "--show-toplevel"]);
+  const root = basename(commonDir) === ".git" ? resolve2(commonDir, "..") : worktree ?? commonDir;
+  return { root, worktree: worktree ?? root, linkPath: join4(commonDir, "slop.json") };
 }
-function resolvePersistedMachineId() {
-  const path2 = join4(dirname3(buildConfigPath()), "machine-id");
-  if (existsSync4(path2)) return readFileSync4(path2, "utf8").trim();
-  const id = randomUUID();
-  mkdirSync4(dirname3(path2), { recursive: true, mode: 448 });
-  writeFileSync4(path2, `${id}
-`, { mode: 384 });
-  return id;
+function fetchCurrentBranch(cwd = process.cwd()) {
+  const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  return branch && branch !== "HEAD" ? branch : null;
 }
-function buildMachineInfo() {
-  const raw = `${fetchOsMachineId() ?? resolvePersistedMachineId()}:${userInfo().username}`;
-  return {
-    fingerprint: createHash2("sha256").update(raw).digest("hex"),
-    name: hostname3().replace(/\.local$/, ""),
-    platform: platform()
-  };
+function requireRepo() {
+  const repo = fetchRepo();
+  if (!repo) throw new CliError("Not inside a git repository", "cd into your repository, or pass --project KEY", "no_repo");
+  return repo;
 }
-
-// src/platform/output.ts
-var jsonMode = false;
-var updateJsonMode = (on) => {
-  jsonMode = on;
-};
-var isJsonMode = () => jsonMode;
-function emitOutput(value, human) {
-  process.stdout.write(jsonMode ? `${JSON.stringify(value, null, 2)}
-` : `${human()}
-`);
+function fetchRepoLink(repo) {
+  try {
+    return JSON.parse(readFileSync4(repo.linkPath, "utf8"));
+  } catch {
+    return null;
+  }
 }
-function exitWithError(error62) {
-  const cli = error62 instanceof CliError ? error62 : null;
-  const message = error62 instanceof Error ? error62.message : String(error62);
-  if (jsonMode) {
-    process.stderr.write(`${JSON.stringify({ error: { code: cli?.code ?? "error", message, hint: cli?.hint } })}
-`);
-  } else {
-    process.stderr.write(`error: ${message}
-`);
-    if (cli?.hint) process.stderr.write(`  try: ${cli.hint}
+function persistRepoLink(repo, link) {
+  writeFileSync4(repo.linkPath, `${JSON.stringify(link, null, 2)}
 `);
-  }
-  process.exit(cli?.exitCode ?? 1);
 }
-function formatTable(rows) {
-  const widths = [];
-  for (const row of rows) row.forEach((cell, index) => widths[index] = Math.max(widths[index] ?? 0, cell.length));
-  return rows.map((row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index])).join("  ")).join("\n");
+function deleteTaskLink(repo) {
+  if (existsSync3(repo.linkPath)) rmSync4(repo.linkPath);
 }
-var formatStatusLabel = (statuses, key) => statuses.find((status) => status.key === key)?.label ?? key;
-var formatTaskLine = (statuses) => (task) => [
-  task.key,
-  formatStatusLabel(statuses, task.status),
-  TASK_SEVERITY_LABELS[task.severity],
-  task.assignee?.name ?? "-",
-  task.title
-];
-function formatTaskDetail(task, url2, statuses) {
-  const lines = [
-    `${task.key}  ${task.title}`,
-    `status: ${formatStatusLabel(statuses, task.status)}   severity: ${TASK_SEVERITY_LABELS[task.severity]}   assignee: ${task.assignee?.name ?? "nobody"}   by: ${task.createdBy.name}`,
-    url2
-  ];
-  if (task.links.length > 0) lines.push(`links: ${task.links.map((link) => `${link.title} <${link.url}>`).join(", ")}`);
-  if (task.archivedAt) lines.push("archived");
-  if (task.items.length > 0) {
-    lines.push("", `plan  ${task.progress.done}/${task.progress.total} done`);
-    task.items.forEach((item, index) => lines.push(`  ${index + 1}. [${item.done ? "x" : " "}] ${item.title}${item.note ? `  (${item.note.split("\n")[0]})` : ""}`));
+function normalizeRemoteUrl(url2) {
+  const scp = /^[^@/]+@([^:/]+):(.+)$/.exec(url2);
+  const bare = scp ? `${scp[1]}/${scp[2]}` : url2.replace(/^[a-z+]+:\/\//i, "").replace(/^[^@/]+@/, "");
+  return bare.replace(/\.git$/, "").replace(/\/+$/, "");
+}
+function buildRepoDescription(repo, existing) {
+  const roots = runGit(["rev-list", "--max-parents=0", "HEAD"], repo.root);
+  const remote = runGit(["remote", "get-url", "origin"], repo.root);
+  const remoteUrl = remote ? normalizeRemoteUrl(remote) : null;
+  let fingerprint;
+  let localRepoId;
+  if (roots) {
+    fingerprint = createHash3("sha256").update(roots.split("\n").sort().join("\n")).digest("hex");
+  } else {
+    localRepoId = existing?.localRepoId ?? randomUUID2();
+    fingerprint = `local:${localRepoId}`;
   }
-  if (task.description) lines.push("", task.description);
-  if (task.notes) lines.push("", "notes:", task.notes);
-  return lines.join("\n");
+  return {
+    info: { fingerprint, name: remoteUrl?.split("/").slice(-1)[0] ?? basename(repo.root), remoteUrl, rootPath: repo.root },
+    localRepoId
+  };
 }
 
-// src/commands/auth.ts
-function openBrowser(url2) {
-  const [command, args] = platform2() === "darwin" ? ["open", [url2]] : platform2() === "win32" ? ["cmd", ["/c", "start", "", url2]] : ["xdg-open", [url2]];
+// src/platform/harness.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { closeSync, openSync, readdirSync as readdirSync3, readSync, readlinkSync, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { basename as basename2, join as join7 } from "path";
+
+// src/platform/harness-wake.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+import { connect } from "net";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/platform/homes.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5, resolve as resolve3 } from "path";
+var deduplicateStrings = (paths) => [...new Set(paths.map((path2) => resolve3(path2)))];
+function fetchAncestorEnvironments() {
+  if (process.platform === "win32") return [];
+  const seen = [];
   try {
-    spawn(command, args, { stdio: "ignore", detached: true }).on("error", () => {
-    }).unref();
+    if (process.platform === "linux") {
+      let pid2 = process.ppid;
+      for (let hop = 0; hop < 6 && pid2 > 1; hop += 1) {
+        seen.push(readFileSync5(`/proc/${pid2}/environ`, "latin1").replace(/\0/g, " "));
+        const stat = readFileSync5(`/proc/${pid2}/stat`, "utf8");
+        pid2 = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      }
+      for (const entry of readdirSync2("/proc")) {
+        if (!/^\d+$/.test(entry)) continue;
+        try {
+          seen.push(readFileSync5(`/proc/${entry}/environ`, "latin1").replace(/\0/g, " "));
+        } catch {
+        }
+      }
+      return seen;
+    }
+    const runPs = (args) => execFileSync2("ps", args, { encoding: "utf8", maxBuffer: 64 << 20, stdio: ["ignore", "pipe", "ignore"] });
+    let pid = process.ppid;
+    for (let hop = 0; hop < 6 && pid > 1; hop += 1) {
+      seen.push(runPs(["eww", "-o", "command=", "-p", String(pid)]));
+      pid = Number(runPs(["-o", "ppid=", "-p", String(pid)]).trim());
+    }
+    seen.push(runPs(["axeww", "-o", "command="]));
   } catch {
   }
+  return seen;
 }
-var waitForMilliseconds = (ms) => new Promise((done) => setTimeout(done, ms));
-var isHeadless = () => Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY) || platform2() === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
-function registerAuthCommands(program3) {
-  program3.command("login").description("Sign this machine in. Opens the web app, where you approve the login. On a VM or over SSH, open the printed link on any device.").option("--url <url>", "the Slopware Tasks instance to sign in to").option("--no-browser", "print the link instead of opening it").action(async (options) => {
-    const baseUrl = (options.url || process.env.SLOP_URL || fetchConfig()?.baseUrl || DEFAULT_URL).replace(/\/+$/, "");
+var environments = null;
+function findHomesInUse(variable) {
+  environments ??= fetchAncestorEnvironments();
+  const found = [];
+  const pattern = new RegExp(`(?:^|\\s)${variable}=(\\S+)`, "g");
+  for (const text of environments) for (const match of text.matchAll(pattern)) found.push(match[1] ?? "");
+  return found.filter(Boolean);
+}
+var findDirectoriesNamed = (root, prefix) => {
+  try {
+    return readdirSync2(root, { withFileTypes: true }).filter((entry) => entry.name.startsWith(prefix) && (entry.isDirectory() || entry.isSymbolicLink())).map((entry) => join5(root, entry.name)).filter((path2) => {
+      try {
+        return statSync2(path2).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+};
+var hasAnyEntry = (dir, files) => files.some((file2) => existsSync4(join5(dir, file2)));
+function fetchClaudeHomes(root = homedir3(), inUse = findHomesInUse) {
+  if (process.env.SLOP_CLAUDE_HOME) return [process.env.SLOP_CLAUDE_HOME];
+  const named = process.env.CLAUDE_CONFIG_DIR ? [process.env.CLAUDE_CONFIG_DIR] : [];
+  return deduplicateStrings([join5(root, ".claude"), ...named, ...inUse("CLAUDE_CONFIG_DIR"), ...findDirectoriesNamed(root, ".claude").filter((dir) => hasAnyEntry(dir, ["settings.json", ".claude.json", "sessions"]))]);
+}
+function fetchCodexHomes(root = homedir3(), inUse = findHomesInUse) {
+  if (process.env.SLOP_CODEX_HOME) return [process.env.SLOP_CODEX_HOME];
+  const named = process.env.CODEX_HOME ? [process.env.CODEX_HOME] : [];
+  return deduplicateStrings([join5(root, ".codex"), ...named, ...inUse("CODEX_HOME"), ...findDirectoriesNamed(root, ".codex").filter((dir) => hasAnyEntry(dir, ["config.toml", "auth.json", "sessions"]))]);
+}
+function resolveOwnHarnessHome(variable) {
+  if (process.platform === "win32") return null;
+  try {
+    let pid = process.ppid;
+    for (let hop = 0; hop < 6 && pid > 1; hop += 1) {
+      const text = process.platform === "linux" ? readFileSync5(`/proc/${pid}/environ`, "latin1").replace(/\0/g, " ") : execFileSync2("ps", ["eww", "-o", "command=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      const match = new RegExp(`(?:^|\\s)${variable}=(\\S+)`).exec(text);
+      if (match?.[1]) return resolve3(match[1]);
+      if (process.platform === "linux") {
+        const stat = readFileSync5(`/proc/${pid}/stat`, "utf8");
+        pid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      } else pid = Number(execFileSync2("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/platform/harness-wake.ts
+function fetchHarnessRegistration(pid = process.ppid) {
+  for (const home of fetchClaudeHomes()) {
+    const path2 = join6(home, "sessions", `${pid}.json`);
+    if (!existsSync5(path2)) continue;
+    try {
+      return JSON.parse(readFileSync6(path2, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function resolveClaudeSession(pid = Number(process.env.SLOP_HARNESS_PID) || process.ppid) {
+  const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+  if (sessionId) {
+    const registration2 = fetchHarnessRegistration(pid);
+    return { sessionId, socketPath: process.env.CLAUDE_CODE_MESSAGING_SOCKET || (registration2?.sessionId === sessionId ? registration2.messagingSocketPath : null) || null };
+  }
+  const registration = fetchHarnessRegistration(pid);
+  return registration?.sessionId ? { sessionId: registration.sessionId, socketPath: registration.messagingSocketPath ?? null } : null;
+}
+function wakeHarness(text, pid = Number(process.env.SLOP_HARNESS_PID) || process.ppid, expectedSessionId) {
+  const session = resolveClaudeSession(pid);
+  if (!session?.socketPath || expectedSessionId && session.sessionId !== expectedSessionId) return Promise.resolve(false);
+  const frame = {
+    uuid: randomUUID3(),
+    session_id: session.sessionId,
+    type: "user",
+    parent_tool_use_id: null,
+    message: { role: "user", content: text }
+  };
+  return new Promise((resolve6) => {
+    const socket = connect({ path: session.socketPath });
+    const finishWake = (ok) => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve6(ok);
+    };
+    const timer = setTimeout(() => finishWake(false), 3e3);
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(frame)}
+`, (error62) => error62 ? finishWake(false) : setTimeout(() => finishWake(true), 200));
+    });
+    socket.on("error", () => finishWake(false));
+  });
+}
+function wakeCodex(text, threadId, options = {}) {
+  const endpoint = process.env.SLOP_CODEX_APP_SERVER;
+  if (endpoint) return wakeCodexOverWs(text, threadId, endpoint);
+  return new Promise((resolve6) => {
+    let child;
+    try {
+      child = spawn(options.binary ?? "codex", ["queue", "--thread", threadId, "--message", text], {
+        env: options.codexHome ? { ...process.env, CODEX_HOME: options.codexHome } : process.env,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+    } catch {
+      resolve6(false);
+      return;
+    }
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve6(false);
+    }, 15e3);
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve6(false);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve6(code === 0);
+    });
+  });
+}
+function wakeCodexOverWs(text, threadId, endpoint) {
+  return new Promise((resolve6) => {
+    let socket;
+    try {
+      socket = new WebSocket(endpoint);
+    } catch {
+      resolve6(false);
+      return;
+    }
+    let finished = false;
+    let nextId = 1;
+    const pending = /* @__PURE__ */ new Map();
+    const finishWake = (ok) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      for (const reply of pending.values()) reply({ error: "connection ended" });
+      pending.clear();
+      try {
+        socket.close();
+      } catch {
+      }
+      resolve6(ok);
+    };
+    const timer = setTimeout(() => finishWake(false), 8e3);
+    const callCodexMethod = (method, params) => new Promise((ok, fail) => {
+      if (finished) {
+        fail(new Error("connection ended"));
+        return;
+      }
+      const id = nextId++;
+      pending.set(id, (message) => message.error ? fail(new Error(method)) : ok(message.result));
+      socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+    socket.addEventListener("error", () => finishWake(false));
+    socket.addEventListener("close", () => finishWake(false));
+    socket.addEventListener("message", (event) => {
+      if (finished) return;
+      try {
+        const message = JSON.parse(String(event.data));
+        if (typeof message.id === "number") {
+          const reply = pending.get(message.id);
+          pending.delete(message.id);
+          reply?.(message);
+        }
+      } catch {
+      }
+    });
+    socket.addEventListener("open", () => {
+      if (finished) return;
+      void (async () => {
+        try {
+          await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0" }, capabilities: { experimentalApi: true } });
+          socket.send(JSON.stringify({ jsonrpc: "2.0", method: "initialized", params: {} }));
+          const loaded = await callCodexMethod("thread/loaded/list", {});
+          if (!loaded.data.includes(threadId)) {
+            finishWake(false);
+            return;
+          }
+          await callCodexMethod("turn/start", { threadId, input: [{ type: "text", text }] });
+          finishWake(true);
+        } catch {
+          finishWake(false);
+        }
+      })();
+    });
+  });
+}
+
+// src/platform/harness.ts
+var parent = null;
+function fetchParentCommand() {
+  if (parent !== null) return parent;
+  try {
+    parent = process.platform === "win32" ? "" : execFileSync3("ps", ["-o", "command=", "-p", String(process.ppid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    parent = "";
+  }
+  return parent;
+}
+function parseHarnessFromCommand(command) {
+  const first = basename2(command.trim().split(/\s+/)[0] ?? "");
+  if (/^claude(\b|$)/.test(first)) return "claude";
+  if (/^codex(\b|$)/.test(first)) return "codex";
+  if (/(^|\/)codex(\S*)?\s/.test(command)) return "codex";
+  return null;
+}
+function isNonInteractiveCommand(command) {
+  return /(^|[\s/])codex(\S*)?\s+exec(\s|$)/.test(command);
+}
+function isNonInteractiveHarness() {
+  return isNonInteractiveCommand(fetchParentCommand());
+}
+var isSamePath = (a, b) => {
+  const resolveRealPath = (path2) => {
+    try {
+      return realpathSync3(path2);
+    } catch {
+      return path2;
+    }
+  };
+  return resolveRealPath(a) === resolveRealPath(b);
+};
+function isMainChatRollout(sessionMetaLine) {
+  if (!sessionMetaLine.includes('"session_meta"')) return false;
+  if (/"parent_thread_id"\s*:\s*"/.test(sessionMetaLine)) return false;
+  const source = /"source"\s*:\s*("([^"]*)"|\{)/.exec(sessionMetaLine);
+  if (!source) return true;
+  if (source[1] === "{") return false;
+  return source[2] !== "exec";
+}
+function fetchCodexConversationByCwd(roots, cwd) {
+  const rollouts = [];
+  const findRolloutsInDirectory = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path2 = join7(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 3) findRolloutsInDirectory(path2, depth + 1);
+        continue;
+      }
+      const match = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(entry.name);
+      if (!match) continue;
+      try {
+        rollouts.push({ path: path2, id: match[1] ?? "", mtime: statSync3(path2).mtimeMs });
+      } catch {
+      }
+    }
+  };
+  for (const root of roots) findRolloutsInDirectory(root, 0);
+  rollouts.sort((a, b) => b.mtime - a.mtime);
+  const matching = /* @__PURE__ */ new Set();
+  for (const rollout of rollouts) {
+    let head = "";
+    try {
+      const fd = openSync(rollout.path, "r");
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        head = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString("utf8");
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+      continue;
+    }
+    const line = head.split("\n")[0] ?? "";
+    if (!line.includes('"session_meta"')) continue;
+    if (!isMainChatRollout(line)) continue;
+    const found = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(line);
+    if (!found) continue;
+    let dir;
+    try {
+      dir = JSON.parse(`"${found[1]}"`);
+    } catch {
+      continue;
+    }
+    if (isSamePath(dir, cwd)) matching.add(rollout.id);
+    if (matching.size > 1) return null;
+  }
+  return matching.size === 1 ? [...matching][0] : null;
+}
+function isMainChatThread(roots, threadId) {
+  const path2 = fetchCodexRolloutPath(roots, threadId);
+  if (!path2) return true;
+  try {
+    const fd = openSync(path2, "r");
+    try {
+      const buffer = Buffer.alloc(64 * 1024);
+      const head = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString("utf8");
+      return isMainChatRollout(head.split("\n")[0] ?? "");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return true;
+  }
+}
+function fetchCodexRolloutPath(roots, threadId) {
+  const suffix = `-${threadId}.jsonl`;
+  let best = null;
+  const findRolloutInDirectory = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path2 = join7(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 3) findRolloutInDirectory(path2, depth + 1);
+        continue;
+      }
+      if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(suffix)) continue;
+      try {
+        const mtime = statSync3(path2).mtimeMs;
+        if (!best || mtime > best.mtime) best = { path: path2, mtime };
+      } catch {
+      }
+    }
+  };
+  for (const root of roots) findRolloutInDirectory(root, 0);
+  return best ? best.path : null;
+}
+function resolveCodexBinary() {
+  try {
+    execFileSync3(process.platform === "win32" ? "where" : "which", ["codex"], { stdio: "ignore" });
+    return "codex";
+  } catch {
+  }
+  if (parseHarnessFromCommand(fetchParentCommand()) === "codex" && process.platform !== "win32") {
+    try {
+      const exe = process.platform === "linux" ? readlinkSync(`/proc/${process.ppid}/exe`) : execFileSync3("ps", ["-o", "comm=", "-p", String(process.ppid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      if (exe && basename2(exe).startsWith("codex")) return exe;
+    } catch {
+    }
+  }
+  return "codex";
+}
+function fetchHarnessConversation(cwd) {
+  const explicit = process.env.SLOP_CONVERSATION_ID?.trim();
+  if (explicit) return { id: explicit, harness: process.env.SLOP_HARNESS === "codex" ? "codex" : process.env.SLOP_HARNESS === "claude" ? "claude" : "other" };
+  if (process.env.CODEX_THREAD_ID?.trim()) return { id: process.env.CODEX_THREAD_ID.trim(), harness: "codex" };
+  if (process.env.CLAUDE_CODE_SESSION_ID?.trim()) return { id: process.env.CLAUDE_CODE_SESSION_ID.trim(), harness: "claude" };
+  const harness = parseHarnessFromCommand(fetchParentCommand());
+  if (harness === "claude") {
+    const id = resolveClaudeSession()?.sessionId;
+    return id ? { id, harness } : null;
+  }
+  if (harness === "codex" && !isNonInteractiveHarness()) {
+    const id = fetchCodexConversationByCwd(fetchCodexHomes().map((home) => join7(home, "sessions")), cwd);
+    return id ? { id, harness } : null;
+  }
+  return null;
+}
+
+// src/platform/agent-identity.ts
+var processConversation = randomUUID4();
+var startedAt = Date.now();
+function fetchKnownConversation(cwd) {
+  const own2 = fetchHarnessConversation(cwd);
+  if (own2) return own2;
+  const remembered = fetchRememberedConversation(cwd, startedAt - 12e4);
+  if (remembered?.harness === "codex" && isMainChatThread(fetchCodexHomes().map((home) => join8(home, "sessions")), remembered.id)) return remembered;
+  return remembered?.harness === "codex" ? null : remembered;
+}
+function resolveAgentIdentity(cwd, fallback = "process") {
+  const conversation = fetchKnownConversation(cwd);
+  const repo = fetchRepo();
+  return {
+    conversation: conversation?.id ?? (fallback === "process" ? processConversation : `dir:${resolve4(cwd)}`),
+    harness: conversation?.harness ?? null,
+    directory: repo ? basename3(repo.worktree) : basename3(cwd),
+    branch: fetchCurrentBranch(cwd)
+  };
+}
+
+// src/platform/api.ts
+function buildApiClient(options) {
+  async function sendApiRequest(method, path2, schema, body2) {
+    try {
+      assertApiResponseContract(method, path2, schema);
+    } catch {
+      throw new CliError("This request does not match the API contract", "Update slop to the latest version", "internal");
+    }
+    const headers = { accept: "application/json" };
+    if (body2 !== void 0) headers["content-type"] = "application/json";
+    if (options.token) headers.authorization = `Bearer ${options.token}`;
+    if (client.sessionId) headers["x-slop-session"] = client.sessionId;
+    let response;
+    try {
+      response = await fetch(`${options.baseUrl}/api${path2}`, {
+        method,
+        headers,
+        body: body2 === void 0 ? void 0 : JSON.stringify(body2),
+        signal: AbortSignal.timeout(2e4)
+      });
+    } catch (error62) {
+      const reason = error62 instanceof Error && error62.name === "TimeoutError" ? "timed out" : "is unreachable";
+      throw new CliError(`${options.baseUrl} ${reason}`, void 0, "network");
+    }
+    const text = await response.text();
+    if (response.ok) {
+      try {
+        return schema.parse(JSON.parse(text));
+      } catch {
+        throw new CliError("The server returned an incompatible response", "Update slop to the latest version", "internal");
+      }
+    }
+    let parsed = null;
+    try {
+      parsed = ApiErrorBody.safeParse(JSON.parse(text));
+    } catch {
+    }
+    if (parsed?.success) {
+      const { code, message } = parsed.data.error;
+      throw new CliError(message, code === "unauthenticated" ? "slop login" : void 0, code);
+    }
+    throw new CliError(`${method} ${path2} failed with HTTP ${response.status}`, void 0, "http");
+  }
+  const client = {
+    baseUrl: options.baseUrl,
+    sessionId: null,
+    get: (path2, schema) => sendApiRequest("GET", path2, schema),
+    post: (path2, schema, body2) => sendApiRequest("POST", path2, schema, body2 ?? {}),
+    patch: (path2, schema, body2) => sendApiRequest("PATCH", path2, schema, body2),
+    put: (path2, schema, body2) => sendApiRequest("PUT", path2, schema, body2),
+    delete: (path2, schema) => sendApiRequest("DELETE", path2, schema)
+  };
+  return client;
+}
+function buildAuthedApiClient() {
+  const session = resolveSession();
+  if (!session.token) throw new CliError(`Not signed in to ${session.baseUrl}`, "slop login", "unauthenticated");
+  const client = buildApiClient(session);
+  const conversation = fetchKnownConversation(process.cwd());
+  client.sessionId = fetchRememberedSession(process.cwd(), conversation?.id ?? `dir:${resolve5(process.cwd())}`);
+  return client;
+}
+
+// src/platform/machine.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { hostname as hostname3, platform, userInfo } from "os";
+import { dirname as dirname4, join as join9 } from "path";
+function runCommand(command, args) {
+  try {
+    return execFileSync4(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+  } catch {
+    return null;
+  }
+}
+function fetchOsMachineId() {
+  switch (platform()) {
+    case "darwin":
+      return /"IOPlatformUUID" = "([^"]+)"/.exec(runCommand("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]) ?? "")?.[1] ?? null;
+    case "linux":
+      for (const path2 of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        if (existsSync6(path2)) return readFileSync7(path2, "utf8").trim() || null;
+      }
+      return null;
+    case "win32":
+      return /MachineGuid\s+REG_SZ\s+(\S+)/.exec(
+        runCommand("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"]) ?? ""
+      )?.[1] ?? null;
+    default:
+      return null;
+  }
+}
+function resolvePersistedMachineId() {
+  const path2 = join9(dirname4(buildConfigPath()), "machine-id");
+  if (existsSync6(path2)) return readFileSync7(path2, "utf8").trim();
+  const id = randomUUID5();
+  mkdirSync4(dirname4(path2), { recursive: true, mode: 448 });
+  writeFileSync5(path2, `${id}
+`, { mode: 384 });
+  return id;
+}
+function buildMachineInfo() {
+  const raw = `${fetchOsMachineId() ?? resolvePersistedMachineId()}:${userInfo().username}`;
+  return {
+    fingerprint: createHash4("sha256").update(raw).digest("hex"),
+    name: hostname3().replace(/\.local$/, ""),
+    platform: platform()
+  };
+}
+
+// src/platform/output.ts
+var jsonMode = false;
+var updateJsonMode = (on) => {
+  jsonMode = on;
+};
+var isJsonMode = () => jsonMode;
+function emitOutput(value, human) {
+  process.stdout.write(jsonMode ? `${JSON.stringify(value, null, 2)}
+` : `${human()}
+`);
+}
+function exitWithError(error62) {
+  const cli = error62 instanceof CliError ? error62 : null;
+  const message = error62 instanceof Error ? error62.message : String(error62);
+  if (jsonMode) {
+    process.stderr.write(`${JSON.stringify({ error: { code: cli?.code ?? "error", message, hint: cli?.hint } })}
+`);
+  } else {
+    process.stderr.write(`error: ${message}
+`);
+    if (cli?.hint) process.stderr.write(`  try: ${cli.hint}
+`);
+  }
+  process.exit(cli?.exitCode ?? 1);
+}
+function formatTable(rows) {
+  const widths = [];
+  for (const row of rows) row.forEach((cell, index) => widths[index] = Math.max(widths[index] ?? 0, cell.length));
+  return rows.map((row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index])).join("  ")).join("\n");
+}
+var formatStatusLabel = (statuses, key) => statuses.find((status) => status.key === key)?.label ?? key;
+var formatTaskLine = (statuses) => (task) => [
+  task.key,
+  formatStatusLabel(statuses, task.status),
+  TASK_SEVERITY_LABELS[task.severity],
+  task.assignee?.name ?? "-",
+  task.title
+];
+function formatTaskDetail(task, url2, statuses) {
+  const lines = [
+    `${task.key}  ${task.title}`,
+    `status: ${formatStatusLabel(statuses, task.status)}   severity: ${TASK_SEVERITY_LABELS[task.severity]}   assignee: ${task.assignee?.name ?? "nobody"}   by: ${task.createdBy.name}`,
+    url2
+  ];
+  if (task.links.length > 0) lines.push(`links: ${task.links.map((link) => `${link.title} <${link.url}>`).join(", ")}`);
+  if (task.archivedAt) lines.push("archived");
+  if (task.items.length > 0) {
+    lines.push("", `plan  ${task.progress.done}/${task.progress.total} done`);
+    task.items.forEach((item, index) => lines.push(`  ${index + 1}. [${item.done ? "x" : " "}] ${item.title}${item.note ? `  (${item.note.split("\n")[0]})` : ""}`));
+  }
+  if (task.description) lines.push("", task.description);
+  if (task.notes) lines.push("", "notes:", task.notes);
+  return lines.join("\n");
+}
+
+// src/commands/auth.ts
+function openBrowser(url2) {
+  const [command, args] = platform2() === "darwin" ? ["open", [url2]] : platform2() === "win32" ? ["cmd", ["/c", "start", "", url2]] : ["xdg-open", [url2]];
+  try {
+    spawn2(command, args, { stdio: "ignore", detached: true }).on("error", () => {
+    }).unref();
+  } catch {
+  }
+}
+var waitForMilliseconds = (ms) => new Promise((done) => setTimeout(done, ms));
+var isHeadless = () => Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY) || platform2() === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
+function registerAuthCommands(program3) {
+  program3.command("login").description("Sign this machine in. Opens the web app, where you approve the login. On a VM or over SSH, open the printed link on any device.").option("--url <url>", "the Slopware Tasks instance to sign in to").option("--no-browser", "print the link instead of opening it").action(async (options) => {
+    const baseUrl = (options.url || process.env.SLOP_URL || fetchConfig()?.baseUrl || DEFAULT_URL).replace(/\/+$/, "");
     const api = buildApiClient({ baseUrl, token: null });
     const started = await api.post("/cli/auth/start", ApiResponses.StartCliAuthResult, { machine: buildMachineInfo() });
     const remote = isHeadless();
@@ -24231,106 +24799,41 @@ Agent skills installed in ~/.claude/skills and ~/.agents/skills. Next: slop mcp
     }
     throw new CliError("The login request expired before it was approved", "slop login");
   });
-  program3.command("logout").description("Sign this machine out and revoke its token.").action(async () => {
-    const session = resolveSession();
-    if (session.token) await buildApiClient(session).post("/cli/auth/logout", ApiResponses.Ok).catch(() => {
-    });
-    deleteConfig();
-    emitOutput({ ok: true }, () => "Signed out.");
-  });
-  program3.command("whoami").description("Show the signed-in user, machine and instance.").action(async () => {
-    const api = buildAuthedApiClient();
-    const me = await api.get("/me", ApiResponses.Me);
-    emitOutput({ ...me, baseUrl: api.baseUrl }, () => `${me.user.name} <${me.user.email}>
-machine: ${me.machine?.name ?? "-"}
-instance: ${api.baseUrl}`);
-  });
-}
-
-// src/commands/guide.ts
-var AGENT_GUIDE = `## Task tracking
-
-This repository is linked to a Slopware Tasks board. Use the \`slop\` CLI to keep it current.
-
-- When you find work that should be tracked (a bug, a follow-up, a TODO you are not doing now), create a task:
-  \`slop task create "Short imperative title" -d "What, where, why" -s <low|medium|high|critical>\`
-- 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. 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.
-- When you open a pull request for a task, link it: \`slop task link <KEY> <pr-url>\`.
-- Columns are the project's own: \`slop statuses\` lists them; \`slop task move <KEY> "<column>"\` takes a key or label. \`slop task start\` / \`slop task done\` go to the first "in progress" / "done" column. Finished work is archived from the board (\`slop task archive <KEY>\`), not deleted. Do not delete tasks you did not create.
-`;
-function registerGuideCommand(program3) {
-  program3.command("guide").description("Print a snippet for AGENTS.md / CLAUDE.md that teaches an agent to use this CLI.").action(() => emitOutput({ markdown: AGENT_GUIDE }, () => AGENT_GUIDE));
-}
-
-// src/platform/git.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { basename, join as join5, resolve } from "path";
-function runGit(args, cwd = process.cwd()) {
-  try {
-    return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-  } catch {
-    return null;
-  }
-}
-function fetchRepo() {
-  const commonDir = runGit(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  if (!commonDir) return null;
-  const worktree = runGit(["rev-parse", "--show-toplevel"]);
-  const root = basename(commonDir) === ".git" ? resolve(commonDir, "..") : worktree ?? commonDir;
-  return { root, worktree: worktree ?? root, linkPath: join5(commonDir, "slop.json") };
-}
-function fetchCurrentBranch(cwd = process.cwd()) {
-  const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
-  return branch && branch !== "HEAD" ? branch : null;
-}
-function requireRepo() {
-  const repo = fetchRepo();
-  if (!repo) throw new CliError("Not inside a git repository", "cd into your repository, or pass --project KEY", "no_repo");
-  return repo;
-}
-function fetchRepoLink(repo) {
-  try {
-    return JSON.parse(readFileSync5(repo.linkPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function persistRepoLink(repo, link) {
-  writeFileSync5(repo.linkPath, `${JSON.stringify(link, null, 2)}
-`);
-}
-function deleteTaskLink(repo) {
-  if (existsSync5(repo.linkPath)) rmSync3(repo.linkPath);
-}
-function normalizeRemoteUrl(url2) {
-  const scp = /^[^@/]+@([^:/]+):(.+)$/.exec(url2);
-  const bare = scp ? `${scp[1]}/${scp[2]}` : url2.replace(/^[a-z+]+:\/\//i, "").replace(/^[^@/]+@/, "");
-  return bare.replace(/\.git$/, "").replace(/\/+$/, "");
-}
-function buildRepoDescription(repo, existing) {
-  const roots = runGit(["rev-list", "--max-parents=0", "HEAD"], repo.root);
-  const remote = runGit(["remote", "get-url", "origin"], repo.root);
-  const remoteUrl = remote ? normalizeRemoteUrl(remote) : null;
-  let fingerprint;
-  let localRepoId;
-  if (roots) {
-    fingerprint = createHash3("sha256").update(roots.split("\n").sort().join("\n")).digest("hex");
-  } else {
-    localRepoId = existing?.localRepoId ?? randomUUID2();
-    fingerprint = `local:${localRepoId}`;
-  }
-  return {
-    info: { fingerprint, name: remoteUrl?.split("/").slice(-1)[0] ?? basename(repo.root), remoteUrl, rootPath: repo.root },
-    localRepoId
-  };
+  program3.command("logout").description("Sign this machine out and revoke its token.").action(async () => {
+    const session = resolveSession();
+    if (session.token) await buildApiClient(session).post("/cli/auth/logout", ApiResponses.Ok).catch(() => {
+    });
+    deleteConfig();
+    emitOutput({ ok: true }, () => "Signed out.");
+  });
+  program3.command("whoami").description("Show the signed-in user, machine and instance.").action(async () => {
+    const api = buildAuthedApiClient();
+    const me = await api.get("/me", ApiResponses.Me);
+    emitOutput({ ...me, baseUrl: api.baseUrl }, () => `${me.user.name} <${me.user.email}>
+machine: ${me.machine?.name ?? "-"}
+instance: ${api.baseUrl}`);
+  });
+}
+
+// src/commands/guide.ts
+var AGENT_GUIDE = `## Task tracking
+
+This repository is linked to a Slopware Tasks board. Use the \`slop\` CLI to keep it current.
+
+- When you find work that should be tracked (a bug, a follow-up, a TODO you are not doing now), create a task:
+  \`slop task create "Short imperative title" -d "What, where, why" -s <low|medium|high|critical>\`
+- 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 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.
+- When you open a pull request for a task, link it: \`slop task link <KEY> <pr-url>\`.
+- Columns are the project's own: \`slop statuses\` lists them; \`slop task move <KEY> "<column>"\` takes a key or label. \`slop task start\` / \`slop task done\` go to the first "in progress" / "done" column. Finished work is archived from the board (\`slop task archive <KEY>\`), not deleted. Do not delete tasks you did not create.
+`;
+function registerGuideCommand(program3) {
+  program3.command("guide").description("Print a snippet for AGENTS.md / CLAUDE.md that teaches an agent to use this CLI.").action(() => emitOutput({ markdown: AGENT_GUIDE }, () => AGENT_GUIDE));
 }
 
 // src/commands/projects.ts
@@ -24391,696 +24894,757 @@ function registerProjectCommands(program3) {
     if (!STATUS_CATEGORIES.includes(options.category)) throw new CliError(`Unknown category "${options.category}"`, `use one of: ${STATUS_CATEGORIES.join(", ")}`);
     const target = await fetchResolvedProject(api, options.project);
     const statuses = await api.post(`/projects/${target.id}/statuses`, ApiResponses.ProjectStatuses, { label, category: options.category });
-    emitOutput(statuses, () => formatStatusLines(statuses));
-  });
-  status.command("rename <column> <label>").description("Rename a column (its key stays).").option("-p, --project <key>").option("-c, --category <category>", STATUS_CATEGORIES.join(" | ")).action(async (ref, label, options) => {
-    const api = buildAuthedApiClient();
-    const target = await fetchResolvedProject(api, options.project);
-    const statuses = await api.patch(`/projects/${target.id}/statuses/${requireStatusByRef(target, ref).id}`, ApiResponses.ProjectStatuses, { label, category: options.category });
-    emitOutput(statuses, () => formatStatusLines(statuses));
-  });
-  status.command("remove <column>").description("Remove a column; its tasks move to --to.").option("-p, --project <key>").option("--to <column>", "where the column's tasks go").action(async (ref, options) => {
-    const api = buildAuthedApiClient();
-    const target = await fetchResolvedProject(api, options.project);
-    const moveTo = options.to ? requireStatusByRef(target, options.to).key : null;
-    const statuses = await api.delete(`/projects/${target.id}/statuses/${requireStatusByRef(target, ref).id}${moveTo ? `?moveTo=${encodeURIComponent(moveTo)}` : ""}`, ApiResponses.ProjectStatuses);
-    emitOutput(statuses, () => formatStatusLines(statuses));
-  });
-  status.command("order <columns...>").description("Set the board order: every column, by key or label.").option("-p, --project <key>").action(async (refs, options) => {
-    const api = buildAuthedApiClient();
-    const target = await fetchResolvedProject(api, options.project);
-    const statuses = await api.put(`/projects/${target.id}/statuses/order`, ApiResponses.ProjectStatuses, { ids: refs.map((ref) => requireStatusByRef(target, ref).id) });
-    emitOutput(statuses, () => formatStatusLines(statuses));
-  });
-  project.command("update").description("Change the linked project's name or description.").option("-p, --project <key>", "project key (default: the linked project)").option("-n, --name <name>").option("-d, --description <text>").action(async (options) => {
-    const api = buildAuthedApiClient();
-    const target = await resolveProject(api, options.project);
-    if (options.name === void 0 && options.description === void 0) {
-      throw new CliError("Nothing to change", "pass --name or --description");
-    }
-    const updated = await api.patch(`/projects/${target.id}`, ApiResponses.Project, { name: options.name, description: options.description });
-    emitOutput(updated, () => `Updated ${updated.key}  ${updated.name}`);
-  });
-  project.command("create <name>").description("Create a project.").option("-k, --key <key>", "task key prefix, e.g. WEB (default: derived from the name)").option("-d, --description <text>", "what the project is").option("--org <slug-or-id>", "which org, if you belong to several").action(async (name, options) => {
-    const api = buildAuthedApiClient();
-    const orgs = await api.get("/orgs", ApiResponses.Orgs);
-    const org = options.org ? orgs.find((candidate) => candidate.id === options.org || candidate.slug === options.org) : orgs.length === 1 ? orgs[0] : void 0;
-    if (!org) throw new CliError(options.org ? `No org "${options.org}"` : "You belong to several orgs", `pass --org: ${orgs.map((candidate) => candidate.slug).join(", ")}`);
-    const key = options.key ?? generateProjectKeyFromName(name);
-    if (!key) throw new CliError("Could not derive a key from that name", "pass --key, e.g. --key WEB");
-    const project2 = await api.post(`/orgs/${org.id}/projects`, ApiResponses.Project, { name, key, description: options.description ?? "" });
-    emitOutput(project2, () => `Created ${project2.key}  ${project2.name}
-Link this repository to it: slop link ${project2.key}`);
-  });
-  program3.command("link <project>").description("Bind this git repository (on this machine) to a project, by key.").action(async (projectKey) => {
-    const api = buildAuthedApiClient();
-    const repo = requireRepo();
-    const project2 = await fetchProjectByKey(api, projectKey);
-    const { info, localRepoId } = buildRepoDescription(repo, fetchRepoLink(repo));
-    const binding = await api.post(`/projects/${project2.id}/bindings`, ApiResponses.Binding, { repo: info });
-    persistRepoLink(repo, { baseUrl: api.baseUrl, projectId: project2.id, projectKey: project2.key, projectName: project2.name, bindingId: binding.id, localRepoId });
-    emitOutput({ project: project2, binding }, () => `Linked ${info.name} on ${binding.machine.name} to ${project2.key}  ${project2.name}
-Try: slop task create "My first task"`);
-  });
-  program3.command("unlink").description("Remove this repository's binding.").action(async () => {
-    const repo = requireRepo();
-    const link = fetchRepoLink(repo);
-    if (!link) throw new CliError("This repository is not linked", void 0, "not_linked");
-    await buildAuthedApiClient().delete(`/projects/${link.projectId}/bindings/${link.bindingId}`, ApiResponses.Ok).catch(() => {
-    });
-    deleteTaskLink(repo);
-    emitOutput({ ok: true }, () => `Unlinked from ${link.projectKey}.`);
-  });
-  program3.command("status").description("Show what this repository is linked to.").action(async () => {
-    const repo = fetchRepo();
-    const link = repo ? fetchRepoLink(repo) : null;
-    const where = !repo ? "" : repo.worktree === repo.root ? repo.root : `${repo.worktree}  (worktree of ${repo.root})`;
-    emitOutput(
-      { repo: repo?.root ?? null, worktree: repo?.worktree ?? null, link },
-      () => !repo ? "Not inside a git repository." : !link ? `${where}
-not linked. Run: slop link <PROJECT_KEY>` : `${where}
-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 existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "fs";
-import "path";
-import { homedir as homedir4 } from "os";
-import { join as join12 } from "path";
-
-// src/platform/live.ts
-var PING_EVERY_MS = 25e3;
-var PONG_WITHIN_MS = 1e4;
-var STANDBY_POLL_MS = 2e4;
-async function waitForMessage(api, projectId, taskKey, options = {}) {
-  const ticket = await api.post(`/projects/${projectId}/tasks/${encodeURIComponent(taskKey)}/session/ticket`, ApiResponses.ConnectTicket, options.claim ?? {});
-  const socket = new WebSocket(`${api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
-  const outcome = await new Promise((resolve5) => {
-    const timer = options.timeoutMs && options.timeoutMs > 0 ? setTimeout(() => resolve5({ kind: "timeout" }), options.timeoutMs) : null;
-    const finishWait = (result) => {
-      if (timer) clearTimeout(timer);
-      resolve5(result);
-    };
-    socket.addEventListener("message", (event) => {
-      if (String(event.data) === "pong") return;
-      const push = JSON.parse(String(event.data));
-      if (push.type === "hello") {
-        api.sessionId = push.session.id;
-        persistRememberedSession(process.cwd(), push.session.id);
-        options.onHello?.(push.session);
-        return;
-      }
-      if (push.type === "end") {
-        finishWait({ kind: "ended" });
-        return;
-      }
-      if (push.type !== "thread") return;
-      if (options.onMessage?.({ thread: push.thread, message: push.message })) return;
-      finishWait({ kind: "message", push: { thread: push.thread, message: push.message } });
-    });
-    socket.addEventListener("close", (event) => finishWait({ kind: "dropped", reason: event.reason || `code ${event.code}` }));
-    socket.addEventListener("error", () => finishWait({ kind: "dropped", reason: "socket error" }));
-  });
-  if (outcome.kind !== "message") persistRememberedSession(process.cwd(), null);
-  if (outcome.kind === "message" || outcome.kind === "timeout") {
-    socket.close(1e3, outcome.kind === "message" ? "handled" : "timeout");
-    await new Promise((resolve5) => {
-      socket.addEventListener("close", () => resolve5(), { once: true });
-      setTimeout(resolve5, 500);
-    });
-  }
-  return outcome;
-}
-var HeldSession = class {
-  constructor(api, projectId, taskKey, hooks) {
-    this.api = api;
-    this.projectId = projectId;
-    this.taskKey = taskKey;
-    this.hooks = hooks;
-  }
-  api;
-  projectId;
-  taskKey;
-  hooks;
-  socket = null;
-  stopped = false;
-  connecting = false;
-  timer = null;
-  heartbeat = null;
-  pongDue = null;
-  attempt = 0;
-  connected = 0;
-  session = null;
-  /**
-   * Whoever is waiting for a message. Handed each one, and answers whether it took it (a waiter for one thread lets
-   * the rest pass to the inbox); handed null when the agent is made unreachable under them.
-   */
-  waiters = /* @__PURE__ */ new Set();
-  greeted = null;
-  /**
-   * Settled once the room has said hello (the session id is known, so this process's next write names its session),
-   * or after a few seconds if the room is slow. A write before hello names no session, and a reply to it reaches
-   * nobody, so callers wait for this before their first write.
-   */
-  ready = new Promise((resolve5) => {
-    this.greeted = resolve5;
-    setTimeout(resolve5, 5e3).unref();
-  });
-  async start() {
-    await this.connect();
-  }
-  async connect() {
-    if (this.stopped || this.connecting || this.socket) return;
-    this.connecting = true;
-    if (this.timer) clearTimeout(this.timer);
-    try {
-      const ticket = await this.api.post(this.taskKey ? `/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket` : `/projects/${this.projectId}/session/ticket`, ApiResponses.ConnectTicket, this.hooks.claim());
-      if (this.stopped) return;
-      const socket = new WebSocket(`${this.api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
-      this.socket = socket;
-      socket.addEventListener("open", () => {
-        if (this.stopped || this.socket !== socket) return;
-        this.attempt = 0;
-        this.startHeartbeat(socket);
-      });
-      socket.addEventListener("message", (event) => {
-        if (this.stopped || this.socket !== socket) return;
-        const data = String(event.data);
-        if (data === "pong") {
-          if (this.pongDue) clearTimeout(this.pongDue);
-          this.pongDue = null;
-          return;
-        }
-        const push = JSON.parse(data);
-        if (push.type === "hello") {
-          this.api.sessionId = push.session.id;
-          this.session = push.session;
-          this.taskKey = push.session.taskKey;
-          persistRememberedSession(process.cwd(), push.session.id);
-          this.greeted?.();
-          this.greeted = null;
-          this.connected += 1;
-          if (this.connected > 1) void this.hooks.onReconnect?.(push.session);
-          return;
-        }
-        if (push.type === "end") {
-          this.stopped = true;
-          return;
-        }
-        if (push.type === "reachable") {
-          if (this.session) this.session = { ...this.session, reachable: push.on };
-          if (!push.on) for (const waiter of [...this.waiters]) waiter(null);
-          this.hooks.onReachable?.(push.on);
-          return;
-        }
-        if (push.type !== "thread") return;
-        const delivered = { thread: push.thread, message: push.message };
-        let taken = false;
-        for (const waiter of [...this.waiters]) if (waiter(delivered)) taken = true;
-        if (!taken) this.hooks.onMessage(delivered);
-      });
-      socket.addEventListener("close", (event) => {
-        if (this.socket !== socket) return;
-        this.stopHeartbeat();
-        if (this.socket === socket) this.socket = null;
-        if (this.stopped) return;
-        if (event.reason === "replaced") this.standBy();
-        else this.schedule();
-      });
-      socket.addEventListener("error", () => {
-      });
-    } catch {
-      this.schedule();
-    } finally {
-      this.connecting = false;
-    }
-  }
-  /** A ping every 25s; no pong within 10s means the socket is dead however open it looks. Close it and come back. */
-  startHeartbeat(socket) {
-    this.stopHeartbeat();
-    this.heartbeat = setInterval(() => {
-      if (socket.readyState !== WebSocket.OPEN) return;
-      socket.send("ping");
-      if (!this.pongDue) {
-        this.pongDue = setTimeout(() => {
-          this.pongDue = null;
-          socket.close(4e3, "no pong");
-        }, PONG_WITHIN_MS);
-      }
-    }, PING_EVERY_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeat) clearInterval(this.heartbeat);
-    if (this.pongDue) clearTimeout(this.pongDue);
-    this.heartbeat = null;
-    this.pongDue = null;
-  }
-  schedule() {
-    if (this.stopped) return;
-    if (this.timer) clearTimeout(this.timer);
-    this.attempt += 1;
-    this.timer = setTimeout(() => void this.connect(), Math.min(3e4, 1e3 * 2 ** Math.min(this.attempt, 5)));
-  }
-  /** Another process holds this session now: look now and then, and take it back once it is no longer live. */
-  standBy() {
-    if (this.stopped) return;
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(async () => {
-      if (this.stopped) return;
-      let holder = true;
-      try {
-        const sessions = await this.api.get(`/projects/${this.projectId}/sessions`, ApiResponses.Sessions);
-        holder = sessions.some((session) => session.id === this.session?.id && session.state === "live");
-      } catch {
-      }
-      if (holder) this.standBy();
-      else void this.connect();
-    }, STANDBY_POLL_MS);
-  }
-  stop() {
-    this.stopped = true;
-    if (this.api.sessionId === this.session?.id) this.api.sessionId = null;
-    if (this.timer) clearTimeout(this.timer);
-    this.stopHeartbeat();
-    this.socket?.close(1e3, "released");
-  }
-};
+    emitOutput(statuses, () => formatStatusLines(statuses));
+  });
+  status.command("rename <column> <label>").description("Rename a column (its key stays).").option("-p, --project <key>").option("-c, --category <category>", STATUS_CATEGORIES.join(" | ")).action(async (ref, label, options) => {
+    const api = buildAuthedApiClient();
+    const target = await fetchResolvedProject(api, options.project);
+    const statuses = await api.patch(`/projects/${target.id}/statuses/${requireStatusByRef(target, ref).id}`, ApiResponses.ProjectStatuses, { label, category: options.category });
+    emitOutput(statuses, () => formatStatusLines(statuses));
+  });
+  status.command("remove <column>").description("Remove a column; its tasks move to --to.").option("-p, --project <key>").option("--to <column>", "where the column's tasks go").action(async (ref, options) => {
+    const api = buildAuthedApiClient();
+    const target = await fetchResolvedProject(api, options.project);
+    const moveTo = options.to ? requireStatusByRef(target, options.to).key : null;
+    const statuses = await api.delete(`/projects/${target.id}/statuses/${requireStatusByRef(target, ref).id}${moveTo ? `?moveTo=${encodeURIComponent(moveTo)}` : ""}`, ApiResponses.ProjectStatuses);
+    emitOutput(statuses, () => formatStatusLines(statuses));
+  });
+  status.command("order <columns...>").description("Set the board order: every column, by key or label.").option("-p, --project <key>").action(async (refs, options) => {
+    const api = buildAuthedApiClient();
+    const target = await fetchResolvedProject(api, options.project);
+    const statuses = await api.put(`/projects/${target.id}/statuses/order`, ApiResponses.ProjectStatuses, { ids: refs.map((ref) => requireStatusByRef(target, ref).id) });
+    emitOutput(statuses, () => formatStatusLines(statuses));
+  });
+  project.command("update").description("Change the linked project's name or description.").option("-p, --project <key>", "project key (default: the linked project)").option("-n, --name <name>").option("-d, --description <text>").action(async (options) => {
+    const api = buildAuthedApiClient();
+    const target = await resolveProject(api, options.project);
+    if (options.name === void 0 && options.description === void 0) {
+      throw new CliError("Nothing to change", "pass --name or --description");
+    }
+    const updated = await api.patch(`/projects/${target.id}`, ApiResponses.Project, { name: options.name, description: options.description });
+    emitOutput(updated, () => `Updated ${updated.key}  ${updated.name}`);
+  });
+  project.command("create <name>").description("Create a project.").option("-k, --key <key>", "task key prefix, e.g. WEB (default: derived from the name)").option("-d, --description <text>", "what the project is").option("--org <slug-or-id>", "which org, if you belong to several").action(async (name, options) => {
+    const api = buildAuthedApiClient();
+    const orgs = await api.get("/orgs", ApiResponses.Orgs);
+    const org = options.org ? orgs.find((candidate) => candidate.id === options.org || candidate.slug === options.org) : orgs.length === 1 ? orgs[0] : void 0;
+    if (!org) throw new CliError(options.org ? `No org "${options.org}"` : "You belong to several orgs", `pass --org: ${orgs.map((candidate) => candidate.slug).join(", ")}`);
+    const key = options.key ?? generateProjectKeyFromName(name);
+    if (!key) throw new CliError("Could not derive a key from that name", "pass --key, e.g. --key WEB");
+    const project2 = await api.post(`/orgs/${org.id}/projects`, ApiResponses.Project, { name, key, description: options.description ?? "" });
+    emitOutput(project2, () => `Created ${project2.key}  ${project2.name}
+Link this repository to it: slop link ${project2.key}`);
+  });
+  program3.command("link <project>").description("Bind this git repository (on this machine) to a project, by key.").action(async (projectKey) => {
+    const api = buildAuthedApiClient();
+    const repo = requireRepo();
+    const project2 = await fetchProjectByKey(api, projectKey);
+    const { info, localRepoId } = buildRepoDescription(repo, fetchRepoLink(repo));
+    const binding = await api.post(`/projects/${project2.id}/bindings`, ApiResponses.Binding, { repo: info });
+    persistRepoLink(repo, { baseUrl: api.baseUrl, projectId: project2.id, projectKey: project2.key, projectName: project2.name, bindingId: binding.id, localRepoId });
+    emitOutput({ project: project2, binding }, () => `Linked ${info.name} on ${binding.machine.name} to ${project2.key}  ${project2.name}
+Try: slop task create "My first task"`);
+  });
+  program3.command("unlink").description("Remove this repository's binding.").action(async () => {
+    const repo = requireRepo();
+    const link = fetchRepoLink(repo);
+    if (!link) throw new CliError("This repository is not linked", void 0, "not_linked");
+    await buildAuthedApiClient().delete(`/projects/${link.projectId}/bindings/${link.bindingId}`, ApiResponses.Ok).catch(() => {
+    });
+    deleteTaskLink(repo);
+    emitOutput({ ok: true }, () => `Unlinked from ${link.projectKey}.`);
+  });
+  program3.command("status").description("Show what this repository is linked to.").action(async () => {
+    const repo = fetchRepo();
+    const link = repo ? fetchRepoLink(repo) : null;
+    const where = !repo ? "" : repo.worktree === repo.root ? repo.root : `${repo.worktree}  (worktree of ${repo.root})`;
+    emitOutput(
+      { repo: repo?.root ?? null, worktree: repo?.worktree ?? null, link },
+      () => !repo ? "Not inside a git repository." : !link ? `${where}
+not linked. Run: slop link <PROJECT_KEY>` : `${where}
+linked to ${link.projectKey}  ${link.projectName}  (${link.baseUrl})`
+    );
+  });
+}
 
-// src/platform/agent-identity.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { basename as basename3, join as join9, resolve as resolve3 } from "path";
+// src/commands/mcp.ts
+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 join15 } from "path";
 
-// src/platform/harness.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { closeSync, openSync, readdirSync as readdirSync2, readSync, readlinkSync, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
-import { basename as basename2, join as join8 } from "path";
+// src/platform/session-recovery.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
 
-// src/platform/harness-wake.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
-import { connect } from "net";
-import { spawn as spawn2 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
+// 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/homes.ts
-import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6, resolve as resolve2 } from "path";
-var deduplicateStrings = (paths) => [...new Set(paths.map((path2) => resolve2(path2)))];
-function fetchAncestorEnvironments() {
-  if (process.platform === "win32") return [];
-  const seen = [];
+// 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 {
-    if (process.platform === "linux") {
-      let pid2 = process.ppid;
-      for (let hop = 0; hop < 6 && pid2 > 1; hop += 1) {
-        seen.push(readFileSync6(`/proc/${pid2}/environ`, "latin1").replace(/\0/g, " "));
-        const stat = readFileSync6(`/proc/${pid2}/stat`, "utf8");
-        pid2 = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+    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;
       }
-      for (const entry of readdirSync("/proc")) {
-        if (!/^\d+$/.test(entry)) continue;
+      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 {
-          seen.push(readFileSync6(`/proc/${entry}/environ`, "latin1").replace(/\0/g, " "));
-        } catch {
+          writeFileSync6(`${next}.released`, "", { mode: 384 });
+        } catch (error62) {
+          if (error62.code !== "ENOENT") throw error62;
         }
-      }
-      return seen;
-    }
-    const runPs = (args) => execFileSync3("ps", args, { encoding: "utf8", maxBuffer: 64 << 20, stdio: ["ignore", "pipe", "ignore"] });
-    let pid = process.ppid;
-    for (let hop = 0; hop < 6 && pid > 1; hop += 1) {
-      seen.push(runPs(["eww", "-o", "command=", "-p", String(pid)]));
-      pid = Number(runPs(["-o", "ppid=", "-p", String(pid)]).trim());
+      } };
+    } catch (error62) {
+      if (error62.code === "ENOENT") return null;
+      if (error62.code !== "EEXIST") throw error62;
+    } finally {
+      rmSync5(temporary, { force: true });
     }
-    seen.push(runPs(["axeww", "-o", "command="]));
-  } catch {
   }
-  return seen;
-}
-var environments = null;
-function findHomesInUse(variable) {
-  environments ??= fetchAncestorEnvironments();
-  const found = [];
-  const pattern = new RegExp(`(?:^|\\s)${variable}=(\\S+)`, "g");
-  for (const text of environments) for (const match of text.matchAll(pattern)) found.push(match[1] ?? "");
-  return found.filter(Boolean);
 }
-var findDirectoriesNamed = (root, prefix) => {
+
+// 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 {
-    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.name.startsWith(prefix) && (entry.isDirectory() || entry.isSymbolicLink())).map((entry) => join6(root, entry.name)).filter((path2) => {
-      try {
-        return statSync2(path2).isDirectory();
-      } catch {
-        return false;
-      }
-    });
-  } catch {
-    return [];
+    names = readdirSync5(join11(directory, "compacted"));
+  } catch (error62) {
+    if (error62.code === "ENOENT") return cached2.keys;
+    throw error62;
   }
-};
-var hasAnyEntry = (dir, files) => files.some((file2) => existsSync6(join6(dir, file2)));
-function fetchClaudeHomes(root = homedir3(), inUse = findHomesInUse) {
-  if (process.env.SLOP_CLAUDE_HOME) return [process.env.SLOP_CLAUDE_HOME];
-  const named = process.env.CLAUDE_CONFIG_DIR ? [process.env.CLAUDE_CONFIG_DIR] : [];
-  return deduplicateStrings([join6(root, ".claude"), ...named, ...inUse("CLAUDE_CONFIG_DIR"), ...findDirectoriesNamed(root, ".claude").filter((dir) => hasAnyEntry(dir, ["settings.json", ".claude.json", "sessions"]))]);
+  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 fetchCodexHomes(root = homedir3(), inUse = findHomesInUse) {
-  if (process.env.SLOP_CODEX_HOME) return [process.env.SLOP_CODEX_HOME];
-  const named = process.env.CODEX_HOME ? [process.env.CODEX_HOME] : [];
-  return deduplicateStrings([join6(root, ".codex"), ...named, ...inUse("CODEX_HOME"), ...findDirectoriesNamed(root, ".codex").filter((dir) => hasAnyEntry(dir, ["config.toml", "auth.json", "sessions"]))]);
+function hasInboxReceipt(directory, key) {
+  return existsSync8(join11(directory, key)) || fetchArchivedReceipts(directory).has(key);
 }
-function resolveOwnHarnessHome(variable) {
-  if (process.platform === "win32") return null;
+function compactInboxReceipts(directory) {
+  let keys;
   try {
-    let pid = process.ppid;
-    for (let hop = 0; hop < 6 && pid > 1; hop += 1) {
-      const text = process.platform === "linux" ? readFileSync6(`/proc/${pid}/environ`, "latin1").replace(/\0/g, " ") : execFileSync3("ps", ["eww", "-o", "command=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-      const match = new RegExp(`(?:^|\\s)${variable}=(\\S+)`).exec(text);
-      if (match?.[1]) return resolve2(match[1]);
-      if (process.platform === "linux") {
-        const stat = readFileSync6(`/proc/${pid}/stat`, "utf8");
-        pid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      } else pid = Number(execFileSync3("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
-    }
-  } catch {
+    keys = readdirSync5(directory).filter((name2) => /^[a-f0-9]{64}$/.test(name2)).sort();
+  } catch (error62) {
+    if (error62.code === "ENOENT") return;
+    throw error62;
   }
-  return null;
+  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/harness-wake.ts
-function fetchHarnessRegistration(pid = process.ppid) {
-  for (const home of fetchClaudeHomes()) {
-    const path2 = join7(home, "sessions", `${pid}.json`);
-    if (!existsSync7(path2)) continue;
+// src/platform/inbox.ts
+var buildInboxDir = () => join12(dirname5(buildConfigPath()), "inbox");
+var resolveRealCwd2 = (cwd) => {
+  try {
+    return realpathSync4(cwd);
+  } catch {
+    return cwd;
+  }
+};
+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);
+  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 = createHash6("sha256").update(push.message.id).digest("hex");
+    const published = join12(directory, `${key}.json`);
     try {
-      return JSON.parse(readFileSync7(path2, "utf8"));
-    } catch {
-      return null;
+      if (hasInboxReceipt(join12(directory, "receipts"), key)) return false;
+      linkSync3(temporary, published);
+      return true;
+    } catch (error62) {
+      if (error62.code === "EEXIST") return !hasInboxReceipt(join12(directory, "receipts"), key);
+      throw error62;
+    } finally {
+      rmSync7(temporary, { force: true });
     }
   }
-  return null;
-}
-function resolveClaudeSession(pid = Number(process.env.SLOP_HARNESS_PID) || process.ppid) {
-  const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
-  if (sessionId) return { sessionId, socketPath: process.env.CLAUDE_CODE_MESSAGING_SOCKET || fetchHarnessRegistration(pid)?.messagingSocketPath || null };
-  const registration = fetchHarnessRegistration(pid);
-  return registration?.sessionId ? { sessionId: registration.sessionId, socketPath: registration.messagingSocketPath ?? null } : null;
-}
-function wakeHarness(text, pid = Number(process.env.SLOP_HARNESS_PID) || process.ppid) {
-  const session = resolveClaudeSession(pid);
-  if (!session?.socketPath) return Promise.resolve(false);
-  const frame = {
-    uuid: randomUUID3(),
-    session_id: session.sessionId,
-    type: "user",
-    parent_tool_use_id: null,
-    message: { role: "user", content: text }
-  };
-  return new Promise((resolve5) => {
-    const socket = connect({ path: session.socketPath });
-    const finishWake = (ok) => {
-      clearTimeout(timer);
-      socket.destroy();
-      resolve5(ok);
-    };
-    const timer = setTimeout(() => finishWake(false), 3e3);
-    socket.on("connect", () => {
-      socket.write(`${JSON.stringify(frame)}
-`, (error62) => error62 ? finishWake(false) : setTimeout(() => finishWake(true), 200));
-    });
-    socket.on("error", () => finishWake(false));
-  });
+  renameSync2(temporary, join12(directory, `${name}.json`));
+  return true;
 }
-function wakeCodex(text, threadId, options = {}) {
-  const endpoint = process.env.SLOP_CODEX_APP_SERVER;
-  if (endpoint) return wakeCodexOverWs(text, threadId, endpoint);
-  return new Promise((resolve5) => {
-    let child;
+function deleteAcknowledgedInboxClaims(directory) {
+  const claims = join12(directory, "claims");
+  let names;
+  try {
+    names = readdirSync6(claims);
+  } catch (error62) {
+    if (error62.code === "ENOENT") return;
+    throw error62;
+  }
+  for (const key of names) {
+    if (!/^[a-f0-9]{64}$/.test(key) || !hasInboxReceipt(join12(directory, "receipts"), key)) continue;
     try {
-      child = spawn2(options.binary ?? "codex", ["queue", "--thread", threadId, "--message", text], {
-        env: options.codexHome ? { ...process.env, CODEX_HOME: options.codexHome } : process.env,
-        stdio: ["ignore", "ignore", "ignore"]
-      });
-    } catch {
-      resolve5(false);
-      return;
+      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 {
+      }
     }
-    const timer = setTimeout(() => {
-      child.kill();
-      resolve5(false);
-    }, 15e3);
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolve5(false);
-    });
-    child.on("exit", (code) => {
-      clearTimeout(timer);
-      resolve5(code === 0);
-    });
-  });
-}
-function wakeCodexOverWs(text, threadId, endpoint) {
-  return new Promise((resolve5) => {
-    let socket;
+  };
+  try {
+    let names;
     try {
-      socket = new WebSocket(endpoint);
-    } catch {
-      resolve5(false);
-      return;
+      names = readdirSync6(directory).filter((file2) => /^[a-f0-9]{64}\.json$/.test(file2));
+    } catch (error62) {
+      if (error62.code === "ENOENT") return delivery;
+      throw error62;
     }
-    let nextId = 1;
-    const pending = /* @__PURE__ */ new Map();
-    const finishWake = (ok) => {
-      clearTimeout(timer);
+    const available = [];
+    for (const name of names) {
       try {
-        socket.close();
-      } catch {
+        available.push({ key: name.slice(0, -5), push: JSON.parse(readFileSync10(join12(directory, name), "utf8")) });
+      } catch (error62) {
+        if (error62.code !== "ENOENT") throw error62;
       }
-      resolve5(ok);
-    };
-    const timer = setTimeout(() => finishWake(false), 8e3);
-    const call = (method, params) => new Promise((ok, fail) => {
-      const id = nextId++;
-      pending.set(id, (message) => message.error ? fail(new Error(method)) : ok(message.result));
-      socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
-    });
-    socket.addEventListener("error", () => finishWake(false));
-    socket.addEventListener("message", (event) => {
+    }
+    available.sort((a, b) => a.push.message.createdAt.localeCompare(b.push.message.createdAt) || a.push.message.id.localeCompare(b.push.message.id));
+    for (const { key, push } of available) {
+      if (hasInboxReceipt(receipts, key)) {
+        rmSync7(join12(directory, `${key}.json`), { force: true });
+        continue;
+      }
+      if (!accept(push)) continue;
+      let claim2;
       try {
-        const message = JSON.parse(String(event.data));
-        if (typeof message.id === "number") pending.get(message.id)?.(message);
-      } catch {
+        claim2 = claimInboxMessage(join12(directory, "claims", key));
+      } catch (error62) {
+        if (hasInboxReceipt(receipts, key)) continue;
+        throw error62;
       }
-    });
-    socket.addEventListener("open", () => {
-      void (async () => {
-        try {
-          await call("initialize", { clientInfo: { name: "slop", version: "0" }, capabilities: { experimentalApi: true } });
-          socket.send(JSON.stringify({ jsonrpc: "2.0", method: "initialized", params: {} }));
-          const loaded = await call("thread/loaded/list", {});
-          if (!loaded.data.includes(threadId)) {
-            finishWake(false);
-            return;
-          }
-          await call("turn/start", { threadId, input: [{ type: "text", text }] });
-          finishWake(true);
-        } catch {
-          finishWake(false);
-        }
-      })();
-    });
-  });
+      if (!claim2) continue;
+      claims.push({ key, ...claim2 });
+      if (!hasInboxReceipt(receipts, key)) delivery.pushes.push(push);
+    }
+    return delivery;
+  } catch (error62) {
+    release();
+    throw error62;
+  }
 }
-
-// src/platform/harness.ts
-var parent = null;
-function fetchParentCommand() {
-  if (parent !== null) return parent;
+function hasPendingInboxMessages(cwd, owner) {
+  const directory = buildInboxQueuePath(cwd, owner);
   try {
-    parent = process.platform === "win32" ? "" : execFileSync4("ps", ["-o", "command=", "-p", String(process.ppid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-  } catch {
-    parent = "";
+    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;
   }
-  return parent;
-}
-function parseHarnessFromCommand(command) {
-  const first = basename2(command.trim().split(/\s+/)[0] ?? "");
-  if (/^claude(\b|$)/.test(first)) return "claude";
-  if (/^codex(\b|$)/.test(first)) return "codex";
-  if (/(^|\/)codex(\S*)?\s/.test(command)) return "codex";
-  return null;
-}
-function isNonInteractiveCommand(command) {
-  return /(^|[\s/])codex(\S*)?\s+exec(\s|$)/.test(command);
 }
-function isNonInteractiveHarness() {
-  return isNonInteractiveCommand(fetchParentCommand());
+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 = join12(directory, `${name}.${randomUUID7()}.draining`);
+    try {
+      renameSync2(join12(directory, name), taken);
+    } catch (error62) {
+      if (error62.code === "ENOENT") continue;
+      throw error62;
+    }
+    try {
+      pushes.push(JSON.parse(readFileSync10(taken, "utf8")));
+    } finally {
+      rmSync7(taken, { force: true });
+    }
+  }
+  return pushes;
 }
-var isSamePath = (a, b) => {
-  const resolveRealPath = (path2) => {
+function drainLegacyInbox(cwd) {
+  const path2 = buildInboxPath(cwd);
+  if (!existsSync9(path2)) return [];
+  const taken = `${path2}.${process.pid}.${Date.now()}.draining`;
+  try {
+    renameSync2(path2, taken);
+  } catch {
+    return [];
+  }
+  const lines = readFileSync10(taken, "utf8").split("\n").filter(Boolean);
+  rmSync7(taken, { force: true });
+  return lines.flatMap((line) => {
     try {
-      return realpathSync2(path2);
+      return [JSON.parse(line)];
     } catch {
-      return path2;
+      return [];
     }
-  };
-  return resolveRealPath(a) === resolveRealPath(b);
+  });
+}
+
+// src/platform/session-recovery.ts
+var SessionRecovery = class {
+  constructor(api, owner, cwd, deliverPush) {
+    this.api = api;
+    this.owner = owner;
+    this.deliverPush = deliverPush;
+    this.path = join13(dirname6(buildConfigPath()), "cursors", `${generateInboxKey(cwd, owner)}.json`);
+  }
+  api;
+  owner;
+  deliverPush;
+  cursor = null;
+  preparing = null;
+  syncing = null;
+  resync = false;
+  retry = null;
+  stopped = false;
+  path;
+  syncCursor() {
+    return this.preparing ??= this.fetchCursor().catch((error62) => {
+      this.preparing = null;
+      throw error62;
+    });
+  }
+  async fetchCursor() {
+    try {
+      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) {
+      if (error62.code !== "ENOENT") throw error62;
+      const page = await this.api.get(`/projects/${this.owner.projectId}/session/messages`, ApiResponses.SessionMessages);
+      persistLocalState(this.path, JSON.stringify(page.cursor), false);
+      await this.fetchCursor();
+    }
+  }
+  sync() {
+    if (this.stopped) return Promise.resolve();
+    if (this.syncing) {
+      this.resync = true;
+      return this.syncing;
+    }
+    return this.syncing ??= this.syncMessages().catch(() => {
+      if (!this.stopped && !this.retry) this.retry = setTimeout(() => {
+        this.retry = null;
+        void this.sync();
+      }, 2e4);
+    }).finally(() => {
+      this.syncing = null;
+    });
+  }
+  async syncMessages() {
+    await this.syncCursor();
+    if (this.retry) clearTimeout(this.retry);
+    this.retry = null;
+    while (!this.stopped) {
+      this.resync = false;
+      const page = await this.api.get(`/projects/${this.owner.projectId}/session/messages?cursor=${this.cursor}`, ApiResponses.SessionMessages);
+      if (this.stopped) return;
+      if (page.cursor < this.cursor || page.hasMore && page.cursor === this.cursor) throw new Error("Message recovery did not advance");
+      for (const push of page.pushes) this.deliverPush(push);
+      persistLocalState(this.path, JSON.stringify(page.cursor));
+      this.cursor = page.cursor;
+      if (!page.hasMore && !this.resync) return;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.retry) clearTimeout(this.retry);
+    this.retry = null;
+  }
 };
-function isMainChatRollout(sessionMetaLine) {
-  if (!sessionMetaLine.includes('"session_meta"')) return false;
-  if (/"parent_thread_id"\s*:\s*"/.test(sessionMetaLine)) return false;
-  const source = /"source"\s*:\s*("([^"]*)"|\{)/.exec(sessionMetaLine);
-  if (!source) return true;
-  if (source[1] === "{") return false;
-  return source[2] !== "exec";
+
+// src/platform/live.ts
+var PING_EVERY_MS = 25e3;
+var PONG_WITHIN_MS = 1e4;
+var STANDBY_POLL_MS = 2e4;
+var HELLO_WITHIN_MS = 1e4;
+function parseSessionPush(data) {
+  try {
+    const parsed = SessionPush.safeParse(JSON.parse(data));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
 }
-function fetchCodexConversationByCwd(roots, cwd) {
-  const rollouts = [];
-  const findRolloutsInDirectory = (dir, depth) => {
-    let entries;
+async function waitForMessage(api, projectId, taskKey, options = {}) {
+  return new Promise((resolve6, reject) => {
+    let finished = false;
+    const finishWait = (outcome) => {
+      if (finished) return;
+      finished = true;
+      if (timer) clearTimeout(timer);
+      held.stop(outcome.kind === "message" ? "handled" : outcome.kind === "timeout" ? "timeout" : "released");
+      setTimeout(() => resolve6(outcome), 50);
+    };
+    const held = new HeldSession(api, projectId, taskKey, {
+      claim: () => options.claim ?? { harness: null, directory: null, branch: null },
+      reconnect: false,
+      onHello: options.onHello,
+      onEnd: () => finishWait({ kind: "ended" }),
+      onDrop: (reason) => finishWait({ kind: "dropped", reason }),
+      onMessage: (push) => {
+        if (!options.onMessage?.(push)) finishWait({ kind: "message", push });
+      }
+    });
+    const timer = options.timeoutMs && options.timeoutMs > 0 ? setTimeout(() => finishWait({ kind: "timeout" }), options.timeoutMs) : null;
+    void held.start().catch((error62) => {
+      if (finished) return;
+      finished = true;
+      if (timer) clearTimeout(timer);
+      held.stop();
+      reject(error62);
+    });
+  });
+}
+var HeldSession = class {
+  constructor(api, projectId, taskKey, hooks) {
+    this.api = api;
+    this.projectId = projectId;
+    this.taskKey = taskKey;
+    this.hooks = hooks;
+    this.identity = { ...hooks.claim() };
+  }
+  api;
+  projectId;
+  taskKey;
+  hooks;
+  socket = null;
+  stopped = false;
+  connecting = false;
+  timer = null;
+  heartbeat = null;
+  pongDue = null;
+  helloDue = null;
+  greetings = /* @__PURE__ */ new Set();
+  attempt = 0;
+  connected = 0;
+  delivered = /* @__PURE__ */ new Set();
+  identity;
+  session = null;
+  /**
+   * Whoever is waiting for a message. Handed each one, and answers whether it took it (a waiter for one thread lets
+   * the rest pass to the inbox); handed null when the agent is made unreachable under them.
+   */
+  waiters = /* @__PURE__ */ new Set();
+  /** A write needs an accepted identity. A timeout must fail rather than silently send as another agent. */
+  requireSession() {
+    if (this.stopped) return Promise.reject(new Error("Session ended; start a new session before writing"));
+    if (this.session) return Promise.resolve(this.session);
+    return new Promise((resolve6, reject) => {
+      const finishGreeting = (session) => {
+        clearTimeout(timer);
+        this.greetings.delete(finishGreeting);
+        if (session) resolve6(session);
+        else reject(new Error("Session is not connected; retry when the connection recovers"));
+      };
+      const timer = setTimeout(() => finishGreeting(null), HELLO_WITHIN_MS);
+      this.greetings.add(finishGreeting);
+    });
+  }
+  get isStopped() {
+    return this.stopped;
+  }
+  async start() {
+    await this.connect();
+  }
+  async connect() {
+    if (this.stopped || this.connecting || this.socket) return;
+    this.connecting = true;
+    if (this.timer) clearTimeout(this.timer);
     try {
-      entries = readdirSync2(dir, { withFileTypes: true });
-    } catch {
-      return;
+      const ticket = await this.api.post(this.taskKey ? `/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket` : `/projects/${this.projectId}/session/ticket`, ApiResponses.ConnectTicket, this.identity);
+      if (this.stopped) return;
+      const socket = new WebSocket(`${this.api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
+      this.socket = socket;
+      let greeted = false;
+      this.helloDue = setTimeout(() => this.retryConnection(socket, "no hello"), HELLO_WITHIN_MS);
+      socket.addEventListener("open", () => {
+        if (this.stopped || this.socket !== socket) return;
+        this.startHeartbeat(socket);
+      });
+      socket.addEventListener("message", (event) => {
+        if (this.stopped || this.socket !== socket) return;
+        const data = String(event.data);
+        if (data === "pong") {
+          if (this.pongDue) clearTimeout(this.pongDue);
+          this.pongDue = null;
+          return;
+        }
+        const push = parseSessionPush(data);
+        if (!push) return;
+        if (push.type === "hello") {
+          if (greeted) return;
+          try {
+            persistRememberedSession(process.cwd(), push.session.id, this.identity.conversation);
+          } catch {
+            this.retryConnection(socket, "cannot save session identity");
+            return;
+          }
+          greeted = true;
+          this.api.sessionId = push.session.id;
+          this.session = push.session;
+          this.taskKey = push.session.taskKey;
+          if (this.helloDue) clearTimeout(this.helloDue);
+          this.helloDue = null;
+          this.attempt = 0;
+          for (const greeting of [...this.greetings]) greeting(push.session);
+          this.hooks.onHello?.(push.session);
+          this.connected += 1;
+          if (this.connected > 1) void Promise.resolve().then(() => !this.stopped && this.socket === socket ? this.hooks.onReconnect?.(push.session) : void 0).catch(() => void 0);
+          return;
+        }
+        if (push.type === "end") {
+          this.hooks.onEnd?.();
+          this.stop();
+          return;
+        }
+        if (push.type === "reachable") {
+          if (this.session) this.session = { ...this.session, reachable: push.on };
+          if (!push.on) this.releaseWaiters();
+          this.hooks.onReachable?.(push.on);
+          return;
+        }
+        if (push.type !== "thread") return;
+        try {
+          this.deliverPush(push);
+        } catch {
+          this.retryConnection(socket, "delivery failed");
+        }
+      });
+      socket.addEventListener("close", (event) => {
+        if (this.socket !== socket) return;
+        this.stopHeartbeat();
+        if (this.helloDue) clearTimeout(this.helloDue);
+        this.helloDue = null;
+        this.socket = null;
+        if (this.stopped) return;
+        if (event.reason === "ended") {
+          this.hooks.onEnd?.();
+          this.stop();
+          return;
+        }
+        this.hooks.onDrop?.(event.reason || `code ${event.code}`);
+        if (this.hooks.reconnect === false) {
+          this.stop();
+          return;
+        }
+        if (event.reason === "replaced") this.standBy();
+        else this.schedule();
+      });
+      socket.addEventListener("error", () => {
+        this.retryConnection(socket, "socket error");
+      });
+    } catch (error62) {
+      if (this.hooks.reconnect === false) {
+        this.stop();
+        throw error62;
+      }
+      this.hooks.onDrop?.(error62 instanceof Error ? error62.message : String(error62));
+      this.schedule();
+    } finally {
+      this.connecting = false;
     }
-    for (const entry of entries) {
-      const path2 = join8(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (depth < 3) findRolloutsInDirectory(path2, depth + 1);
-        continue;
+  }
+  /** Live and recovered messages follow exactly the same local delivery path. */
+  deliverPush(push) {
+    if (this.stopped || this.session?.reachable === false || this.delivered.has(push.message.id)) return;
+    if (this.hooks.onPush?.(push) === false) return;
+    for (const waiter of [...this.waiters]) {
+      if (waiter(push)) {
+        this.markPushDelivered(push.message.id);
+        return;
       }
-      const match = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(entry.name);
-      if (!match) continue;
+    }
+    this.hooks.onMessage(push);
+    this.markPushDelivered(push.message.id);
+  }
+  markPushDelivered(id) {
+    this.delivered.add(id);
+    if (this.delivered.size > 1e4) this.delivered.delete(this.delivered.values().next().value);
+  }
+  /** A ping every 25s; no pong within 10s means the socket is dead however open it looks. Close it and come back. */
+  startHeartbeat(socket) {
+    this.stopHeartbeat();
+    this.heartbeat = setInterval(() => {
+      if (socket.readyState !== WebSocket.OPEN) return;
       try {
-        rollouts.push({ path: path2, id: match[1] ?? "", mtime: statSync3(path2).mtimeMs });
+        socket.send("ping");
       } catch {
+        this.retryConnection(socket, "ping failed");
+        return;
       }
-    }
-  };
-  for (const root of roots) findRolloutsInDirectory(root, 0);
-  rollouts.sort((a, b) => b.mtime - a.mtime);
-  for (const rollout of rollouts.slice(0, 300)) {
-    let head = "";
-    try {
-      const fd = openSync(rollout.path, "r");
-      try {
-        const buffer = Buffer.alloc(64 * 1024);
-        head = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString("utf8");
-      } finally {
-        closeSync(fd);
+      if (!this.pongDue) {
+        this.pongDue = setTimeout(() => {
+          this.pongDue = null;
+          this.retryConnection(socket, "no pong");
+        }, PONG_WITHIN_MS);
       }
-    } catch {
-      continue;
-    }
-    const line = head.split("\n")[0] ?? "";
-    if (!line.includes('"session_meta"')) continue;
-    if (!isMainChatRollout(line)) continue;
-    const found = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(line);
-    if (!found) continue;
-    let dir;
+    }, PING_EVERY_MS);
+  }
+  /** Detach first: close may arrive late or never, and an old callback must not change its replacement. */
+  retryConnection(socket, reason) {
+    if (this.stopped || this.socket !== socket) return;
+    this.socket = null;
+    this.stopHeartbeat();
+    if (this.helloDue) clearTimeout(this.helloDue);
+    this.helloDue = null;
     try {
-      dir = JSON.parse(`"${found[1]}"`);
+      socket.close(4e3, reason);
     } catch {
-      continue;
     }
-    if (isSamePath(dir, cwd)) return rollout.id;
+    this.hooks.onDrop?.(reason);
+    if (this.hooks.reconnect !== false) this.schedule();
+    else this.stop();
   }
-  return null;
-}
-function isMainChatThread(roots, threadId) {
-  const path2 = fetchCodexRolloutPath(roots, threadId);
-  if (!path2) return true;
-  try {
-    const fd = openSync(path2, "r");
-    try {
-      const buffer = Buffer.alloc(64 * 1024);
-      const head = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString("utf8");
-      return isMainChatRollout(head.split("\n")[0] ?? "");
-    } finally {
-      closeSync(fd);
-    }
-  } catch {
-    return true;
+  releaseWaiters() {
+    const waiters = [...this.waiters];
+    this.waiters.clear();
+    for (const waiter of waiters) waiter(null);
   }
-}
-function fetchCodexRolloutPath(roots, threadId) {
-  const suffix = `-${threadId}.jsonl`;
-  let best = null;
-  const findRolloutInDirectory = (dir, depth) => {
-    let entries;
-    try {
-      entries = readdirSync2(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const path2 = join8(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (depth < 3) findRolloutInDirectory(path2, depth + 1);
-        continue;
-      }
-      if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(suffix)) continue;
+  stopHeartbeat() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    if (this.pongDue) clearTimeout(this.pongDue);
+    this.heartbeat = null;
+    this.pongDue = null;
+  }
+  schedule() {
+    if (this.stopped) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.attempt += 1;
+    this.timer = setTimeout(() => void this.connect(), Math.min(3e4, 1e3 * 2 ** Math.min(this.attempt, 5)));
+  }
+  /** Another process holds this session now: look now and then, and take it back once it is no longer live. */
+  standBy() {
+    if (this.stopped) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(async () => {
+      if (this.stopped) return;
+      let holder = true;
       try {
-        const mtime = statSync3(path2).mtimeMs;
-        if (!best || mtime > best.mtime) best = { path: path2, mtime };
+        const sessions = await this.api.get(`/projects/${this.projectId}/sessions`, ApiResponses.Sessions);
+        holder = sessions.some((session) => session.id === this.session?.id && session.state === "live");
       } catch {
       }
-    }
-  };
-  for (const root of roots) findRolloutInDirectory(root, 0);
-  return best ? best.path : null;
-}
-function resolveCodexBinary() {
-  try {
-    execFileSync4(process.platform === "win32" ? "where" : "which", ["codex"], { stdio: "ignore" });
-    return "codex";
-  } catch {
+      if (holder) this.standBy();
+      else void this.connect();
+    }, STANDBY_POLL_MS);
   }
-  if (parseHarnessFromCommand(fetchParentCommand()) === "codex" && process.platform !== "win32") {
+  stop(reason = "released") {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.releaseWaiters();
+    for (const greeting of [...this.greetings]) greeting(null);
+    if (this.helloDue) clearTimeout(this.helloDue);
+    this.helloDue = null;
+    if (reason !== "handled" && this.api.sessionId === this.session?.id) this.api.sessionId = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.stopHeartbeat();
+    const socket = this.socket;
+    this.socket = null;
     try {
-      const exe = process.platform === "linux" ? readlinkSync(`/proc/${process.ppid}/exe`) : execFileSync4("ps", ["-o", "comm=", "-p", String(process.ppid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-      if (exe && basename2(exe).startsWith("codex")) return exe;
+      socket?.close(1e3, reason);
     } catch {
     }
   }
-  return "codex";
-}
-function fetchHarnessConversation(cwd) {
-  const harness = parseHarnessFromCommand(fetchParentCommand());
-  if (harness === "claude") {
-    const id = resolveClaudeSession()?.sessionId;
-    return id ? { id, harness } : null;
-  }
-  if (harness === "codex" && !isNonInteractiveHarness()) {
-    const id = fetchCodexConversationByCwd(fetchCodexHomes().map((home) => join8(home, "sessions")), cwd);
-    return id ? { id, harness } : null;
-  }
-  return null;
-}
-
-// src/platform/agent-identity.ts
-var processConversation = randomUUID4();
-var startedAt = Date.now();
-function fetchKnownConversation(cwd) {
-  const remembered = fetchRememberedConversation(cwd, startedAt - 12e4);
-  if (remembered?.harness === "codex" && isMainChatThread(fetchCodexHomes().map((home) => join9(home, "sessions")), remembered.id)) return remembered;
-  return fetchHarnessConversation(cwd) ?? remembered;
-}
-function resolveAgentIdentity(cwd, fallback = "process") {
-  const conversation = fetchKnownConversation(cwd);
-  const repo = fetchRepo();
-  return {
-    conversation: conversation?.id ?? (fallback === "process" ? processConversation : `dir:${resolve3(cwd)}`),
-    harness: conversation?.harness ?? null,
-    directory: repo ? basename3(repo.worktree) : basename3(cwd),
-    branch: fetchCurrentBranch(cwd)
-  };
-}
+};
 
 // src/platform/bounded.ts
 var RESULT_CAP = 16e3;
@@ -25093,45 +25657,99 @@ function truncateToolResult(result) {
 
 // src/platform/mcp.ts
 import { createInterface } from "readline";
-function serveMcp(tools, info) {
-  const sendJsonRpcMessage = (message) => process.stdout.write(`${JSON.stringify(message)}
-`);
+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 } });
-  const handleJsonRpcRequest = async (request) => {
-    const { id, method, params = {} } = request;
+  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") {
+      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)) {
+      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)) {
+          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 {
+          text = output2.formatResult(await tool.run(params.arguments ?? {}, output2));
+        } catch (error62) {
+          output2.releaseDeliveries();
+          await sendJsonRpcResult(id, { content: [{ type: "text", text: error62 instanceof Error ? error62.message : String(error62) }], isError: true });
           return;
         }
         try {
-          const text = await tool.run(params.arguments ?? {});
-          sendJsonRpcResult(id, { content: [{ type: "text", text }] });
+          await sendJsonRpcResult(id, { content: [{ type: "text", text }] });
+          output2.acknowledgeDeliveries();
         } catch (error62) {
-          sendJsonRpcResult(id, { content: [{ type: "text", text: error62 instanceof Error ? error62.message : String(error62) }], isError: true });
+          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) => 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) => {
     if (!line.trim()) return;
@@ -25139,20 +25757,19 @@ function serveMcp(tools, info) {
     try {
       request = JSON.parse(line);
     } catch {
-      sendJsonRpcError(null, -32700, "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);
   });
-  lines.on("close", () => process.exit(0));
 }
 
 // src/commands/tasks.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 
 // src/commands/items.ts
-import { readFileSync as readFileSync8 } from "fs";
-var fetchTextArgument = (value) => value === "-" ? readFileSync8(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> -";
@@ -25179,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] === "-" ? readFileSync8(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 })) });
@@ -25236,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 === "-" ? readFileSync9(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) {
@@ -25387,21 +26004,21 @@ ${buildTaskUrl(api.baseUrl, project.id, created)}`);
 }
 
 // src/platform/update-check.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname4, join as join10 } 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 = () => join10(dirname4(buildConfigPath()), "update-check.json");
+var buildUpdateCachePath = () => join14(dirname7(buildConfigPath()), "update-check.json");
 function fetchUpdateCache() {
   try {
-    return JSON.parse(readFileSync10(buildUpdateCachePath(), "utf8"));
+    return JSON.parse(readFileSync14(buildUpdateCachePath(), "utf8"));
   } catch {
     return { checkedAt: 0, latest: null };
   }
 }
 function persistUpdateCache(cache) {
-  mkdirSync5(dirname4(buildUpdateCachePath()), { recursive: true });
-  writeFileSync6(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));
@@ -25430,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(join10(dirname4(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 readFileSync11 } from "fs";
-var fetchTextArgument3 = (value) => value === "-" ? readFileSync11(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) {
@@ -25505,76 +26122,6 @@ function registerThreadCommands(program3, task) {
 }
 var formatStartedLine = (result) => result.thread.to.length ? `Started ${result.thread.id} to ${result.thread.to.map((recipient) => recipient.agent).join(", ")}${result.delivered ? `; ${result.delivered} of them ha${result.delivered === 1 ? "s" : "ve"} it now.` : "; they read it when they are back."}` : result.thread.taskKey ? result.delivered ? `Started ${result.thread.id} on ${result.thread.taskKey}; reached ${result.delivered} live session${result.delivered === 1 ? "" : "s"}.` : `Started ${result.thread.id} on ${result.thread.taskKey}. Nobody is live on it; they see it when they start.` : `Started ${result.thread.id} (general). People see it on the web; agents at their next session start.`;
 
-// src/platform/inbox.ts
-import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync12, readdirSync as readdirSync3, realpathSync as realpathSync3, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5, join as join11 } from "path";
-var buildInboxDir = () => join11(dirname5(buildConfigPath()), "inbox");
-var resolveRealCwd2 = (cwd) => {
-  try {
-    return realpathSync3(cwd);
-  } catch {
-    return cwd;
-  }
-};
-var generateInboxKey = (cwd) => createHash4("sha256").update(resolveRealCwd2(cwd)).digest("hex").slice(0, 16);
-var buildInboxPath = (cwd) => join11(buildInboxDir(), `${generateInboxKey(cwd)}.jsonl`);
-var buildInboxQueuePath = (cwd) => join11(buildInboxDir(), generateInboxKey(cwd));
-var sequence = 0;
-function persistInboxPush(cwd, push) {
-  const directory = buildInboxQueuePath(cwd);
-  mkdirSync6(directory, { recursive: true });
-  const name = `${Date.now()}.${process.pid}.${String(sequence++).padStart(12, "0")}.${randomUUID5()}`;
-  const temporary = join11(directory, `${name}.writing`);
-  writeFileSync7(temporary, JSON.stringify(push), { flag: "wx" });
-  renameSync(temporary, join11(directory, `${name}.json`));
-}
-function drainInbox(cwd) {
-  const pushes = drainLegacyInbox(cwd);
-  const directory = buildInboxQueuePath(cwd);
-  let names;
-  try {
-    names = readdirSync3(directory).filter((file2) => file2.endsWith(".json")).sort();
-  } catch (error62) {
-    if (error62.code === "ENOENT") return pushes;
-    throw error62;
-  }
-  for (const name of names) {
-    const taken = join11(directory, `${name}.${randomUUID5()}.draining`);
-    try {
-      renameSync(join11(directory, name), taken);
-    } catch (error62) {
-      if (error62.code === "ENOENT") continue;
-      throw error62;
-    }
-    try {
-      pushes.push(JSON.parse(readFileSync12(taken, "utf8")));
-    } finally {
-      rmSync4(taken, { force: true });
-    }
-  }
-  return pushes;
-}
-function drainLegacyInbox(cwd) {
-  const path2 = buildInboxPath(cwd);
-  if (!existsSync9(path2)) return [];
-  const taken = `${path2}.${process.pid}.${Date.now()}.draining`;
-  try {
-    renameSync(path2, taken);
-  } catch {
-    return [];
-  }
-  const lines = readFileSync12(taken, "utf8").split("\n").filter(Boolean);
-  rmSync4(taken, { force: true });
-  return lines.flatMap((line) => {
-    try {
-      return [JSON.parse(line)];
-    } catch {
-      return [];
-    }
-  });
-}
-
 // src/commands/mcp.ts
 var buildStringSchema = (description2) => ({ type: "string", description: description2 });
 var buildIntegerSchema = (description2) => ({ type: "integer", description: description2 });
@@ -25593,139 +26140,142 @@ var formatSessionLine = (session, mine = null) => [
   session.reachable ? "" : "(not visible to teammates)"
 ].filter(Boolean).join("  ");
 async function buildUnreadDigest(api, projectId, taskKey) {
-  const [about, mine, general] = await Promise.all([
+  const [about, general] = await Promise.all([
     taskKey ? api.get(`/projects/${projectId}/threads?task=${encodeURIComponent(taskKey)}&unread=1&read=1`, ApiResponses.Threads) : Promise.resolve([]),
-    api.get(`/projects/${projectId}/threads?participant=1&unread=1&read=1`, ApiResponses.Threads),
     api.get(`/projects/${projectId}/threads?scope=general&unread=1&read=1`, ApiResponses.Threads)
   ]);
   const lines = [];
   if (about.length) lines.push(`Unread about ${taskKey} (read one with the thread tool):`, ...about.map(formatThreadLine));
-  const elsewhere = mine.filter((thread) => !about.some((candidate) => candidate.id === thread.id));
-  if (elsewhere.length) lines.push("Unread in threads you are part of (answers to you):", ...elsewhere.map(formatThreadLine));
   if (general.length) lines.push("Unread general threads (context; nobody has to answer):", ...general.map(formatThreadLine));
   return lines.length ? lines.join("\n") : "Nothing unread.";
 }
-async function persistMissedPushes(api, projectId, taskKey, cwd) {
-  const [mine, about] = await Promise.all([
-    api.get(`/projects/${projectId}/threads?participant=1&unread=1`, ApiResponses.Threads),
-    taskKey ? api.get(`/projects/${projectId}/threads?task=${encodeURIComponent(taskKey)}&unread=1`, ApiResponses.Threads) : Promise.resolve([])
-  ]);
-  const seen = /* @__PURE__ */ new Set();
-  for (const thread of [...about, ...mine]) {
-    if (seen.has(thread.id) || thread.unread === 0) continue;
-    seen.add(thread.id);
-    const detail = await api.get(`/projects/${projectId}/threads/${thread.id}?read=0`, ApiResponses.ThreadDetail);
-    for (const message of detail.messages.slice(-thread.unread)) persistInboxPush(cwd, { thread: { id: detail.id, subject: detail.subject, taskKey: detail.taskKey, to: detail.to.length ? detail.to.map((recipient) => recipient.agent).join(", ") : null }, message });
+async function fetchProjectsOverview(api) {
+  const list = await api.get("/projects", ApiResponses.Projects);
+  let linked = null;
+  try {
+    linked = (await resolveProject(api)).key;
+  } catch {
   }
-}
-function buildToolHandlers() {
-  const api = buildAuthedApiClient();
-  const resolveProjectFromArgs = (args) => resolveProject(api, args.project);
+  return list.map((project) => `${project.key === linked ? "* " : "  "}${project.key}  ${project.name}  (${project.openTaskCount} open)`).join("\n") + (linked ? "" : "\n\nThis repository is not linked: slop link <KEY>");
+}
+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 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 identity = null;
-  const resolveOwnAgentIdentity = () => identity ??= resolveAgentIdentity(process.cwd());
-  const formatWakeMessage = (pushes) => `${pushes.length > 1 ? `${pushes.length} messages` : "A message"} for you on Slopware Tasks. ${pushes.length > 1 ? "They" : "It"} waited for your turn and others may have followed: read the thread (threads read) if it may be stale, act, and answer once (say reply) only if something is asked that you have not given yet. Do not acknowledge. Then carry on.
-
-${pushes.map(formatPushBlock).join("\n\n")}`;
+  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 (held && held.projectId === projectId && held.taskKey === taskKey) return;
+    if (stopped) throw new Error("The project session is stopping");
+    if (held && !held.isStopped && held.projectId === projectId && held.taskKey === taskKey) {
+      await held.requireSession();
+      return;
+    }
+    await recovery.syncCursor();
+    if (stopped) throw new Error("The project session is stopping");
+    if (held && !held.isStopped && held.taskKey === taskKey) {
+      await held.requireSession();
+      return;
+    }
     held?.stop();
     held = new HeldSession(api, projectId, taskKey, {
-      // Claude Code is woken over its session socket: the message arrives as a turn, now, idle or not (mid-turn it
-      // rides the next tool result). Codex is handed the message with `codex queue` to its thread: idle, that starts
-      // a turn at once; mid-turn, it becomes the next turn when the running one ends, which is why the skills tell
-      // agents to treat messages as letters that may be read late. When neither can be done the message waits in
-      // the inbox and rides the chat's next slop tool result. Nothing holds a turn open.
-      onMessage: (push) => {
-        const me = resolveOwnAgentIdentity();
-        const wake = me.harness === "codex" && me.conversation ? wakeCodex(formatWakeMessage([push]), me.conversation, { binary: resolveCodexBinary(), codexHome: resolveOwnHarnessHome("CODEX_HOME") }) : wakeHarness(formatWakeMessage([push]));
-        void wake.then((woken) => {
-          if (!woken) persistInboxPush(process.cwd(), push);
-        });
-      },
+      onPush: persistOwnInboxPush,
+      onMessage: wakeOwnHarness,
       claim: resolveOwnAgentIdentity,
-      onReconnect: (session) => persistMissedPushes(api, projectId, session.taskKey, process.cwd()).catch(() => void 0)
+      onReconnect: () => recovery.sync()
     });
-    await held.start();
+    const current = held;
+    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);
-    if (!held) await holdSession(target.id, null);
-    await held?.ready;
+    if (!held || held.isStopped) await holdSession(target.id, null);
+    await held?.requireSession();
     return target;
   };
   const releaseTaskSession = async () => {
     if (held?.taskKey) await holdSession(held.projectId, null);
   };
-  if (!isNonInteractiveHarness())
-    void (async () => {
-      for (let waited = 0; waited < 1e4 && !fetchKnownConversation(process.cwd()); waited += 250) await new Promise((resolve5) => setTimeout(resolve5, 250));
-      resolveOwnAgentIdentity();
-      const target = await resolveProjectFromArgs({});
-      if (!held) await holdSession(target.id, null);
-    })().catch(() => void 0);
-  if (!isNonInteractiveHarness()) void trustCodexHooksForOwnHome().catch(() => void 0);
-  const endSessionAndExit = () => {
-    held?.stop();
-    held = null;
-    setTimeout(() => process.exit(0), 300).unref();
-  };
-  process.stdin.once("end", endSessionAndExit);
-  for (const signal of ["SIGTERM", "SIGHUP", "SIGINT"]) process.once(signal, endSessionAndExit);
-  const waitForNextMessage = async (thread, minutes) => {
-    const queued = drainInbox(process.cwd());
-    const wanted = queued.filter((push) => !thread || push.thread.id === thread);
-    for (const other of queued) if (!wanted.includes(other)) persistInboxPush(process.cwd(), other);
-    if (wanted.length) return { pushes: wanted, released: false };
-    return new Promise((resolve5) => {
+  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 { received: false, released: true };
+    return new Promise((resolve6) => {
       const acceptDeliveredPush = (delivered) => {
         if (delivered && thread && delivered.thread.id !== thread) return false;
-        held?.waiters.delete(acceptDeliveredPush);
+        if (delivered && !claimOwnInbox(output2, (push) => push.message.id === delivered.message.id)) return false;
+        waitingOn.waiters.delete(acceptDeliveredPush);
         clearTimeout(timer);
-        resolve5({ pushes: delivered ? [delivered] : [], released: delivered === null });
+        resolve6({ received: delivered !== null, released: delivered === null });
         return true;
       };
-      held?.waiters.add(acceptDeliveredPush);
+      waitingOn.waiters.add(acceptDeliveredPush);
       const timer = setTimeout(() => {
-        held?.waiters.delete(acceptDeliveredPush);
-        resolve5({ pushes: [], released: false });
+        waitingOn.waiters.delete(acceptDeliveredPush);
+        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.released) return "Your person made you not visible to teammates: nothing can reach you now. You may stop.";
+    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.`;
   };
-  return [
+  const tools = [
     {
       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 = drainInbox(process.cwd()).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) });
@@ -25733,14 +26283,14 @@ ${pushes.map(formatPushBlock).join("\n\n")}`;
         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(", ");
@@ -25748,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)}`;
       }
     },
     {
@@ -26005,21 +26555,6 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
         return members2.map((member) => `${member.name}  ${member.email}  ${member.role}`).join("\n");
       }
     },
-    {
-      name: "projects",
-      description: "Every project you can reach, and which one this repository is linked to.",
-      inputSchema: buildToolSchema({}),
-      run: async () => {
-        const list = await api.get("/projects", ApiResponses.Projects);
-        let linked = null;
-        try {
-          linked = (await resolveProjectFromArgs({})).key;
-        } catch {
-          linked = null;
-        }
-        return list.map((candidate) => `${candidate.key === linked ? "* " : "  "}${candidate.key}  ${candidate.name}  (${candidate.openTaskCount} open)`).join("\n") + (linked ? "" : "\n\nThis repository is not linked: slop link <KEY>");
-      }
-    },
     {
       name: "finish_task",
       description: "Move a task to the first done column.",
@@ -26032,35 +26567,48 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
       }
     }
   ];
+  return {
+    start: () => holdSession(project.id, null),
+    stop: () => {
+      stopped = true;
+      recovery.stop();
+      held?.stop();
+    },
+    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(readFileSync13(path2, "utf8"));
+    return JSON.parse(readFileSync16(path2, "utf8"));
   } catch {
     return {};
   }
 }
 function installIntoClaudeHome(dir) {
   const done = [];
-  const primary = dir === join12(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 = join12(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;
@@ -26083,31 +26631,31 @@ function mergeHooks(hooks, harness) {
 }
 function installIntoCodexHome(dir) {
   const done = [];
-  mkdirSync7(dir, { recursive: true });
-  const configTomlPath = join12(dir, "config.toml");
-  const current = existsSync10(configTomlPath) ? readFileSync13(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 = join12(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 === join12(homedir4(), ".codex") ? "" : ` under ${codexHome}`;
+  const where = codexHome === join15(homedir4(), ".codex") ? "" : ` under ${codexHome}`;
   let buffer = "";
   const pending = /* @__PURE__ */ new Map();
   server.stdout.on("data", (chunk) => {
@@ -26125,7 +26673,7 @@ async function trustCodexHooks(codexHome) {
     }
   });
   let nextId = 1;
-  const callCodexMethod = (method, params) => new Promise((resolve5, reject) => {
+  const callCodexMethod = (method, params) => new Promise((resolve6, reject) => {
     const id = nextId++;
     const timer = setTimeout(() => {
       pending.delete(id);
@@ -26134,7 +26682,7 @@ async function trustCodexHooks(codexHome) {
     pending.set(id, (message) => {
       clearTimeout(timer);
       if (message.error) reject(new Error(message.error.message ?? `${method} failed`));
-      else resolve5(message.result);
+      else resolve6(message.result);
     });
     server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `);
@@ -26142,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.8" }, 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 "));
@@ -26158,22 +26706,12 @@ async function trustCodexHooks(codexHome) {
     server.kill();
   }
 }
-async function trustCodexHooksForOwnHome() {
-  const home = resolveOwnHarnessHome("CODEX_HOME");
-  if (!home) return;
-  const hooksPath = join12(home, "hooks.json");
-  const configTomlPath = join12(home, "config.toml");
-  if (!existsSync10(hooksPath) || !existsSync10(configTomlPath)) return;
-  if (!readFileSync13(hooksPath, "utf8").includes("slop hook stop")) return;
-  if (readFileSync13(configTomlPath, "utf8").includes(`hooks.state."${hooksPath}:stop:`)) return;
-  await trustCodexHooks(home);
-}
 async function parseHookInput(harness, remember = true) {
-  const input2 = await new Promise((resolve5) => {
+  const input2 = await new Promise((resolve6) => {
     let data = "";
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve5(data));
-    setTimeout(() => resolve5(data), 2e3).unref();
+    process.stdin.on("end", () => resolve6(data));
+    setTimeout(() => resolve6(data), 2e3).unref();
   });
   let cwd = process.cwd();
   let conversation = null;
@@ -26183,7 +26721,7 @@ async function parseHookInput(harness, remember = true) {
     conversation = parsed.session_id ?? null;
   } catch {
   }
-  const ownThread = harness !== "codex" || !conversation || isMainChatThread(fetchCodexHomes().map((home) => join12(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 };
 }
@@ -26235,20 +26773,49 @@ ${parts.join("\n")}` })}
 }
 function buildTools() {
   if (isNonInteractiveHarness()) return [];
-  const fine = buildToolHandlers();
-  const runHandlerByName = (name, args) => {
-    const handler = fine.find((candidate) => candidate.name === name);
-    if (!handler) throw new Error(`No such action`);
-    return handler.run(args);
+  const api = buildAuthedApiClient();
+  let identity = null;
+  let stopped = false;
+  const projects = /* @__PURE__ */ new Map();
+  const requireProjectTools = (project) => {
+    if (stopped) throw new Error("The MCP server is stopping");
+    let context = projects.get(project.id);
+    if (!context) {
+      identity ??= resolveAgentIdentity(process.cwd());
+      context = createProjectTools(buildAuthedApiClient(), project, identity);
+      projects.set(project.id, context);
+    }
+    return context;
+  };
+  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, output2);
+  };
+  void (async () => {
+    for (let waited = 0; waited < 1e4 && !fetchKnownConversation(process.cwd()) && !stopped; waited += 250) await new Promise((resolve6) => setTimeout(resolve6, 250));
+    if (stopped) return;
+    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(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 [
@@ -26285,17 +26852,12 @@ function buildTools() {
     )
   ];
 }
-function attachInboxToTools(list, version2) {
+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];
-      if (!(tool.name === "session" && (args.action === "check" || args.action === "wait"))) {
-        const arrived = drainInbox(process.cwd());
-        if (arrived.length) parts.push(`--- Messages arrived while you worked (answer what is still open, once; do not acknowledge) ---
-${arrived.map(formatPushBlock).join("\n\n")}`);
-      }
       const notice = isUpdateCheckEnabled() ? buildUpdateNotice(version2) : null;
       if (notice) parts.push(notice);
       return parts.join("\n\n");
@@ -26304,13 +26866,13 @@ ${arrived.map(formatPushBlock).join("\n\n")}`);
 }
 function registerMcpCommands(program3, version2) {
   const mcp = program3.command("mcp").description("The MCP server: the board and its threads as tools for Claude Code, Codex and any MCP client. Holds your live session while it runs.");
-  mcp.command("serve", { isDefault: true }).description("Serve MCP over stdio (what the harness runs).").action(() => serveMcp(attachInboxToTools(buildTools(), version2), { name: "slop", version: version2 }));
+  mcp.command("serve", { isDefault: true }).description("Serve MCP over stdio (what the harness runs).").action(() => serveMcp(attachUpdateNoticeToTools(buildTools(), version2), { name: "slop", version: version2 }));
   mcp.command("install").description("Register the server and the two hooks with Claude Code and Codex on this machine.").action(async () => {
     const homes = fetchCodexHomes();
     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;
     }
@@ -26326,10 +26888,9 @@ function registerMcpCommands(program3, version2) {
 }
 
 // src/commands/sessions.ts
-import { readFileSync as readFileSync14 } from "fs";
 var buildTaskPath2 = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
 var formatSessionLine2 = (session) => [session.agent?.name ?? "agent", session.taskKey ?? "(no task)", session.user.name, session.machine.name, session.where?.directory ? `${session.where.directory}${session.where.branch ? `@${session.where.branch}` : ""}` : "-", session.startedAt, session.state === "reconnecting" ? "reconnecting" : "live"];
-function registerSessionCommands(program3, task) {
+function registerSessionCommands(program3) {
   const registerProjectOption = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
   const session = program3.command("session").description("Claim a task and be reachable on it while you work.");
   registerProjectOption(session.command("start <key>")).description("Claim a task: assign it to you, move it to the first in-progress column, then tell you how to go live.").action(async (key, options) => {
@@ -26411,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.8").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, taskCommand);
+registerSessionCommands(program2);
 registerThreadCommands(program2, taskCommand);
-registerMcpCommands(program2, "0.4.8");
+registerMcpCommands(program2, "0.4.10");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(exitWithError);