slopwaresystems 0.3.0 → 0.4.1

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`), `columns`, `members`, `projects` |\n| `task` | `show`, `create`, `update` (only given fields change), `move`, `link`, `archive`, `restore`, `history`, `finish` |\n| `plan` | `add` (`items`), `note`, `done`, `reopen`, `rename`, `remove` (by `item` number) |\n| `session` | `claim`, `release`, `who`, `check`, `wait` (see `slop-sessions`) |\n| `threads` | `list`, `read` |\n| `say` | `post` (new thread; with `task` it reaches whoever is live on it, without it is general), `reply` |\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` (optional; messages reach you on their own; 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` |\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";
 
 // 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 `slop session wait` background task finishes, 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## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, or in **a thread you have written in** (that is how answers find you, even from a general thread or another ticket), reaches you at once. Nothing else does.\n- **Everything else waits.** `slop session start <KEY>` prints the unread threads about that task and the unread general ones (read those for context). `slop threads` lists them any time; `slop thread show <id>` reads one.\n- Your own messages never wake your own waiter.\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. Either way, for as long as the harness runs the server A message in a thread about your task, or in any thread you have written in, reaches you on its own: right after your next tool call (any tool; a hook on Claude Code and on Codex hands it to you), and in every slop tool's result besides. There is nothing to poll and nothing to restart. When one arrives, act or answer with `say` `reply` and carry on.\n4. **Nothing to do but wait?** `session` `wait` blocks until the next message. Optional; most of the time you just keep working.\n5. **Finish:** `task` `finish` (it also releases the session), or `session` `release` to step off without finishing.\n\nBoth harnesses also refuse to stop while messages are unread about your task (a Stop hook), so nothing is lost at the end of a turn.\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                                 who is live on what\nthreads list (task?, unread?)               list; threads read (id) reads one (marks it read)\nsay reply (thread, body)                    in a task thread: reaches whoever is live on it, or waits for them\nsay post (subject, body, task: \"WEB-12\")    a new thread about a task\nsay post (subject, body)                    a general thread: for people, and for context\n```\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.\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 messages about your task promptly: the other agent is blocked on you.\n- Report progress in the plan's notes, not in threads. Threads are for talking to someone.\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 `slop session wait` background task finishes, 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## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, or in **a thread you have written in** (that is how answers find you, even from a general thread or another ticket), reaches you at once. Nothing else does.\n- **Everything else waits.** `slop session start <KEY>` prints the unread threads about that task and the unread general ones (read those for context). `slop threads` lists them any time; `slop thread show <id>` reads one.\n- Your own messages never wake your own waiter.\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. Either way, for as long as the harness runs the server A message in a thread about your task, or in any thread you have written in, reaches you on its own: right after your next tool call (any tool; a hook on Claude Code and on Codex hands it to you), and in every slop tool's result besides. There is nothing to poll and nothing to restart. When one arrives, act or answer with `say` `reply` and carry on.\n4. **Nothing to do but wait?** `session` `wait` blocks until the next message. Optional; most of the time you just keep working.\n5. **Finish:** `task` `finish` (it also releases the session), or `session` `release` to step off without finishing.\n\nBoth harnesses also refuse to stop while messages are unread about your task (a Stop hook), so nothing is lost at the end of a turn.\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 its addressee\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)                             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**Messages find you.** Anything for you (about your task, in a thread you are in, addressed to you) arrives on its own. On Claude Code it arrives as a turn of yours, even while you are idle. On Codex, when your turn ends the Stop hook waits on your behalf, costing nothing, and continues your turn the moment a message arrives; your person typing comes first and you wait again after. Otherwise it arrives with your next tool result. Act or answer it (`say` `reply`), then carry on. If your person makes you not visible to teammates, nothing reaches you and you cannot post or reply until they switch it back.\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.\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 messages about your task promptly: the other agent is blocked on you.\n- Report progress in the plan's notes, not in threads. Threads are for talking to someone.\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";
@@ -3398,11 +3398,11 @@ function installSkills({ force = false } = {}) {
   const written = [];
   for (const home of SKILL_HOMES) {
     for (const [name, markdown] of Object.entries(SKILLS)) {
-      const file2 = join(home, name, "SKILL.md");
-      if (!force && existsSync(file2) && readFileSync(file2, "utf8") === markdown) continue;
+      const file3 = join(home, name, "SKILL.md");
+      if (!force && existsSync(file3) && readFileSync(file3, "utf8") === markdown) continue;
       mkdirSync(join(home, name), { recursive: true });
-      writeFileSync(file2, markdown);
-      written.push(file2);
+      writeFileSync(file3, markdown);
+      written.push(file3);
     }
   }
   return written;
@@ -8438,7 +8438,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve2) {
+function isRecursive(inst, stack, resolve5) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -8448,7 +8448,7 @@ function isRecursive(inst, stack, resolve2) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve2);
+      const answer = isRecursive(child, stack, resolve5);
       if (answer > result)
         result = answer;
     }
@@ -8459,7 +8459,7 @@ function isRecursive(inst, stack, resolve2) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve2) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -8523,7 +8523,7 @@ function isRecursive(inst, stack, resolve2) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve2 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -19054,12 +19054,12 @@ function processSchema(schema2, ctx, _params = { path: [], schemaPath: [] }) {
       }
       processor(schema2, ctx, _json, params);
     }
-    const parent = schema2._zod.parent;
-    if (parent) {
+    const parent2 = schema2._zod.parent;
+    if (parent2) {
       if (!result.ref)
-        result.ref = parent;
-      processSchema(parent, ctx, params);
-      ctx.seen.get(parent).isParent = true;
+        result.ref = parent2;
+      processSchema(parent2, ctx, params);
+      ctx.seen.get(parent2).isParent = true;
     }
   }
   const meta3 = ctx.metadataRegistry.get(schema2);
@@ -19322,10 +19322,10 @@ function finalize(ctx, schema2) {
         }
       }
     }
-    const parent = zodSchema._zod.parent;
-    if (parent && parent !== ref) {
-      flattenRef(parent);
-      const parentSeen = ctx.seen.get(parent);
+    const parent2 = zodSchema._zod.parent;
+    if (parent2 && parent2 !== ref) {
+      flattenRef(parent2);
+      const parentSeen = ctx.seen.get(parent2);
       if (parentSeen?.schema.$ref) {
         schema3.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
@@ -23130,9 +23130,13 @@ var User = external_exports.object({
   avatarUrl: external_exports.string().nullable(),
   /** False for accounts that only ever signed in with a code. */
   hasPassword: external_exports.boolean(),
+  /** New sessions of this person's agents start reachable by teammates (visible, messaged, messaging). */
+  shareAgents: external_exports.boolean(),
+  /** The first sign-in's welcome (the agent prompt) has been shown. */
+  welcomed: external_exports.boolean(),
   createdAt: Timestamp
 });
-var UpdateMeInput = external_exports.object({ name: external_exports.string().trim().min(1).max(80) });
+var UpdateMeInput = external_exports.object({ name: external_exports.string().trim().min(1).max(80).optional(), shareAgents: external_exports.boolean().optional(), welcomed: external_exports.literal(true).optional() });
 var AVATAR_CONTENT_TYPES = ["image/webp", "image/jpeg", "image/png"];
 var AVATAR_MAX_BYTES = 1e5;
 var SetAvatarInput = external_exports.object({
@@ -23209,12 +23213,14 @@ var Invitation = external_exports.object({
 });
 var InviteLink = external_exports.object({
   id: Id,
+  /** Who it is for, as typed when it was made; shown in the members table so a link can be told from another. */
+  label: external_exports.string().nullable(),
   role: OrgRole,
   createdAt: Timestamp,
   expiresAt: Timestamp.nullable(),
   uses: external_exports.number()
 });
-var CreateInviteLinkInput = external_exports.object({ role: OrgRole.default("member"), expiresInHours: external_exports.number().int().min(1).max(24 * 30).nullable().default(24) });
+var CreateInviteLinkInput = external_exports.object({ role: OrgRole.default("member"), expiresInHours: external_exports.number().int().min(1).max(24 * 30).nullable().default(24), label: external_exports.string().trim().max(120).optional() });
 var CreatedInviteLink = InviteLink.extend({ url: external_exports.string() });
 var JoinPreview = external_exports.object({ org: external_exports.object({ id: Id, name: external_exports.string() }), role: OrgRole, alreadyMember: external_exports.boolean() });
 var MembersResult = external_exports.object({
@@ -23314,6 +23320,8 @@ var ThreadMessage = external_exports.object({
   /** A person on the web, or an agent through the CLI (with its machine). */
   via: MessageVia,
   machine: external_exports.string().nullable(),
+  /** The agent's name, when a live session wrote it; null for a person, or an older CLI. */
+  agent: external_exports.string().nullable(),
   body: external_exports.string(),
   createdAt: Timestamp
 });
@@ -23324,20 +23332,25 @@ var Thread = external_exports.object({
   taskId: Id.nullable(),
   taskKey: external_exports.string().nullable(),
   subject: external_exports.string(),
+  /** Addressed to one live agent (by its session); replies reach it wherever it is. Null: to the task's agents, or general. */
+  to: external_exports.object({ sessionId: external_exports.string(), agent: external_exports.string() }).nullable(),
   createdBy: UserRef,
   createdAt: Timestamp,
   lastMessageAt: Timestamp,
   messageCount: external_exports.number(),
   /** Messages the viewer has not read. Their own count as read. */
   unread: external_exports.number(),
-  last: external_exports.object({ author: UserRef, via: MessageVia, body: external_exports.string() }).nullable()
+  last: external_exports.object({ author: UserRef, via: MessageVia, agent: external_exports.string().nullable(), body: external_exports.string() }).nullable()
 });
-var ThreadDetail = Thread.extend({ messages: external_exports.array(ThreadMessage) });
+var ThreadDetail = Thread.extend({ messages: external_exports.array(ThreadMessage), earlier: external_exports.number().default(0) });
 var body = external_exports.string().trim().min(1, "Say something").max(8e3);
 var CreateThreadInput = external_exports.object({
-  subject: external_exports.string().trim().min(1, "Give it a subject").max(200),
+  /** Absent, the first line of the body is the subject. */
+  subject: external_exports.string().trim().min(1, "Give it a subject").max(200).optional(),
   /** A task key or number; absent means general. */
   task: external_exports.string().trim().min(1).optional(),
+  /** A live agent, by session id or name (as `session who` lists them). */
+  to: external_exports.string().trim().min(1).max(200).optional(),
   body
 });
 var ReplyInput = external_exports.object({ body });
@@ -23440,14 +23453,35 @@ var TaskEventRecord = external_exports.object({
 });
 
 // ../contract/src/work/sessions.ts
+var AgentHarness = external_exports.enum(["claude", "codex", "other"]);
 var Session = external_exports.object({
+  /** Derived from the person, the machine and the agent's conversation: the same across reconnects and resumes. */
   id: Id,
   /** Null: the agent is live in the project but on no task yet (presence). Replies in threads it is part of still reach it. */
   taskId: Id.nullable(),
   taskKey: external_exports.string().nullable(),
   user: UserRef,
   machine: external_exports.object({ id: Id, name: external_exports.string() }),
-  startedAt: Timestamp
+  /** The agent itself: a generated name (see agent-names) and which harness runs it. */
+  agent: external_exports.object({ name: external_exports.string(), harness: AgentHarness.nullable() }),
+  /** Where it runs, to tell two agents under one person apart. */
+  where: external_exports.object({ directory: external_exports.string().nullable(), branch: external_exports.string().nullable() }),
+  startedAt: Timestamp,
+  /** "reconnecting": its socket dropped and the room is holding the session open for it to come back. */
+  state: external_exports.enum(["live", "reconnecting"]),
+  /**
+   * Reachable by teammates: listed to them, messaged by them and by their agents, and able to message. Off, the agent
+   * still works the board but talks to nobody and is listed only to its own person. Starts from the person's default.
+   */
+  reachable: external_exports.boolean().default(true)
+});
+var ReachableInput = external_exports.object({ on: external_exports.boolean() });
+var SessionClaimInput = external_exports.object({
+  /** Stable for one conversation of the agent (the harness's own session id), so a resumed chat is the same session and keeps its name. */
+  conversation: external_exports.string().trim().min(1).max(200).optional(),
+  harness: AgentHarness.nullable().default(null),
+  directory: external_exports.string().trim().max(200).nullable().default(null),
+  branch: external_exports.string().trim().max(200).nullable().default(null)
 });
 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) });
@@ -23455,13 +23489,127 @@ 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() }), message: ThreadMessage }),
+  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 }),
   /** 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. */
