slopwaresystems 0.4.2 → 0.4.3

package/dist/index.js

@@ -3385,7 +3385,7 @@ var slop_cli_default = "---\nname: slop-cli\ndescription: How an agent works the
 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\nNothing is lost at the end of a turn: what arrived while you worked is handed to you with your next tool result.\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 it waits for you: it is handed to you with your next tool result, so check `session check` when you start a turn if you expect something.\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";
+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\nNothing is lost at the end of a turn: what arrived while you worked is handed to you with your next tool result.\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)\nsay reply (thread, body, wait: 20)          reply, then wait up to 20 minutes for the answer, in one call\nsession wait (thread, minutes)              wait for the next message in that thread (20 minutes unless told)\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 it waits for you: it is handed to you with your next tool result. So on Codex, when you are talking with someone and need their answer to go on, wait for it inside your turn: `say` `reply` (or `post`) with `wait: 20` returns their reply in the same call, or `session` `wait` with `thread` does the same for a thread you already wrote in. Nothing else to do and nobody at your keyboard: `session` `wait` alone blocks for the next message for you.\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";
@@ -24214,7 +24214,10 @@ var HeldSession = class {
   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. */
+  /**
+   * Whoever is waiting for a message. Handed each one, and answers whether it took it (a waiter for one thread lets
+   * the rest pass to the inbox); handed null when the agent is made unreachable under them.
+   */
   waiters = /* @__PURE__ */ new Set();
   async start() {
     await this.connect();
@@ -24258,8 +24261,8 @@ var HeldSession = class {
         }
         if (push.type !== "thread") return;
         const delivered = { thread: push.thread, message: push.message };
-        const taken = this.waiters.size > 0;
-        for (const waiter of [...this.waiters]) waiter(delivered);
+        let taken = false;
+        for (const waiter of [...this.waiters]) if (waiter(delivered)) taken = true;
         if (!taken) this.hooks.onMessage(delivered);
       });
       socket.addEventListener("close", (event) => {
@@ -25182,7 +25185,7 @@ ${pushBlock(push)}`;
   };
   if (!nonInteractiveHarness())
     void (async () => {
-      for (let waited = 0; waited < 1e4 && !knownConversation(process.cwd()); waited += 250) await new Promise((resolve5) => setTimeout(resolve5, 250));
+      for (let waited2 = 0; waited2 < 1e4 && !knownConversation(process.cwd()); waited2 += 250) await new Promise((resolve5) => setTimeout(resolve5, 250));
       whoAmI();
       const target = await resolveOnly({});
       if (!held) await hold(target.id, null);
@@ -25195,32 +25198,42 @@ ${pushBlock(push)}`;
   };
   process.stdin.once("end", goodbye);
   for (const signal of ["SIGTERM", "SIGHUP", "SIGINT"]) process.once(signal, goodbye);
+  const waitFor = async (thread, minutes) => {
+    const queued = inboxDrain(process.cwd());
+    const wanted = queued.filter((push) => !thread || push.thread.id === thread);
+    for (const other of queued) if (!wanted.includes(other)) inboxWrite(process.cwd(), other);
+    if (wanted.length) return { pushes: wanted, released: false };
+    return new Promise((resolve5) => {
+      const waiter = (delivered) => {
+        if (delivered && thread && delivered.thread.id !== thread) return false;
+        held?.waiters.delete(waiter);
+        clearTimeout(timer);
+        resolve5({ pushes: delivered ? [delivered] : [], released: delivered === null });
+        return true;
+      };
+      held?.waiters.add(waiter);
+      const timer = setTimeout(() => {
+        held?.waiters.delete(waiter);
+        resolve5({ pushes: [], released: false });
+      }, minutes * 6e4);
+    });
+  };
+  const waited = (outcome, minutes, thread) => {
+    if (outcome.pushes.length) return outcome.pushes.map(pushBlock).join("\n\n");
+    if (outcome.released) return "Your person made you not visible to teammates: nothing can reach you now. You may stop.";
+    return thread ? `No reply in ${thread} in ${minutes} minutes.` : `No message in ${minutes} minutes.`;
+  };
   return [
     {
       name: "wait_for_message",
-      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 }),
+      description: "Block until the next message for you (on your task, in a thread you are in, or addressed to you), or, with `thread`, the next one in that thread; or until `minutes` pass. Use it when you are waiting on someone's answer and have nothing else to do.",
+      inputSchema: schema({ task: str("Task key to go live on first (optional)"), thread: str("Only a message in this thread"), minutes: int2("Give up after (default 300; 20 with thread)"), project: PROJECT }),
       run: async (args) => {
         const target = await project(args);
         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 : 300;
-        const outcome = await new Promise((resolve5) => {
-          const waiter = (delivered) => {
-            held?.waiters.delete(waiter);
-            clearTimeout(timer);
-            resolve5({ push: delivered, released: delivered === null });
-          };
-          held?.waiters.add(waiter);
-          const timer = setTimeout(() => {
-            held?.waiters.delete(waiter);
-            resolve5({ push: null, released: false });
-          }, minutes * 6e4);
-        });
-        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.`;
+        const thread = args.thread ? String(args.thread) : null;
+        const minutes = typeof args.minutes === "number" ? args.minutes : thread ? 20 : 300;
+        return waited(await waitFor(thread, minutes), minutes, thread);
       }
     },
     {
@@ -25237,21 +25250,30 @@ ${pushBlock(push)}`;
     {
       name: "reply",
       description: "Reply in a thread. In a thread about a task, it reaches whoever is live on that task now, or waits for them.",
-      inputSchema: schema({ thread: str("Thread id"), body: str("The message (Markdown)"), project: PROJECT }, ["thread", "body"]),
+      inputSchema: schema({ thread: str("Thread id"), body: str("The message (Markdown)"), wait: int2("Then wait this many minutes for a reply in the thread"), project: PROJECT }, ["thread", "body"]),
       run: async (args) => {
         const target = await project(args);
-        const result = await api.post(`/projects/${target.id}/threads/${String(args.thread)}/messages`, { body: String(args.body) });
-        return result.delivered ? `Replied; reached ${result.delivered} live session(s).` : "Replied. Nobody is live on it; they see it when they start.";
+        const thread = String(args.thread);
+        const result = await api.post(`/projects/${target.id}/threads/${thread}/messages`, { body: String(args.body) });
+        const replied = result.delivered ? `Replied; reached ${result.delivered} live session(s).` : "Replied. Nobody is live on it; they see it when they start.";
+        if (typeof args.wait !== "number" || args.wait <= 0) return replied;
+        return `${replied}
+
+${waited(await waitFor(thread, args.wait), args.wait, thread)}`;
       }
     },
     {
       name: "post",
       description: "Start a thread. With a task: about that task, to whoever is live on it (or whoever picks it up). Without: general, for people and for context; nobody has to answer.",
-      inputSchema: 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"]),
+      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"), wait: int2("Then wait this many minutes for a reply in the thread"), project: PROJECT }, ["body"]),
       run: async (args) => {
         const target = await project(args);
         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)` : ""}.`;
+        const started2 = `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)` : ""}.`;
+        if (typeof args.wait !== "number" || args.wait <= 0) return started2;
+        return `${started2}
+
+${waited(await waitFor(result.thread.id, args.wait), args.wait, result.thread.id)}`;
       }
     },
     {
@@ -25605,7 +25627,7 @@ tool_timeout_sec = 21600
   file2.hooks = mergeHooks(file2.hooks ?? {}, "codex");
   writeFileSync7(hooksPath, `${JSON.stringify(file2, null, 2)}
 `);
-  done.push(`Codex: SessionStart hook written to ${hooksPath}; other slop hooks removed (a stand-in run answers for an idle chat)`);
+  done.push(`Codex: SessionStart hook written to ${hooksPath}; other slop hooks removed (no Codex hook holds a turn open)`);
   return done;
 }
 async function trustCodexHooks(codexHome) {
@@ -25645,7 +25667,7 @@ async function trustCodexHooks(codexHome) {
   const notify = (method, params) => server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   try {
-    await call("initialize", { clientInfo: { name: "slop", version: "0.4.2" }, capabilities: { experimentalApi: true } });
+    await call("initialize", { clientInfo: { name: "slop", version: "0.4.3" }, 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?.startsWith("slop hook "));
@@ -25771,16 +25793,16 @@ function tools() {
     ),
     group(
       "session",
-      "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).",
+      "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, or the next one in a thread.",
       { 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 300)") }
+      { task: str("Task key"), thread: str("wait: only a message in this thread"), minutes: int2("wait: give up after (default 300; 20 with thread)") }
     ),
     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; 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: 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. Waiting on an answer? Add wait (minutes) and the reply comes back in the same call.",
       { post: "post", reply: "reply" },
-      { 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") }
+      { 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"), wait: int2("then wait this many minutes for a reply in the thread") }
     )
   ];
 }
@@ -25909,13 +25931,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.4.2").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.3").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.4.2");
+registerMcpCommands(program2, "0.4.3");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(fail);

package/package.json

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