+  external_exports.object({ type: external_exports.literal("reachable"), on: external_exports.boolean() }),
   /** To board watchers: something in the project changed; refetch. */
   external_exports.object({ type: external_exports.literal("changed"), scope: external_exports.string() })
 ]);
 
+// ../contract/src/work/agent-names.ts
+var AGENT_NAMES = [
+  "Albert",
+  "Alma",
+  "Amos",
+  "Astrid",
+  "August",
+  "Beatrix",
+  "Bruno",
+  "Cedric",
+  "Clara",
+  "Cosmo",
+  "Dahlia",
+  "Dexter",
+  "Edie",
+  "Elio",
+  "Ember",
+  "Felix",
+  "Fern",
+  "Flora",
+  "Gus",
+  "Hazel",
+  "Hugo",
+  "Ida",
+  "Ingrid",
+  "Iris",
+  "Jasper",
+  "Juno",
+  "Kit",
+  "Leo",
+  "Lila",
+  "Linus",
+  "Lotte",
+  "Mabel",
+  "Marlow",
+  "Milo",
+  "Minnie",
+  "Nell",
+  "Nico",
+  "Nina",
+  "Odette",
+  "Olive",
+  "Oscar",
+  "Otto",
+  "Pearl",
+  "Percy",
+  "Pip",
+  "Quill",
+  "Remy",
+  "Rosa",
+  "Rufus",
+  "Sable",
+  "Silas",
+  "Sky",
+  "Sol",
+  "Tess",
+  "Theo",
+  "Tilly",
+  "Ulla",
+  "Vera",
+  "Vito",
+  "Wren",
+  "Xavi",
+  "Yara",
+  "Zed",
+  "Zora",
+  "Arlo",
+  "Bea",
+  "Cyrus",
+  "Della",
+  "Enzo",
+  "Frida",
+  "Gilda",
+  "Hal",
+  "Imre",
+  "Joss",
+  "Kai",
+  "Lena",
+  "Mona",
+  "Nate",
+  "Opal",
+  "Pia",
+  "Rae",
+  "Sacha",
+  "Tove",
+  "Uma",
+  "Vince",
+  "Willa",
+  "Yuki",
+  "Zelda",
+  "Ansel",
+  "Birdie",
+  "Cleo",
+  "Dov",
+  "Esme",
+  "Fitz",
+  "Greta",
+  "Hollis",
+  "Inez",
+  "Jude",
+  "Kip",
+  "Lark"
+];
+function agentNameFor(key) {
+  let hash2 = 2166136261;
+  for (let index = 0; index < key.length; index += 1) {
+    hash2 ^= key.charCodeAt(index);
+    hash2 = Math.imul(hash2, 16777619) >>> 0;
+  }
+  return AGENT_NAMES[hash2 % AGENT_NAMES.length] ?? AGENT_NAMES[0];
+}
+
 // ../contract/src/work/bindings.ts
 var RepoInfo = external_exports.object({
   /**
@@ -23520,7 +23668,7 @@ 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, writeFileSync as writeFileSync3 } from "fs";
+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 sessionsDir = () => join3(dirname2(configPath()), "sessions");
 var realCwd = (cwd) => {
@@ -23540,6 +23688,21 @@ function rememberedSession(cwd) {
   const path3 = sessionFile(cwd);
   return existsSync3(path3) ? readFileSync3(path3, "utf8").trim() || null : null;
 }
+var conversationFile = (cwd) => join3(sessionsDir(), `${createHash("sha256").update(realCwd(cwd)).digest("hex").slice(0, 16)}.conversation.json`);
+function rememberConversation(cwd, conversation) {
+  mkdirSync3(sessionsDir(), { recursive: true });
+  writeFileSync3(conversationFile(cwd), JSON.stringify(conversation));
+}
+function rememberedConversation(cwd, notBefore) {
+  const path3 = conversationFile(cwd);
+  try {
+    if (statSync(path3).mtimeMs < notBefore) return null;
+    const parsed = JSON.parse(readFileSync3(path3, "utf8"));
+    return typeof parsed.id === "string" && parsed.id ? { id: parsed.id, harness: parsed.harness ?? "other" } : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/platform/errors.ts
 var CliError = class extends Error {
@@ -23775,7 +23938,7 @@ This repository is linked to a Slopware Tasks board. Use the \`slop\` CLI to kee
 - Before starting tracked work: \`slop task list\`, then \`slop task start <KEY>\`.
 - When it is finished and verified: \`slop task done <KEY>\`.
 - Descriptions are Markdown and are shown in full on the board. Write real ones: context, file paths, what done means. Pipe long ones in with \`-d -\`.
-- Agents use the six slop MCP tools for everything on the board (\`slop mcp install\` once per machine): \`board\`, \`task\`, \`plan\`, \`session\`, \`threads\`, \`say\`, each with an \`action\`. Messages about your task reach you after your next tool call. The \`slop\` command is for people and scripts. Talk through threads: \`slop task ask <KEY> "\u2026"\` reaches whoever is live on that task, \`slop thread reply <id> "\u2026"\` answers, \`slop threads\` lists them; general threads are for people and for context. Method: \`slop skill slop-sessions\`.
+- Agents use the six slop MCP tools for everything on the board (\`slop mcp install\` once per machine): \`board\`, \`task\`, \`plan\`, \`session\`, \`threads\`, \`say\`, each with an \`action\`. You have a name (session start tells you; \`session who\` lists everyone's); \`say post\` with \`to\` reaches one agent by name. Messages for you reach you after your next tool call. 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.
@@ -23805,6 +23968,10 @@ function findRepo() {
   const root = basename(commonDir) === ".git" ? resolve(commonDir, "..") : worktree ?? commonDir;
   return { root, worktree: worktree ?? root, linkPath: join5(commonDir, "slop.json") };
 }
+function currentBranch(cwd = process.cwd()) {
+  const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  return branch && branch !== "HEAD" ? branch : null;
+}
 function requireRepo() {
   const repo = findRepo();
   if (!repo) throw new CliError("Not inside a git repository", "cd into your repository, or pass --project KEY", "no_repo");
@@ -23979,24 +24146,26 @@ linked to ${link.projectKey}  ${link.projectName}  (${link.baseUrl})`
 }
 
 // src/commands/mcp.ts
-import { execFileSync as execFileSync3, spawn as spawn2 } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync, realpathSync as realpathSync2, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5 } from "path";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, 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;
 async function waitForMessage(api, projectId, taskKey, options = {}) {
-  const ticket = await api.post(`/projects/${projectId}/tasks/${encodeURIComponent(taskKey)}/session/ticket`);
+  const ticket = await api.post(`/projects/${projectId}/tasks/${encodeURIComponent(taskKey)}/session/ticket`, options.claim ?? {});
   const socket = new WebSocket(`${api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
-  const outcome = await new Promise((resolve2) => {
-    const timer = options.timeoutMs && options.timeoutMs > 0 ? setTimeout(() => resolve2({ kind: "timeout" }), options.timeoutMs) : null;
+  const outcome = await new Promise((resolve5) => {
+    const timer = options.timeoutMs && options.timeoutMs > 0 ? setTimeout(() => resolve5({ kind: "timeout" }), options.timeoutMs) : null;
     const done = (result) => {
       if (timer) clearTimeout(timer);
-      resolve2(result);
+      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;
@@ -24018,28 +24187,33 @@ async function waitForMessage(api, projectId, taskKey, options = {}) {
   if (outcome.kind !== "message") rememberSession(process.cwd(), null);
   if (outcome.kind === "message" || outcome.kind === "timeout") {
     socket.close(1e3, outcome.kind === "message" ? "handled" : "timeout");
-    await new Promise((resolve2) => {
-      socket.addEventListener("close", () => resolve2(), { once: true });
-      setTimeout(resolve2, 500);
+    await new Promise((resolve5) => {
+      socket.addEventListener("close", () => resolve5(), { once: true });
+      setTimeout(resolve5, 500);
     });
   }
   return outcome;
 }
 var HeldSession = class {
-  constructor(api, projectId, taskKey, onMessage) {
+  constructor(api, projectId, taskKey, hooks) {
     this.api = api;
     this.projectId = projectId;
     this.taskKey = taskKey;
-    this.onMessage = onMessage;
+    this.hooks = hooks;
   }
   api;
   projectId;
   taskKey;
-  onMessage;
+  hooks;
   socket = null;
   stopped = false;
   timer = null;
+  heartbeat = null;
+  pongDue = null;
   attempt = 0;
+  connected = 0;
+  session = null;
+  /** Whoever is sitting in `session wait`. Handed the next message, or null when standby is switched off under them. */
   waiters = /* @__PURE__ */ new Set();
   async start() {
     await this.connect();
@@ -24047,30 +24221,49 @@ var HeldSession = class {
   async connect() {
     if (this.stopped) return;
     try {
-      const ticket = await this.api.post(this.taskKey ? `/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket` : `/projects/${this.projectId}/session/ticket`);
+      const ticket = await this.api.post(this.taskKey ? `/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket` : `/projects/${this.projectId}/session/ticket`, this.hooks.claim());
       const socket = new WebSocket(`${this.api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
       this.socket = socket;
       socket.addEventListener("open", () => {
         this.attempt = 0;
+        this.startHeartbeat(socket);
       });
       socket.addEventListener("message", (event) => {
-        const push = JSON.parse(String(event.data));
+        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;
           rememberSession(process.cwd(), push.session.id);
+          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 };
-        for (const waiter of this.waiters) waiter(delivered);
-        if (this.waiters.size === 0) this.onMessage(delivered);
+        const taken = this.waiters.size > 0;
+        for (const waiter of [...this.waiters]) waiter(delivered);
+        if (!taken) this.hooks.onMessage(delivered);
       });
       socket.addEventListener("close", () => {
-        this.socket = null;
+        this.stopHeartbeat();
+        if (this.socket === socket) this.socket = null;
         if (!this.stopped) this.schedule();
       });
       socket.addEventListener("error", () => {
@@ -24079,6 +24272,26 @@ var HeldSession = class {
       this.schedule();
     }
   }
+  /** 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() {
     this.attempt += 1;
     this.timer = setTimeout(() => void this.connect(), Math.min(3e4, 1e3 * 2 ** Math.min(this.attempt, 5)));
@@ -24088,10 +24301,335 @@ var HeldSession = class {
     this.api.sessionId = null;
     rememberSession(process.cwd(), null);
     if (this.timer) clearTimeout(this.timer);
+    this.stopHeartbeat();
     this.socket?.close(1e3, "released");
   }
 };
 
+// src/platform/agent-identity.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { basename as basename3, resolve as resolve3 } from "path";
+
+// src/platform/harness.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { closeSync, openSync, readdirSync as readdirSync2, readSync, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
+import { basename as basename2, join as join8 } 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/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 unique = (paths) => [...new Set(paths.map((path3) => resolve2(path3)))];
+function environmentsSeen() {
+  if (process.platform === "win32") return [];
+  const seen = [];
+  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]);
+      }
+      for (const entry of readdirSync("/proc")) {
+        if (!/^\d+$/.test(entry)) continue;
+        try {
+          seen.push(readFileSync6(`/proc/${entry}/environ`, "latin1").replace(/\0/g, " "));
+        } catch {
+        }
+      }
+      return seen;
+    }
+    const ps = (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(ps(["eww", "-o", "command=", "-p", String(pid)]));
+      pid = Number(ps(["-o", "ppid=", "-p", String(pid)]).trim());
+    }
+    seen.push(ps(["axeww", "-o", "command="]));
+  } catch {
+  }
+  return seen;
+}
+var environments = null;
+function homesInUse(variable) {
+  environments ??= environmentsSeen();
+  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 directoriesNamed = (root, prefix) => {
+  try {
+    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.name.startsWith(prefix) && (entry.isDirectory() || entry.isSymbolicLink())).map((entry) => join6(root, entry.name)).filter((path3) => {
+      try {
+        return statSync2(path3).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+};
+var hasAny = (dir2, files) => files.some((file3) => existsSync6(join6(dir2, file3)));
+function claudeHomes(root = homedir3(), inUse = homesInUse) {
+  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 unique([join6(root, ".claude"), ...named, ...inUse("CLAUDE_CONFIG_DIR"), ...directoriesNamed(root, ".claude").filter((dir2) => hasAny(dir2, ["settings.json", ".claude.json", "sessions"]))]);
+}
+function codexHomes(root = homedir3(), inUse = homesInUse) {
+  if (process.env.SLOP_CODEX_HOME) return [process.env.SLOP_CODEX_HOME];
+  const named = process.env.CODEX_HOME ? [process.env.CODEX_HOME] : [];
+  return unique([join6(root, ".codex"), ...named, ...inUse("CODEX_HOME"), ...directoriesNamed(root, ".codex").filter((dir2) => hasAny(dir2, ["config.toml", "auth.json", "sessions"]))]);
+}
+function ownHarnessHome(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" ? 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 {
+  }
+  return null;
+}
+
+// src/platform/harness-wake.ts
+function harnessRegistration(pid = process.ppid) {
+  for (const home of claudeHomes()) {
+    const path3 = join7(home, "sessions", `${pid}.json`);
+    if (!existsSync7(path3)) continue;
+    try {
+      return JSON.parse(readFileSync7(path3, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function wakeHarness(text, pid = Number(process.env.SLOP_HARNESS_PID) || process.ppid) {
+  const registration = harnessRegistration(pid);
+  if (!registration?.sessionId || !registration.messagingSocketPath) return Promise.resolve(false);
+  const frame = {
+    uuid: randomUUID3(),
+    session_id: registration.sessionId,
+    type: "user",
+    parent_tool_use_id: null,
+    message: { role: "user", content: text }
+  };
+  return new Promise((resolve5) => {
+    const socket = connect({ path: registration.messagingSocketPath });
+    const done = (ok) => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve5(ok);
+    };
+    const timer = setTimeout(() => done(false), 3e3);
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(frame)}
+`, (error62) => error62 ? done(false) : setTimeout(() => done(true), 200));
+    });
+    socket.on("error", () => done(false));
+  });
+}
+function wakeCodex(text, threadId) {
+  const endpoint = process.env.SLOP_CODEX_APP_SERVER;
+  if (endpoint) return wakeCodexOverWs(text, threadId, endpoint);
+  return Promise.resolve(false);
+}
+function wakeCodexOverWs(text, threadId, endpoint) {
+  return new Promise((resolve5) => {
+    let socket;
+    try {
+      socket = new WebSocket(endpoint);
+    } catch {
+      resolve5(false);
+      return;
+    }
+    let nextId = 1;
+    const pending = /* @__PURE__ */ new Map();
+    const finish = (ok) => {
+      clearTimeout(timer);
+      try {
+        socket.close();
+      } catch {
+      }
+      resolve5(ok);
+    };
+    const timer = setTimeout(() => finish(false), 8e3);
+    const call = (method, params) => new Promise((ok, fail2) => {
+      const id = nextId++;
+      pending.set(id, (message) => message.error ? fail2(new Error(method)) : ok(message.result));
+      socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+    socket.addEventListener("error", () => finish(false));
+    socket.addEventListener("message", (event) => {
+      try {
+        const message = JSON.parse(String(event.data));
+        if (typeof message.id === "number") pending.get(message.id)?.(message);
+      } catch {
+      }
+    });
+    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)) {
+            finish(false);
+            return;
+          }
+          await call("turn/start", { threadId, input: [{ type: "text", text }] });
+          finish(true);
+        } catch {
+          finish(false);
+        }
+      })();
+    });
+  });
+}
+
+// src/platform/harness.ts
+var parent = null;
+function parentCommand() {
+  if (parent !== null) return parent;
+  try {
+    parent = process.platform === "win32" ? "" : execFileSync4("ps", ["-o", "command=", "-p", String(process.ppid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    parent = "";
+  }
+  return parent;
+}
+function harnessOf(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 isNonInteractive(parentCommand2) {
+  return /(^|[\s/])codex(\S*)?\s+exec(\s|$)/.test(parentCommand2);
+}
+function nonInteractiveHarness() {
+  return isNonInteractive(parentCommand());
+}
+var same = (a, b) => {
+  const real = (path3) => {
+    try {
+      return realpathSync2(path3);
+    } catch {
+      return path3;
+    }
+  };
+  return real(a) === real(b);
+};
+function codexConversation(roots, cwd) {
+  const rollouts = [];
+  const walk = (dir2, depth) => {
+    let entries;
+    try {
+      entries = readdirSync2(dir2, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path3 = join8(dir2, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 3) walk(path3, 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: path3, id: match[1] ?? "", mtime: statSync3(path3).mtimeMs });
+      } catch {
+      }
+    }
+  };
+  for (const root of roots) walk(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(8192);
+        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;
+    const found = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(line);
+    if (!found) continue;
+    let dir2;
+    try {
+      dir2 = JSON.parse(`"${found[1]}"`);
+    } catch {
+      continue;
+    }
+    if (same(dir2, cwd)) return rollout.id;
+  }
+  return null;
+}
+function harnessConversation(cwd) {
+  const harness = harnessOf(parentCommand());
+  if (harness === "claude") {
+    const id = harnessRegistration()?.sessionId;
+    return id ? { id, harness } : null;
+  }
+  if (harness === "codex" && !nonInteractiveHarness()) {
+    const id = codexConversation(codexHomes().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 knownConversation(cwd) {
+  return harnessConversation(cwd) ?? rememberedConversation(cwd, startedAt - 12e4);
+}
+function agentIdentity(cwd, fallback = "process") {
+  const conversation = knownConversation(cwd);
+  const repo = findRepo();
+  return {
+    conversation: conversation?.id ?? (fallback === "process" ? processConversation : `dir:${resolve3(cwd)}`),
+    harness: conversation?.harness ?? null,
+    directory: repo ? basename3(repo.worktree) : basename3(cwd),
+    branch: currentBranch(cwd)
+  };
+}
+
+// src/platform/bounded.ts
+var RESULT_CAP = 16e3;
+function bounded(result) {
+  if (result.length <= RESULT_CAP) return result;
+  return `${result.slice(0, RESULT_CAP)}
+
+[cut: ${result.length - RESULT_CAP} more characters; ask for less with limit, offset or before]`;
+}
+
 // src/platform/mcp.ts
 import { createInterface } from "readline";
 function serveMcp(tools2, info) {
@@ -24149,11 +24687,11 @@ function serveMcp(tools2, info) {
 }
 
 // src/commands/tasks.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 
 // src/commands/items.ts
-import { readFileSync as readFileSync6 } from "fs";
-var readText = (value) => value === "-" ? readFileSync6(0, "utf8").trim() : value;
+import { readFileSync as readFileSync8 } from "fs";
+var readText = (value) => value === "-" ? readFileSync8(0, "utf8").trim() : value;
 var path2 = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}/items`;
 function renderItems(items) {
   if (items.length === 0) return "No plan yet. Write one: slop task plan <KEY> -";
@@ -24180,7 +24718,7 @@ function registerItemCommands(task, withProject) {
   withProject(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 = authedApi();
     const project = await resolveProject(api, options.project);
-    const source = lines.length === 1 && lines[0] === "-" ? readFileSync6(0, "utf8") : lines.join("\n");
+    const source = lines.length === 1 && lines[0] === "-" ? readFileSync8(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(path2(project.id, key), { items: titles.map((title3) => ({ title: title3 })) });
@@ -24237,7 +24775,7 @@ function oneOf(value, allowed, what) {
   if (allowed.includes(normalized)) return normalized;
   throw new CliError(`Unknown ${what} "${value}"`, `use one of: ${allowed.join(", ")}`);
 }
-var readDescription = (value) => value === "-" ? readFileSync7(0, "utf8").trim() : value;
+var readDescription = (value) => value === "-" ? readFileSync9(0, "utf8").trim() : value;
 var taskUrl = (baseUrl, projectId, task) => `${baseUrl}/projects/${projectId}?task=${task.key}`;
 var loadProject = (api, id) => api.get(`/projects/${id}`);
 function resolveStatus(project, ref) {
@@ -24388,14 +24926,14 @@ ${taskUrl(api.baseUrl, project.id, created)}`);
 }
 
 // src/platform/update-check.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
 var CHECK_EVERY_MS = 60 * 60 * 1e3;
 var REGISTRY = "https://registry.npmjs.org/slopwaresystems/latest";
-var cacheFile = () => join6(dirname4(configPath()), "update-check.json");
+var cacheFile = () => join9(dirname4(configPath()), "update-check.json");
 function readCache() {
   try {
-    return JSON.parse(readFileSync8(cacheFile(), "utf8"));
+    return JSON.parse(readFileSync10(cacheFile(), "utf8"));
   } catch {
     return { checkedAt: 0, latest: null };
   }
@@ -24431,15 +24969,15 @@ function updateNotice(current) {
   if (!latest || !isNewer(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 updateChecksEnabled = () => !existsSync6(join6(dirname4(configPath()), "no-update-check")) && process.env.SLOP_NO_UPDATE_CHECK !== "1";
+var updateChecksEnabled = () => !existsSync8(join9(dirname4(configPath()), "no-update-check")) && process.env.SLOP_NO_UPDATE_CHECK !== "1";
 
 // src/commands/threads.ts
-import { readFileSync as readFileSync9 } from "fs";
-var readText2 = (value) => value === "-" ? readFileSync9(0, "utf8").trim() : value;
+import { readFileSync as readFileSync11 } from "fs";
+var readText2 = (value) => value === "-" ? readFileSync11(0, "utf8").trim() : value;
 var when = (iso) => iso.slice(0, 16).replace("T", " ");
-var who = (message) => `${message.author.name}${message.via === "agent" ? ` (agent${message.machine ? ` \xB7 ${message.machine}` : ""})` : ""}`;
+var who = (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 threadLine(thread) {
-  const scope = thread.taskKey ?? "general";
+  const scope = [thread.taskKey ?? (thread.to ? null : "general"), thread.to ? `to ${thread.to.agent}` : null].filter(Boolean).join(", ");
   const unread = thread.unread > 0 ? `  ${thread.unread} unread` : "";
   const last = thread.last ? `
     ${who(thread.last)}: ${thread.last.body.split("\n")[0]}` : "";
@@ -24453,9 +24991,10 @@ function threadBlock(thread) {
   return [`${thread.subject}  [${thread.taskKey ?? "general"}]  ${thread.id}`, "", ...thread.messages.map(messageBlock)].join("\n\n").replace("\n\n\n", "\n\n");
 }
 function pushBlock(push) {
-  return `Thread ${push.thread.id}  [${push.thread.taskKey ?? "general"}]  ${push.thread.subject}
+  const scope = [push.thread.taskKey ?? (push.thread.to ? null : "general"), push.thread.to ? `to ${push.thread.to}` : null].filter(Boolean).join(", ");
+  return `Thread ${push.thread.id}  [${scope}]  ${push.thread.subject}
 ${messageBlock(push.message)}
-Reply: slop thread reply ${push.thread.id} "\u2026"`;
+Reply: say reply (thread ${push.thread.id})`;
 }
 function registerThreadCommands(program3, task) {
   const withProject = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
@@ -24470,10 +25009,10 @@ function registerThreadCommands(program3, task) {
     emit(threads, () => threads.length === 0 ? "No threads." : threads.map(threadLine).join("\n"));
   });
   const thread = program3.command("thread").description("One thread: start, read, reply.");
-  withProject(thread.command("new <subject>")).description('Start a thread. General by default; --task makes it about a task (and reaches whoever is live on it). The first message is -m, or "-" for stdin.').requiredOption("-m, --message <text>", 'the first message; "-" reads stdin').option("-t, --task <key>", "about this task").action(async (subject, options) => {
+  withProject(thread.command("new <subject>")).description('Start a thread. General by default; --task makes it about a task (and reaches whoever is live on it). The first message is -m, or "-" for stdin.').requiredOption("-m, --message <text>", 'the first message; "-" reads stdin').option("-t, --task <key>", "about this task").option("--to <agent>", "to one live agent, by name or session id (slop sessions)").action(async (subject, options) => {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
-    const result = await api.post(`/projects/${project.id}/threads`, { subject, task: options.task, body: readText2(options.message) });
+    const result = await api.post(`/projects/${project.id}/threads`, { subject, task: options.task, to: options.to, body: readText2(options.message) });
     emit(result, () => started(result));
   });
   withProject(thread.command("show <id>")).description("Read a thread (and mark it read).").action(async (id, options) => {
@@ -24492,40 +25031,33 @@ function registerThreadCommands(program3, task) {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
     const body2 = readText2(text);
-    const result = await api.post(`/projects/${project.id}/threads`, { subject: subjectOf(body2), task: options.task, body: body2 });
+    const result = await api.post(`/projects/${project.id}/threads`, { task: options.task, body: body2 });
     emit(result, () => started(result));
   });
   withProject(task.command("ask <key> <text>")).description('Start a thread about the task and say something to whoever is live on it. "-" reads stdin.').action(async (key, text, options) => {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
     const body2 = readText2(text);
-    const result = await api.post(`/projects/${project.id}/threads`, { subject: subjectOf(body2), task: key, body: body2 });
+    const result = await api.post(`/projects/${project.id}/threads`, { task: key, body: body2 });
     emit(result, () => started(result));
   });
 }
-var subjectOf = (body2) => {
-  const line = body2.split("\n")[0]?.trim() ?? "";
-  if (!line) throw new CliError("Say something", "the first line becomes the subject");
-  return line.length > 120 ? `${line.slice(0, 117)}\u2026` : line;
-};
-var started = (result) => 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.`;
+var started = (result) => result.thread.to ? `Started ${result.thread.id} to ${result.thread.to.agent}${result.delivered ? "; it has it now." : "; it reads it when it is 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/commands/mcp.ts
-var str = (description2) => ({ type: "string", description: description2 });
-var int2 = (description2) => ({ type: "integer", description: description2 });
-var schema = (properties, required2 = []) => ({ type: "object", properties, required: required2, additionalProperties: false });
-var PROJECT = str("Project key. Defaults to the project this repository is linked to.");
-var taskPath = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var inboxDir = () => join7(dirname5(configPath()), "inbox");
+// src/platform/inbox.ts
+import { createHash as createHash4 } from "crypto";
+import { appendFileSync, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync12, realpathSync as realpathSync3, renameSync, rmSync as rmSync4 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
+var inboxDir = () => join10(dirname5(configPath()), "inbox");
 var realCwd2 = (cwd) => {
   try {
-    return realpathSync2(cwd);
+    return realpathSync3(cwd);
   } catch {
     return cwd;
   }
 };
 var inboxKey = (cwd) => createHash4("sha256").update(realCwd2(cwd)).digest("hex").slice(0, 16);
-var inboxFile = (cwd) => join7(inboxDir(), `${inboxKey(cwd)}.jsonl`);
+var inboxFile = (cwd) => join10(inboxDir(), `${inboxKey(cwd)}.jsonl`);
 function inboxWrite(cwd, push) {
   mkdirSync6(inboxDir(), { recursive: true });
   appendFileSync(inboxFile(cwd), `${JSON.stringify(push)}
@@ -24533,11 +25065,58 @@ function inboxWrite(cwd, push) {
 }
 function inboxDrain(cwd) {
   const path3 = inboxFile(cwd);
-  if (!existsSync7(path3)) return [];
-  const lines = readFileSync10(path3, "utf8").split("\n").filter(Boolean);
-  rmSync4(path3, { force: true });
-  return lines.map((line) => JSON.parse(line));
+  if (!existsSync9(path3)) return [];
+  const taken = `${path3}.${process.pid}.${Date.now()}.draining`;
+  try {
+    renameSync(path3, 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/platform/wake.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname6, join as join11 } from "path";
+var dir = (kind) => join11(dirname6(configPath()), kind);
+var file2 = (kind, cwd) => join11(dir(kind), inboxKey(cwd));
+function markWake(cwd) {
+  mkdirSync7(dir("wake"), { recursive: true });
+  writeFileSync7(file2("wake", cwd), String(Date.now()));
+}
+function takeWake(cwd, since) {
+  const path3 = file2("wake", cwd);
+  if (!existsSync10(path3)) return false;
+  const at = statSync4(path3).mtimeMs;
+  rmSync5(path3, { force: true });
+  return at >= since - 1e3;
+}
+
+// src/commands/mcp.ts
+var str = (description2) => ({ type: "string", description: description2 });
+var int2 = (description2) => ({ type: "integer", description: description2 });
+var schema = (properties, required2 = []) => ({ type: "object", properties, required: required2, additionalProperties: false });
+var PROJECT = str("Project key. Defaults to the project this repository is linked to.");
+var taskPath = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
+var sessionLine = (session, mine = null) => [
+  // Optional chaining on purpose: a server from before agents had names answers without these, and a tool must not crash on it.
+  (session.agent?.name ?? "agent") + (session.id === mine ? " (you)" : ""),
+  session.taskKey ?? "(no task)",
+  session.user.name,
+  session.machine.name,
+  session.where?.directory ? `${session.where.directory}${session.where.branch ? `@${session.where.branch}` : ""}` : "-",
+  `since ${session.startedAt}`,
+  session.state === "reconnecting" ? "(reconnecting)" : "",
+  session.reachable ? "" : "(not visible to teammates)"
+].filter(Boolean).join("  ");
 async function digest(api, projectId, taskKey) {
   const [about, mine, general] = await Promise.all([
     taskKey ? api.get(`/projects/${projectId}/threads?task=${encodeURIComponent(taskKey)}&unread=1&read=1`) : Promise.resolve([]),
@@ -24551,14 +25130,48 @@ async function digest(api, projectId, taskKey) {
   if (general.length) lines.push("Unread general threads (context; nobody has to answer):", ...general.map(threadLine));
   return lines.length ? lines.join("\n") : "Nothing unread.";
 }
+async function catchUp(api, projectId, taskKey, cwd) {
+  const [mine, about] = await Promise.all([
+    api.get(`/projects/${projectId}/threads?participant=1&unread=1`),
+    taskKey ? api.get(`/projects/${projectId}/threads?task=${encodeURIComponent(taskKey)}&unread=1`) : 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`);
+    for (const message of detail.messages.slice(-thread.unread)) inboxWrite(cwd, { thread: { id: detail.id, subject: detail.subject, taskKey: detail.taskKey, to: detail.to?.agent ?? null }, message });
+  }
+}
 function handlers() {
   const api = authedApi();
   const resolveOnly = (args) => resolveProject(api, args.project);
   let held = null;
+  let identity = null;
+  const whoAmI = () => identity ??= agentIdentity(process.cwd());
   const hold = async (projectId, taskKey) => {
     if (held && held.projectId === projectId && held.taskKey === taskKey) return;
     held?.stop();
-    held = new HeldSession(api, projectId, taskKey, (push) => inboxWrite(process.cwd(), push));
+    held = new HeldSession(api, projectId, taskKey, {
+      // A message for the agent wakes its harness when the harness can be woken (Claude Code's session socket): it
+      // arrives as a turn, now, whether the agent is idle or mid-turn. Otherwise the inbox and the hooks carry it.
+      onMessage: (push) => {
+        const text = `A message for you on Slopware Tasks. Act or answer it (say reply), then carry on.
+
+${pushBlock(push)}`;
+        const me = whoAmI();
+        const wake = me.harness === "codex" && me.conversation ? wakeCodex(text, me.conversation) : wakeHarness(text);
+        void wake.then((woken) => {
+          if (!woken) inboxWrite(process.cwd(), push);
+        });
+      },
+      claim: whoAmI,
+      onReconnect: (session) => catchUp(api, projectId, session.taskKey, process.cwd()).catch(() => void 0),
+      // Made unreachable: a Codex Stop hook holding a turn open has nothing to wait for; the marker lets it go.
+      onReachable: (on) => {
+        if (!on) markWake(process.cwd());
+      }
+    });
     await held.start();
   };
   const project = async (args) => {
@@ -24569,29 +25182,47 @@ function handlers() {
   const release = async () => {
     if (held?.taskKey) await hold(held.projectId, null);
   };
+  if (!nonInteractiveHarness())
+    void (async () => {
+      for (let waited = 0; waited < 1e4 && !knownConversation(process.cwd()); waited += 250) await new Promise((resolve5) => setTimeout(resolve5, 250));
+      whoAmI();
+      const target = await resolveOnly({});
+      if (!held) await hold(target.id, null);
+    })().catch(() => void 0);
+  if (!nonInteractiveHarness()) void healCodexTrust().catch(() => void 0);
+  const goodbye = () => {
+    held?.stop();
+    held = null;
+    setTimeout(() => process.exit(0), 300).unref();
+  };
+  process.stdin.once("end", goodbye);
+  for (const signal of ["SIGTERM", "SIGHUP", "SIGINT"]) process.once(signal, goodbye);
   return [
     {
       name: "wait_for_message",
-      description: "Optional. Block until the next message in a thread about the task you hold (claim_task first), or until `minutes` pass. You do not need this to be reached: messages arrive on their own after your next tool call. Use it only when you have nothing else to do and want to sit and wait.",
-      inputSchema: schema({ task: str("Task key, e.g. WEB-12"), minutes: int2("How long to wait before returning empty (default 10)"), project: PROJECT }, ["task"]),
+      description: "Block until the next message for you (on your task, in a thread you are in, or addressed to you), or until `minutes` pass. Optional: messages reach you on their own; use this only when you have nothing else to do and nobody is at your keyboard.",
+      inputSchema: schema({ task: str("Task key to go live on first (optional)"), minutes: int2("Give up after (default 300)"), project: PROJECT }),
       run: async (args) => {
         const target = await project(args);
-        await hold(target.id, String(args.task));
+        if (args.task) await hold(target.id, String(args.task));
         const queued = inboxDrain(process.cwd());
         if (queued.length) return queued.map(pushBlock).join("\n\n");
-        const minutes = typeof args.minutes === "number" ? args.minutes : 10;
-        const push = await new Promise((resolve2) => {
+        const minutes = typeof args.minutes === "number" ? args.minutes : 300;
+        const outcome = await new Promise((resolve5) => {
           const waiter = (delivered) => {
             held?.waiters.delete(waiter);
-            resolve2(delivered);
+            clearTimeout(timer);
+            resolve5({ push: delivered, released: delivered === null });
           };
           held?.waiters.add(waiter);
-          setTimeout(() => {
+          const timer = setTimeout(() => {
             held?.waiters.delete(waiter);
-            resolve2(null);
+            resolve5({ push: null, released: false });
           }, minutes * 6e4);
         });
-        return push ? pushBlock(push) : `No message in ${minutes} minutes.`;
+        if (outcome.push) return pushBlock(outcome.push);
+        if (outcome.released) return "Your person made you not visible to teammates: nothing can reach you now. You may stop.";
+        return `No message in ${minutes} minutes.`;
       }
     },
     {
@@ -24618,11 +25249,11 @@ function handlers() {
     {
       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: schema({ subject: str("Subject"), body: str("First message (Markdown)"), task: str("Task key, to make it about that task"), project: PROJECT }, ["subject", "body"]),
+      inputSchema: schema({ subject: str("Subject (default: the first line of the body)"), body: str("First message (Markdown)"), task: str("Task key, to make it about that task"), project: PROJECT }, ["body"]),
       run: async (args) => {
         const target = await project(args);
-        const result = await api.post(`/projects/${target.id}/threads`, { subject: String(args.subject), body: String(args.body), task: args.task });
-        return `Started ${result.thread.id}${result.thread.taskKey ? ` on ${result.thread.taskKey}` : " (general)"}${result.delivered ? `; reached ${result.delivered} live session(s)` : ""}.`;
+        const result = await api.post(`/projects/${target.id}/threads`, { subject: args.subject ? String(args.subject) : void 0, body: String(args.body), task: args.task, to: args.to });
+        return `Started ${result.thread.id}${result.thread.to ? ` to ${result.thread.to.agent}` : ""}${result.thread.taskKey ? ` on ${result.thread.taskKey}` : result.thread.to ? "" : " (general)"}${result.delivered ? `; reached ${result.delivered} live session(s)` : ""}.`;
       }
     },
     {
@@ -24642,7 +25273,15 @@ function handlers() {
       name: "thread",
       description: "Read a thread in full (marks it read).",
       inputSchema: schema({ id: str("Thread id"), project: PROJECT }, ["id"]),
-      run: async (args) => threadBlock(await api.get(`/projects/${(await project(args)).id}/threads/${String(args.id)}`))
+      run: async (args) => {
+        const query = new URLSearchParams({ limit: String(Math.max(1, Number(args.limit ?? 40))) });
+        if (args.before) query.set("before", String(args.before));
+        const detail = await api.get(`/projects/${(await project(args)).id}/threads/${String(args.id)}?${query}`);
+        const earlier = detail.earlier > 0 && detail.messages[0] ? `\u2026 ${detail.earlier} earlier (before: ${detail.messages[0].createdAt})
+
+` : "";
+        return earlier + threadBlock(detail);
+      }
     },
     {
       name: "sessions",
@@ -24650,7 +25289,8 @@ function handlers() {
       inputSchema: schema({ project: PROJECT }),
       run: async (args) => {
         const list = await api.get(`/projects/${(await project(args)).id}/sessions`);
-        return list.length ? list.map((session) => `${session.taskKey ?? "(no task)"}  ${session.user.name}  ${session.machine.name}  since ${session.startedAt}`).join("\n") : "Nobody is live.";
+        const mine = held?.session?.id ?? null;
+        return list.length ? list.map((session) => sessionLine(session, mine)).join("\n") : "Nobody is live.";
       }
     },
     {
@@ -24730,7 +25370,15 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
         const doneKeys = new Set(target.statuses.filter((status) => status.category === "done").map((status) => status.key));
         const only = args.status ? resolveStatus(target, String(args.status)) : null;
         const rows = list.filter((task) => (args.all || args.archived || !doneKeys.has(task.status)) && (!me || task.assignee?.userId === me) && (!only || task.status === only));
-        return rows.length ? rows.map((task) => `${task.key}  ${target.statuses.find((status) => status.key === task.status)?.label ?? task.status}  ${task.severity}  ${task.assignee?.name ?? "-"}  ${task.title}${task.progress.total ? `  (${task.progress.done}/${task.progress.total})` : ""}`).join("\n") : "No tasks.";
+        const offset = Math.max(0, Number(args.offset ?? 0));
+        const limit = Math.max(1, Number(args.limit ?? 50));
+        const page = rows.slice(offset, offset + limit);
+        const more = rows.length - offset - page.length;
+        if (rows.length === 0) return "No tasks.";
+        return [
+          ...page.map((task) => `${task.key}  ${target.statuses.find((status) => status.key === task.status)?.label ?? task.status}  ${task.severity}  ${task.assignee?.name ?? "-"}  ${task.title}${task.progress.total ? `  (${task.progress.done}/${task.progress.total})` : ""}`),
+          ...more > 0 ? [`\u2026 ${more} more (offset: ${offset + page.length})`] : []
+        ].join("\n");
       }
     },
     {
@@ -24805,8 +25453,13 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
       inputSchema: schema({ task: str("Task key"), project: PROJECT }, ["task"]),
       run: async (args) => {
         const target = await project(args);
-        const events = await api.get(`${taskPath(target.id, String(args.task))}/events`);
-        return events.length ? events.map((record2) => `${record2.createdAt.slice(0, 16).replace("T", " ")}  ${record2.actor.name}  ${JSON.stringify(record2.event)}`).join("\n") : "No history yet.";
+        const query = new URLSearchParams({ limit: String(Math.max(1, Number(args.limit ?? 50))) });
+        if (args.before) query.set("before", String(args.before));
+        const events = await api.get(`${taskPath(target.id, String(args.task))}/events?${query}`);
+        if (events.length === 0) return "No history yet.";
+        const lines = events.map((record2) => `${record2.createdAt.slice(0, 16).replace("T", " ")}  ${record2.actor.name}  ${JSON.stringify(record2.event)}`);
+        const full = events.length >= Number(query.get("limit"));
+        return [...full ? [`\u2026 earlier history: pass before: ${events[0].createdAt}`] : [], ...lines].join("\n");
       }
     },
     {
@@ -24887,66 +25540,83 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
 }
 function readJson(path3) {
   try {
-    return JSON.parse(readFileSync10(path3, "utf8"));
+    return JSON.parse(readFileSync13(path3, "utf8"));
   } catch {
     return {};
   }
 }
-function installClaude() {
+function installClaude(dir2) {
   const done = [];
+  const primary = dir2 === join12(homedir4(), ".claude");
+  const env = { ...process.env };
+  if (primary) delete env.CLAUDE_CONFIG_DIR;
+  else env.CLAUDE_CONFIG_DIR = dir2;
+  const where = primary ? "" : ` for ${dir2}`;
   try {
-    execFileSync3("claude", ["mcp", "add", "--scope", "user", "slop", "--", "slop", "mcp"], { stdio: "ignore" });
-    done.push('Claude Code: MCP server "slop" registered (user scope)');
-  } catch {
-    done.push("Claude Code: run `claude mcp add --scope user slop -- slop mcp` (the claude command was not found here)");
+    execFileSync5("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=${dir2} `}claude mcp add --scope user slop -- slop mcp\` (${said.trim() || "the claude command was not found here"})`);
   }
-  const dir = join7(homedir3(), ".claude");
-  const path3 = join7(dir, "settings.json");
-  mkdirSync6(dir, { recursive: true });
+  const path3 = join12(dir2, "settings.json");
+  mkdirSync8(dir2, { recursive: true });
   const settings = readJson(path3);
-  settings.hooks = mergeHooks(settings.hooks ?? {});
-  settings.env = { ...settings.env ?? {}, MCP_TOOL_TIMEOUT: "1800000" };
-  writeFileSync7(path3, `${JSON.stringify(settings, null, 2)}
+  settings.hooks = mergeHooks(settings.hooks ?? {}, "claude");
+  settings.env = { ...settings.env ?? {}, MCP_TOOL_TIMEOUT: "21600000" };
+  writeFileSync8(path3, `${JSON.stringify(settings, null, 2)}
 `);
-  done.push(`Claude Code: PostToolUse and Stop hooks and MCP_TOOL_TIMEOUT written to ${path3}`);
+  done.push(`Claude Code: SessionStart hook and MCP_TOOL_TIMEOUT written to ${path3}; other slop hooks removed (its session socket wakes it)`);
   return done;
 }
-function mergeHooks(hooks) {
-  const stop = hooks.Stop ?? [];
-  if (!stop.some((entry) => entry.hooks?.some((hook) => hook.command === "slop hook stop"))) {
-    stop.push({ hooks: [{ type: "command", command: "slop hook stop", timeout: 30, statusMessage: "Checking Slopware Tasks for messages" }] });
+function mergeHooks(hooks, harness) {
+  const ours = (hook) => typeof hook.command === "string" && /^slop hook /.test(hook.command);
+  for (const event of Object.keys(hooks)) {
+    const entries = hooks[event] ?? [];
+    for (const entry of entries) entry.hooks = (entry.hooks ?? []).filter((hook) => !ours(hook));
+    hooks[event] = entries.filter((entry) => (entry.hooks ?? []).length > 0);
+    if (hooks[event].length === 0) delete hooks[event];
   }
-  const tick = hooks.PostToolUse ?? [];
-  if (!tick.some((entry) => entry.hooks?.some((hook) => hook.command === "slop hook tick"))) {
-    tick.push({ hooks: [{ type: "command", command: "slop hook tick", timeout: 5, statusMessage: "Slopware Tasks inbox" }] });
+  const add = (event, verb, timeout, statusMessage) => {
+    const entries = hooks[event] ?? [];
+    entries.push({ hooks: [{ type: "command", command: `slop hook ${verb} --harness ${harness}`, timeout, statusMessage }] });
+    hooks[event] = entries;
+  };
+  add("SessionStart", "start", 5, "Slopware Tasks");
+  if (harness === "codex") {
+    add("UserPromptSubmit", "prompt", 5, "Slopware Tasks");
+    add("Stop", "stop", 21600, "Listening on Slopware Tasks");
   }
-  return { ...hooks, Stop: stop, PostToolUse: tick };
+  return hooks;
 }
-function installCodex() {
+function installCodex(dir2) {
   const done = [];
-  const dir = join7(homedir3(), ".codex");
-  mkdirSync6(dir, { recursive: true });
-  const configPath2 = join7(dir, "config.toml");
-  const current = existsSync7(configPath2) ? readFileSync10(configPath2, "utf8") : "";
-  if (/^\[mcp_servers\.slop\]/m.test(current)) done.push(`Codex: MCP server already in ${configPath2}`);
-  else {
-    writeFileSync7(configPath2, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
+  mkdirSync8(dir2, { recursive: true });
+  const configPath3 = join12(dir2, "config.toml");
+  const current = existsSync11(configPath3) ? readFileSync13(configPath3, "utf8") : "";
+  if (/^\[mcp_servers\.slop\]/m.test(current)) {
+    if (/tool_timeout_sec = 1800\b/.test(current)) writeFileSync8(configPath3, current.replace(/tool_timeout_sec = 1800\b/, "tool_timeout_sec = 21600"));
+    done.push(`Codex: MCP server already in ${configPath3}`);
+  } else {
+    writeFileSync8(configPath3, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
 command = "slop"
 args = ["mcp"]
-tool_timeout_sec = 1800
+tool_timeout_sec = 21600
 `);
-    done.push(`Codex: MCP server "slop" added to ${configPath2}`);
+    done.push(`Codex: MCP server "slop" added to ${configPath3}`);
   }
-  const hooksPath = join7(dir, "hooks.json");
-  const file2 = readJson(hooksPath);
-  file2.hooks = mergeHooks(file2.hooks ?? {});
-  writeFileSync7(hooksPath, `${JSON.stringify(file2, null, 2)}
+  const hooksPath = join12(dir2, "hooks.json");
+  const file3 = readJson(hooksPath);
+  file3.hooks = mergeHooks(file3.hooks ?? {}, "codex");
+  writeFileSync8(hooksPath, `${JSON.stringify(file3, null, 2)}
 `);
-  done.push(`Codex: PostToolUse and Stop hooks written to ${hooksPath}`);
+  done.push(`Codex: SessionStart, UserPromptSubmit and Stop hooks written to ${hooksPath}`);
   return done;
 }
-async function trustCodexHooks() {
-  const server = spawn2("codex", ["app-server"], { stdio: ["pipe", "pipe", "ignore"] });
+async function trustCodexHooks(codexHome) {
+  const server = spawn3("codex", ["app-server"], { stdio: ["pipe", "pipe", "ignore"], env: { ...process.env, CODEX_HOME: codexHome } });
+  const where = codexHome === join12(homedir4(), ".codex") ? "" : ` under ${codexHome}`;
   let buffer = "";
   const pending = /* @__PURE__ */ new Map();
   server.stdout.on("data", (chunk) => {
@@ -24964,7 +25634,7 @@ async function trustCodexHooks() {
     }
   });
   let nextId = 1;
-  const call = (method, params) => new Promise((resolve2, reject) => {
+  const call = (method, params) => new Promise((resolve5, reject) => {
     const id = nextId++;
     const timer = setTimeout(() => {
       pending.delete(id);
@@ -24973,7 +25643,7 @@ async function trustCodexHooks() {
     pending.set(id, (message) => {
       clearTimeout(timer);
       if (message.error) reject(new Error(message.error.message ?? `${method} failed`));
-      else resolve2(message.result);
+      else resolve5(message.result);
     });
     server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `);
@@ -24981,48 +25651,64 @@ async function trustCodexHooks() {
   const notify = (method, params) => server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   try {
-    await call("initialize", { clientInfo: { name: "slop", version: "0.3.0" }, capabilities: { experimentalApi: true } });
+    await call("initialize", { clientInfo: { name: "slop", version: "0.4.1" }, capabilities: { experimentalApi: true } });
     notify("initialized", {});
     const listed = await call("hooks/list", { cwds: [process.cwd()] });
-    const ours = listed.data.flatMap((entry) => entry.hooks).filter((hook) => hook.command === "slop hook tick" || hook.command === "slop hook stop");
-    if (ours.length === 0) return "Codex: could not find the slop hooks in its list; trust them once with /hooks in a Codex session";
+    const ours = listed.data.flatMap((entry) => entry.hooks).filter((hook) => hook.command?.startsWith("slop hook "));
+    if (ours.length === 0) return `Codex: could not find the slop hooks in its list${where}; trust them once with /hooks in a Codex session`;
     const untrusted = ours.filter((hook) => hook.trustStatus !== "trusted");
-    if (untrusted.length === 0) return "Codex: the slop hooks are already trusted";
+    if (untrusted.length === 0) return `Codex: the slop hooks are already trusted${where}`;
     const value = Object.fromEntries(untrusted.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]));
     await call("config/batchWrite", { edits: [{ keyPath: "hooks.state", value, mergeStrategy: "upsert" }], reloadUserConfig: true });
-    return `Codex: trusted ${untrusted.length} slop hook(s), so it will not ask`;
+    return `Codex: trusted ${untrusted.length} slop hook(s)${where}, so it will not ask`;
   } catch (error62) {
-    return `Codex: could not trust the hooks automatically (${error62 instanceof Error ? error62.message : String(error62)}); trust them once with /hooks in a Codex session`;
+    return `Codex: could not trust the hooks automatically${where} (${error62 instanceof Error ? error62.message : String(error62)}); trust them once with /hooks in a Codex session`;
   } finally {
     server.kill();
   }
 }
-async function hookCwd() {
-  const input2 = await new Promise((resolve2) => {
+async function healCodexTrust() {
+  const home = ownHarnessHome("CODEX_HOME");
+  if (!home) return;
+  const hooksPath = join12(home, "hooks.json");
+  const configPath3 = join12(home, "config.toml");
+  if (!existsSync11(hooksPath) || !existsSync11(configPath3)) return;
+  if (!readFileSync13(hooksPath, "utf8").includes("slop hook stop")) return;
+  if (readFileSync13(configPath3, "utf8").includes(`hooks.state."${hooksPath}:stop:`)) return;
+  await trustCodexHooks(home);
+}
+async function hookInput(harness) {
+  const input2 = await new Promise((resolve5) => {
     let data = "";
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve2(data));
-    setTimeout(() => resolve2(data), 2e3);
+    process.stdin.on("end", () => resolve5(data));
+    setTimeout(() => resolve5(data), 2e3);
   });
+  let cwd = process.cwd();
+  let conversation = null;
   try {
-    return JSON.parse(input2).cwd ?? process.cwd();
+    const parsed = JSON.parse(input2);
+    cwd = parsed.cwd ?? cwd;
+    conversation = parsed.session_id ?? null;
   } catch {
-    return process.cwd();
   }
+  if (conversation && !nonInteractiveHarness()) rememberConversation(cwd, { id: conversation, harness: harness ?? "other" });
+  return { cwd, conversation };
 }
-async function tickHook() {
-  const arrived = inboxDrain(await hookCwd());
-  if (arrived.length === 0) return;
-  const text = `Messages arrived on Slopware Tasks while you worked:
-
-${arrived.map(pushBlock).join("\n\n")}
-
-Act or answer with the slop MCP \`reply\` tool, then carry on.`;
-  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: text } })}
+async function promptHook(harness) {
+  const { cwd } = await hookInput(harness);
+  markWake(cwd);
+}
+async function startHook(harness) {
+  const { conversation } = await hookInput(harness);
+  if (!conversation) return;
+  const text = `On Slopware Tasks you are ${agentNameFor(conversation)}: that is how people and other agents address you (session who lists everyone).`;
+  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: text } })}
 `);
 }
-async function stopHook() {
-  const cwd = await hookCwd();
+async function stopHook(harness) {
+  if (nonInteractiveHarness()) return;
+  const { cwd } = await hookInput(harness);
   process.chdir(cwd);
   const parts = inboxDrain(cwd).map(pushBlock);
   const repo = findRepo();
@@ -25044,12 +25730,40 @@ ${parts.join("\n\n")}` })}
   }
   const general = await api.get(`/projects/${project.id}/threads?scope=general&unread=1&read=1`);
   if (general.length) parts.push("Unread general threads (context):", ...general.map(threadLine));
-  if (parts.length === 0) return;
-  process.stdout.write(`${JSON.stringify({ decision: "block", reason: `Messages arrived on Slopware Tasks while you worked. Read them (slop thread show <id>), act or reply (slop thread reply <id> "\u2026"), then continue or stop.
+  if (parts.length) {
+    process.stdout.write(`${JSON.stringify({ decision: "block", reason: `Messages arrived on Slopware Tasks while you worked. Read them (threads read), act or reply (say reply), then continue or stop.
 
 ${parts.join("\n")}` })}
+`);
+    return;
+  }
+  const sessionId = rememberedSession(cwd);
+  if (!sessionId || harness !== "codex") return;
+  const reachable = async () => (await api.get(`/projects/${project.id}/sessions`)).some((session) => session.id === sessionId && session.reachable);
+  if (!await reachable()) return;
+  const began = Date.now();
+  takeWake(cwd, began);
+  let lastCheck = began;
+  while (Date.now() - began < STANDBY_HOLD_MS) {
+    await new Promise((resolve5) => setTimeout(resolve5, 500));
+    const arrived = inboxDrain(cwd);
+    if (arrived.length) {
+      process.stdout.write(`${JSON.stringify({ decision: "block", reason: `A message for you on Slopware Tasks. Act or answer it (say reply), then stop.
+
+${arrived.map(pushBlock).join("\n\n")}` })}
+`);
+      return;
+    }
+    if (takeWake(cwd, began)) return;
+    if (Date.now() - lastCheck > 6e4) {
+      lastCheck = Date.now();
+      if (!await reachable().catch(() => true)) return;
+    }
+  }
+  process.stdout.write(`${JSON.stringify({ decision: "block", reason: "Still reachable on Slopware Tasks, nothing arrived. Say so in a word and stop; you will wait again." })}
 `);
 }
+var STANDBY_HOLD_MS = 5 * 60 * 60 * 1e3;
 function tools() {
   const fine = handlers();
   const run2 = (name, args) => {
@@ -25072,13 +25786,13 @@ function tools() {
       "board",
       "The project: tasks on the board, columns, members, projects.",
       { list: "list_tasks", columns: "columns", members: "members", projects: "projects" },
-      { status: str("list: only this column"), mine: { type: "boolean" }, all: { type: "boolean", description: "list: include done" }, archived: { type: "boolean" } }
+      { status: str("list: only this column"), mine: { type: "boolean" }, all: { type: "boolean", description: "list: include done" }, archived: { type: "boolean" }, limit: int2("list: rows (default 50)"), offset: int2("list: skip") }
     ),
     group(
       "task",
       "One task. show; create; update (only given fields change); move; link; archive/restore; history; finish (first done column, releases your session).",
       { show: "show_task", create: "create_task", update: "update_task", move: "move_task", link: "link_task", archive: "archive_task", restore: "archive_task", history: "task_history", finish: "finish_task" },
-      { task: str("Key, e.g. WEB-12 (all but create)"), title: str(""), description: str("Markdown"), notes: str("scratchpad, Markdown"), severity: str("low|medium|high|critical"), column: str("column key or label"), assignee: str("email, name, me, or none"), url: str("link: the URL") }
+      { task: str("Key, e.g. WEB-12 (all but create)"), title: str(""), description: str("Markdown"), notes: str("scratchpad, Markdown"), severity: str("low|medium|high|critical"), column: str("column key or label"), assignee: str("email, name, me, or none"), url: str("link: the URL"), limit: int2("history: newest N (default 50)"), before: str("history: page back from this time") }
     ),
     group(
       "plan",
@@ -25088,16 +25802,16 @@ function tools() {
     ),
     group(
       "session",
-      "Being live. claim: take a task, go live on it, get what is unread (messages then reach you after any tool call). release; finish is on task. who: live sessions. check: unread now. wait: block for the next message (optional).",
+      "Being live. claim: take a task, go live on it, get what is unread (messages then reach you on their own). release; finish is on task. who: live agents by name (you included). check: unread now. wait: block for the next message (optional).",
       { claim: "claim_task", release: "release_task", who: "sessions", check: "check_messages", wait: "wait_for_message" },
-      { task: str("Task key"), minutes: int2("wait: give up after (default 10)") }
+      { task: str("Task key"), minutes: int2("wait: give up after (default 300)") }
     ),
-    group("threads", "Talk between agents and people. list threads; read one (marks it read).", { list: "threads", read: "thread" }, { task: str("list: about this task"), unread: { type: "boolean" }, id: str("read: thread id") }),
+    group("threads", "Talk between agents and people. list threads; read one (marks it read; newest 40 unless limit/before).", { list: "threads", read: "thread" }, { task: str("list: about this task"), unread: { type: "boolean" }, id: str("read: thread id"), limit: int2("read: newest N"), before: str("read: page back from this time") }),
     group(
       "say",
-      "post: start a thread (with task: reaches whoever is live on it; without: general, for people). reply: in a thread; reaches its task's live sessions and its participants.",
+      "post: start a thread (with task: reaches whoever is live on it; with to: one live agent by name; without either: general, for people). reply: in a thread; reaches its task's live sessions, its participants and its addressee.",
       { post: "post", reply: "reply" },
-      { subject: str("post"), body: str("Markdown"), task: str("post: about this task"), thread: str("reply: thread id") }
+      { subject: str("post: optional, else the first line"), body: str("Markdown"), task: str("post: about this task"), to: str("post: an agent's name (session who)"), thread: str("reply: thread id") }
     )
   ];
 }
@@ -25105,7 +25819,7 @@ function withInbox(list, version2) {
   return list.map((tool) => ({
     ...tool,
     run: async (args) => {
-      const result = await tool.run(args);
+      const result = bounded(await tool.run(args));
       const parts = [result];
       if (!(tool.name === "session" && (args.action === "check" || args.action === "wait"))) {
         const arrived = inboxDrain(process.cwd());
@@ -25122,25 +25836,28 @@ 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(withInbox(tools(), 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 lines = [...installClaude(), ...installCodex()];
+    const homes = codexHomes();
+    const lines = [...claudeHomes().flatMap((home) => installClaude(home)), ...homes.flatMap((home) => installCodex(home))];
     let codexPresent = true;
     try {
-      execFileSync3("codex", ["--version"], { stdio: "ignore" });
+      execFileSync5("codex", ["--version"], { stdio: "ignore" });
     } catch {
       codexPresent = false;
     }
-    if (codexPresent) lines.push(await trustCodexHooks());
+    if (codexPresent) for (const home of homes) lines.push(await trustCodexHooks(home));
     emit({ done: lines }, () => lines.join("\n"));
   });
   const hook = program3.command("hook").description("Harness hooks (installed by slop mcp install).");
-  hook.command("stop").description("Stop hook (Claude Code and Codex): hands over unread messages instead of letting the agent stop.").action(stopHook);
-  hook.command("tick").description("PostToolUse hook (Claude Code and Codex): hands over messages the held session received, as context, right after any tool call.").action(tickHook);
+  const harnessOf2 = (options) => options.harness === "claude" || options.harness === "codex" ? options.harness : options.harness ? "other" : null;
+  hook.command("start").description("SessionStart hook (Claude Code and Codex): writes the conversation down so the MCP server is its session, and tells the agent its name.").option("--harness <name>", "claude or codex").action((options) => startHook(harnessOf2(options)));
+  hook.command("prompt").description("UserPromptSubmit hook (Codex): the person typed; a waiting agent returns to handle it.").option("--harness <name>", "claude or codex").action((options) => promptHook(harnessOf2(options)));
+  hook.command("stop").description("Stop hook (Codex): the wait. Holds the turn open at no cost until a message arrives, the person types, or the agent is made unreachable.").option("--harness <name>", "claude or codex").action((options) => stopHook(harnessOf2(options)));
 }
 
 // src/commands/sessions.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 var taskPath2 = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var sessionLine = (session) => [session.taskKey ?? "(no task)", session.user.name, session.machine.name, session.startedAt];
+var sessionLine2 = (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) {
   const withProject = (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.");
@@ -25171,7 +25888,8 @@ function registerSessionCommands(program3, task) {
 `);
     const outcome = await waitForMessage(api, project.id, key, {
       timeoutMs: options.timeout ? Number(options.timeout) * 1e3 : 0,
-      onHello: (session2) => note2(isJsonMode() ? JSON.stringify({ live: session2 }) : `live on ${session2.taskKey} as ${session2.user.name} (${session2.machine.name}); waiting\u2026`),
+      claim: agentIdentity(process.cwd(), "directory"),
+      onHello: (session2) => note2(isJsonMode() ? JSON.stringify({ live: session2 }) : `live on ${session2.taskKey} as ${session2.agent?.name ?? "agent"} for ${session2.user.name} (${session2.machine.name}); waiting\u2026`),
       onMessage: options.follow ? (push) => {
         emit(push, () => `${pushBlock(push)}
 `);
@@ -25196,7 +25914,7 @@ function registerSessionCommands(program3, task) {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
     const sessions = await api.get(`/projects/${project.id}/sessions`);
-    emit(sessions, () => sessions.length === 0 ? "Nobody is live." : table([["TASK", "WHO", "MACHINE", "SINCE"], ...sessions.map(sessionLine)]));
+    emit(sessions, () => sessions.length === 0 ? "Nobody is live." : table([["AGENT", "TASK", "WHO", "MACHINE", "WHERE", "SINCE", "STATE"], ...sessions.map(sessionLine2)]));
   });
 }
 
@@ -25222,13 +25940,13 @@ ${written.map((path3) => `  ${path3}`).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.3.0").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => setJsonMode(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.1").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => setJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
 registerAuthCommands(program2);
 registerProjectCommands(program2);
 var taskCommand = registerTaskCommands(program2);
 registerSessionCommands(program2, taskCommand);
 registerThreadCommands(program2, taskCommand);
-registerMcpCommands(program2, "0.3.0");
+registerMcpCommands(program2, "0.4.1");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(fail);