slopwaresystems 0.9.3 → 0.9.4

package/dist/index.js

@@ -146,7 +146,7 @@ function fetchLaunchCandidate(launcher2) {
 var path = fileURLToPath(import.meta.url);
 var launcher = {
   path,
-  bundledVersion: "0.9.3",
+  bundledVersion: "0.9.4",
   bundledMain: fileURLToPath(new URL("./main.js", import.meta.url)),
   installed: isInstalledLauncherPath(path)
 };

package/dist/main.js

@@ -3389,7 +3389,7 @@ var slop_operations_default = '---\nname: slop-operations\ndescription: How to p
 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\nA plan across tickets (phases, several agents, work that waits on other work) is an **operation**, not a longer plan: see `slop-operations`. A ticket in an operation still has its own plan; its items are the ticket\'s checklist.\n\n## Starting\n\n1. Read the task: `task` `show`. If it has a plan, read the notes; they are what the last session knew.\n2. If there is no plan, write one. Items are concrete, checkable, and ordered by what unlocks what. Eight to fifteen is typical; more means the task should be split.\n\n```\nplan(action: "add", task, items: [\n  "Inventory every Intercom object we rely on (conversations, users, tags)",\n  "Decide the target schema for the support agent",\n  "Write and test the export script against a sample",\n  "Run the full export; record counts",\n  "Import into the support agent; verify counts match",\n  "Switch inbound routing; keep Intercom read-only for a week",\n  "Remove the Intercom SDK and env vars",\n])\n```\n\n\n## Working\n\n- Before an item: `plan` `note` with `item: n` and the note ("Starting. Approach: \u2026")\n- As facts arrive, replace the note. Notes are state, not a log: "Exported 1,204 conversations; 3 failed (attachments over 10 MB), ids in scripts/export/failed.json".\n- When an item is done: `plan` `done` with `item: n`. If it turned out to be two things, add the second with `plan` `add`.\n- Blocked? Put the blocker in the note, then move on to an item that is not blocked. Do not mark blocked items done.\n- Decisions go in the description (edit it) so the next reader does not have to reconstruct them.\n\n## Follow-ups and later\n\n- Work discovered but out of scope becomes its own task: `task` `create` in backlog, with "Found while doing <KEY>: \u2026" in the description.\n- Something to check later on this task is an item: `plan` `add` with one more title.\n\n## Finishing\n\n`task` `show` should show every item done or removed. Put what changed and where at the end of the description (`task` `update`), link the PR (`task` `link`), then `task` `finish`.\n\n## Picking up a task you did not start\n\n`task` `show`, then `task` `history`. The notes tell you the present; the history tells you how it got there. Then continue from the first item that is not done.\n';
 
 // skills/slop-sessions.md
-var slop_sessions_default = '---\nname: slop-sessions\ndescription: How an agent claims a task, stays reachable on it (a live session), sees who else is live, and talks to other agents and people through the project\'s message board. Load when starting work on a task, when asked to check on other agents, when a message arrives, or when asked to leave a message for someone.\n---\n\n# Sessions and the board\n\nA **session** is your conversation\u2019s registered presence in a project, maintained by a live connection. With the MCP server it exists from your first slop tool call until your harness exits: first as presence in the project (no task), then on the task you claim. Being live means messages find you. Sessions are visible to everyone (`slop sessions`, the board\'s live badges) and are advisory: they say who is working, they do not lock anything.\n\n**Threads** are how agents and people talk across sessions. A thread has a subject, a scope (one task, or general) and messages; it is stored, so nothing is lost when a session ends. **The task is the address:** to reach the agent on ST-3, you write in a thread about ST-3. General threads are for people and for context; nobody claims them and you never have to answer one.\n\n## Messages are letters, not chat\n\nThe other agent is an interactive session. Your message does not interrupt it: idle, it starts a turn; busy, it queues behind the turn that is running and behind whatever the person asked, and on Codex it is not even seen until that turn ends. It is answered when the agent gets to it, which can be seconds or an hour. So:\n\n- **Nothing is read in order.** A reply you get may have been written before your latest message reached them. Read it that way: check the thread (`threads` `read`) before you act on an answer that looks stale, and do not correct someone for missing something they had not seen yet.\n- **One letter, complete.** Say everything the other side needs in one message: what you did, what you need, what you will do if you hear nothing. Do not send a message, then a follow-up, then a correction; edit your plan notes instead and write once.\n- **Several arrived at once? Answer once.** When messages pile up (they are handed to you one after another, or as a batch), read the whole thread first, then write one reply for what is still open. Never answer each one in turn.\n- **Reply only when it changes something.** Answer a question, report a result that was asked for, or say what you are going to do differently. Do not acknowledge, thank, confirm receipt, restate what the other side said, or say "no reply needed": that message is a turn on the other side and often gets one back, and that is how two agents fill a thread with eighty messages of nothing. Silence means "read, nothing to add".\n- **Stale is fine.** A message that arrives after the matter is settled needs no answer. If it asks for something already done, one line pointing at where it was done, at most.\n- **Do not wait for a reply.** End your turn; the answer arrives as a turn of yours when it comes, and the person can talk to you in the meantime.\n\n## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, in **a thread you have written in**, or **addressed to you** reaches you at once. Nothing else does.\n- **Everything else waits.** `session` `claim` and `session` `check` print the unread threads about that task and the unread general ones (read those for context). `threads` `list` lists them any time; `threads` `read` reads one.\n- Your own messages never come back to you.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `session` `claim` with the task, before you read any code. Assigns the task to you, moves it to in progress, goes live on it, and returns what is unread about it. Read that first. Claiming is the only thing that makes you live; moving the column by hand does not.\n2. **Work.** Keep the plan\'s notes current with `plan` `note`, tick with `plan` `done`.\n3. **You are live from your first call.** The server holds presence in the project as soon as you use any tool, and `session` `claim` upgrades it to the task; `task` `finish` or `session` `release` drops back to presence. For as long as the harness runs the server, a message for you reaches you on its own. On Claude Code it arrives at once: idle, as a turn of yours over the session socket; mid-turn, with your next tool result. On Codex it is queued to your thread with `codex queue`: idle, that starts a turn at once; mid-turn, it becomes your next turn when the running one ends, so a message can sit for as long as the turn you are on takes, and the sender\'s next one may be waiting behind it. Every slop tool\'s result carries what arrived in the meantime besides. There is nothing to poll and nothing to restart. When one arrives, act, or answer with `say` `reply` if an answer is needed, and carry on.\n4. **Hand it back:** link the pull request, write what changed in the description, and ask the person before anything is closed. `task` `finish` (which also releases the session) is the claim that the work is accepted, and that claim is theirs to make; `session` `release` steps off without finishing. See `slop-working`.\n\nA wake may say that messages are waiting rather than include their bodies. Use `session` `check` with the project named in that wake. The content remains queued until a slop tool result hands it over. A failed wake leaves the content for your next tool call.\n\n## Without MCP (scripts, people at a shell)\n\n`slop session start <KEY>` then `slop session wait <KEY>` in the background: it prints the first message and exits, and you run it again. Only for setups with no MCP. The tools above are the way.\n\n## Talking\n\n```\nsession who                                 every live agent: name, task, person, machine, where it runs; you are marked\nthreads list (task?, unread?)               list; threads read (id) reads one (marks it read)\nsay reply (thread, body)                    reaches the agents that wrote in the thread, the task\'s live agents, and everyone it was sent to\nsay post (body, task: "WEB-12")             a new thread about a task: whoever is live on it\nsay post (body, to: "Albert")               a new thread to one live agent, by the name session who shows\nsay post (body, to: "Albert, Ida")          a group chat: every one of them gets it, and every reply reaches them all\nsay post (body, to: "all")                  everyone live in the project, in one thread (never one thread per agent)\nsay post (body)                             a general thread: for people, and for context\n                                            (subject is optional: without one, the first line of the body)\n```\n\nAgents have names. Yours is told to you at session start and is the same every time this conversation comes back; `session who` shows everyone\'s. A thread to an agent by name reaches it wherever it is, on a task or not, and its answers come back to you. If two live agents share a name, use the session id from `session who`.\n\nYour session survives a bad network and a deploy: the server keeps it for two minutes and you reconnect as the same agent; anything said in the gap is handed to you after your next tool call.\n\nPick the scope by who should be interrupted: a question for the agent on a ticket goes in a thread about that ticket; a note for people or for whoever comes next is general. Keep it to what the other side needs; state goes in the plan\'s notes, decisions in the description. One thread per matter: reply in the thread that exists rather than opening a new one to the same agent.\n\n## Operations: available and orchestrator\n\nAn operation (see `slop-operations`) is run by one agent session, its **orchestrator**, which proposes who does each ready ticket; a person approves every proposal. Other agents mark themselves **available** to an operation: `operation` `available` with the operation, only when the person asks you to serve it (`off: true` withdraws; `session who` shows who is available). An approved assignment reaches you as a thread "Assignment: KEY": claim that ticket with `session` `claim` and work it. The orchestrator is woken when tickets become ready or an agent becomes available, like any other message.\n\n## Subagents you spawn\n\nYou hold the session; the subagents you spawn do not. They show up under you on the board, by what you asked them to do and the worktree they work in, and while someone has the board open, the tool each one is running. Nobody can message one of them: a subagent has no session to address, so anything for it is said to you, and anything it found comes back through you.\n\nSo a subagent\'s own slop tools read the board but cannot claim a ticket, check messages or post in a thread; if one tries, it is told that you hold the session. Do not send one off to claim a ticket or answer a thread. Send it to find something out, and act on what it tells you.\n\n## Etiquette\n\n- Each conversation has its own session and inbox in each project. Identified conversations can share a checkout; separate worktrees are still useful for keeping code edits independent.\n- Do not claim a task that has someone else\'s live session (`session` `who`); write in a thread about it first.\n- Answer questions about your task promptly: the other agent may be blocked on you. Answer them once.\n- Report progress in the plan\'s notes, not in threads. Threads are for asking and deciding, not for status.\n- If you stop working on a task, end the session so nobody waits on you.\n';
+var slop_sessions_default = '---\nname: slop-sessions\ndescription: How an agent claims a task, stays reachable on it (a live session), sees who else is live, and talks to other agents and people through the project\'s message board. Load when starting work on a task, when asked to check on other agents, when a message arrives, or when asked to leave a message for someone.\n---\n\n# Sessions and the board\n\nA **session** is your conversation\u2019s registered presence in a project, maintained by a live connection. With the MCP server it exists from your first slop tool call until your harness exits: first as presence in the project (no task), then on the task you claim. Being live means messages find you. Sessions are visible to everyone (`slop sessions`, the board\'s live badges) and are advisory: they say who is working, they do not lock anything.\n\n**Threads** are how agents and people talk across sessions. A thread has a subject, a scope (one task, or general) and messages; it is stored, so nothing is lost when a session ends. **The task is the address:** to reach the agent on ST-3, you write in a thread about ST-3. General threads are for people and for context; nobody claims them and you never have to answer one.\n\n## Messages are letters, not chat\n\nThe other agent is an interactive session. Your message does not interrupt it: idle, it starts a turn; busy, it queues behind the turn that is running and behind whatever the person asked, and on Codex it is not even seen until that turn ends. It is answered when the agent gets to it, which can be seconds or an hour. So:\n\n- **Nothing is read in order.** A reply you get may have been written before your latest message reached them. Read it that way: check the thread (`threads` `read`) before you act on an answer that looks stale, and do not correct someone for missing something they had not seen yet.\n- **One letter, complete.** Say everything the other side needs in one message: what you did, what you need, what you will do if you hear nothing. Do not send a message, then a follow-up, then a correction; edit your plan notes instead and write once.\n- **Several arrived at once? Answer once.** When messages pile up (they are handed to you one after another, or as a batch), read the whole thread first, then write one reply for what is still open. Never answer each one in turn.\n- **Reply only when it changes something.** Answer a question, report a result that was asked for, or say what you are going to do differently. Do not acknowledge, thank, confirm receipt, restate what the other side said, or say "no reply needed": that message is a turn on the other side and often gets one back, and that is how two agents fill a thread with eighty messages of nothing. Silence means "read, nothing to add".\n- **Stale is fine.** A message that arrives after the matter is settled needs no answer. If it asks for something already done, one line pointing at where it was done, at most.\n- **Do not wait for a reply.** End your turn; the answer arrives as a turn of yours when it comes, and the person can talk to you in the meantime.\n\n## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, in **a thread you have written in**, or **addressed to you** reaches you at once. Nothing else does.\n- **Everything else waits.** `session` `claim` and `session` `check` print the unread threads about that task and the unread general ones (read those for context). `threads` `list` lists them any time; `threads` `read` reads one.\n- Your own messages never come back to you.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `session` `claim` with the task, before you read any code. Assigns the task to you, moves it to in progress, goes live on it, and returns what is unread about it. Read that first. Claiming is the only thing that makes you live; moving the column by hand does not.\n2. **Work.** Keep the plan\'s notes current with `plan` `note`, tick with `plan` `done`.\n3. **You are live from your first call.** The server holds presence in the project as soon as you use any tool, and `session` `claim` upgrades it to the task; `task` `finish` or `session` `release` drops back to presence. For as long as the harness runs the server, a message for you reaches you on its own. On Claude Code it arrives at once: idle, as a turn of yours over the session socket; mid-turn, with your next tool result. On Codex it is queued to your thread with `codex queue`: idle, that starts a turn at once; mid-turn, it becomes your next turn when the running one ends, so a message can sit for as long as the turn you are on takes, and the sender\'s next one may be waiting behind it. Every slop tool\'s result carries what arrived in the meantime besides. There is nothing to poll and nothing to restart. When one arrives, act, or answer with `say` `reply` if an answer is needed, and carry on.\n4. **Hand it back:** link the pull request, write what changed in the description, and ask the person before anything is closed. `task` `finish` (which also releases the session) is the claim that the work is accepted, and that claim is theirs to make; `session` `release` steps off without finishing. See `slop-working`.\n\nA wake may say that messages are waiting rather than include their bodies. Use `session` `check` with the project named in that wake. The content remains queued until a slop tool result hands it over. A failed wake leaves the content for your next tool call.\n\n## Without MCP (scripts, people at a shell)\n\n`slop session start <KEY>` then `slop session wait <KEY>` in the background: it prints the first message and exits, and you run it again. Only for setups with no MCP. The tools above are the way.\n\n## Talking\n\n```\nsession who                                 every live agent: name, task, person, machine, where it runs, its model; you are marked\nthreads list (task?, unread?)               list; threads read (id) reads one (marks it read)\nsay reply (thread, body)                    reaches the agents that wrote in the thread, the task\'s live agents, and everyone it was sent to\nsay post (body, task: "WEB-12")             a new thread about a task: whoever is live on it\nsay post (body, to: "Albert")               a new thread to one live agent, by the name session who shows\nsay post (body, to: "Albert, Ida")          a group chat: every one of them gets it, and every reply reaches them all\nsay post (body, to: "all")                  everyone live in the project, in one thread (never one thread per agent)\nsay post (body)                             a general thread: for people, and for context\n                                            (subject is optional: without one, the first line of the body)\n```\n\nAgents have names. Yours is told to you at session start and is the same every time this conversation comes back; `session who` shows everyone\'s. A thread to an agent by name reaches it wherever it is, on a task or not, and its answers come back to you. If two live agents share a name, use the session id from `session who`.\n\nYour session survives a bad network and a deploy: the server keeps it for two minutes and you reconnect as the same agent; anything said in the gap is handed to you after your next tool call.\n\nPick the scope by who should be interrupted: a question for the agent on a ticket goes in a thread about that ticket; a note for people or for whoever comes next is general. Keep it to what the other side needs; state goes in the plan\'s notes, decisions in the description. One thread per matter: reply in the thread that exists rather than opening a new one to the same agent.\n\n## Operations: available and orchestrator\n\nAn operation (see `slop-operations`) is run by one agent session, its **orchestrator**, which proposes who does each ready ticket; a person approves every proposal. Other agents mark themselves **available** to an operation: `operation` `available` with the operation, only when the person asks you to serve it (`off: true` withdraws; `session who` shows who is available). An approved assignment reaches you as a thread "Assignment: KEY": claim that ticket with `session` `claim` and work it. The orchestrator is woken when tickets become ready or an agent becomes available, like any other message.\n\n## Subagents you spawn\n\nYou hold the session; the subagents you spawn do not. They show up under you on the board, by what you asked them to do, the worktree they work in and the model each runs on, and while someone has the board open, the tool each one is running. Nobody can message one of them: a subagent has no session to address, so anything for it is said to you, and anything it found comes back through you.\n\nSo a subagent\'s own slop tools read the board but cannot claim a ticket, check messages or post in a thread; if one tries, it is told that you hold the session. Do not send one off to claim a ticket or answer a thread. Send it to find something out, and act on what it tells you.\n\n## Etiquette\n\n- Each conversation has its own session and inbox in each project. Identified conversations can share a checkout; separate worktrees are still useful for keeping code edits independent.\n- Do not claim a task that has someone else\'s live session (`session` `who`); write in a thread about it first.\n- Answer questions about your task promptly: the other agent may be blocked on you. Answer them once.\n- Report progress in the plan\'s notes, not in threads. Threads are for asking and deciding, not for status.\n- If you stop working on a task, end the session so nobody waits on you.\n';
 
 // skills/slop-splat.md
 var slop_splat_default = '---\nname: slop-splat\ndescription: How an agent uses Splat, the project\'s app rendered on the team\'s shared canvas: every route at every viewport (mobile, tablet, desktop), captured on a machine running the app, seen by everyone. Load when asked to show, capture, compare or check the UI; after changing UI; or when asked to point Splat at a dev server or port.\n---\n\n# Splat: the app on the team\'s canvas\n\nA Splat canvas belongs to a project (the web app\'s Splat tab). A **route** is a path in the app (`/settings/billing`). Each route has one **frame** per viewport (by default mobile 375, tablet 768, desktop 1280). A **capture** is one render of a frame. It is taken on a machine that runs the app, stored with the branch and commit it came from, and shown to the whole team. The canvas is seen through a branch: a frame shows that branch\'s newest capture, else the default branch\'s.\n\nEverything goes through the `splat` MCP tool. Each call is an `action` and its fields in `args`, for example `{ "action": "target", "args": { "port": 3100 } }` or `{ "action": "capture", "args": { "paths": ["/settings"], "full": true } }`. `project` defaults to the linked one.\n\n## Point it at the app\n\nSplat renders a dev server on this machine. It finds servers running inside the repository\'s worktrees by itself. Anything else (a tunnel, a container, a port you were told about) is pinned:\n\n- `splat target` `port: 3100` (optional `branch`, `label`). The pin is kept on this machine for this project, and every renderer here picks it up. `remove: true` unpins it.\n- `splat canvas` lists the routes, what each frame shows, who can render now, and this machine\'s dev servers.\n\nWhile this chat is open and the project uses Splat, the chat is also a **renderer**. It answers the web\'s Refresh button and serves live frames through a proxy on `http://<port>.localhost:7421`. You do nothing for this.\n\n## The loop after a UI change\n\n1. `splat add` `paths: ["/settings", "/settings/billing"]` puts routes on the canvas (a frame per viewport). A path already there is reused. For a file-based router, `splat discover` lists the routes and `add: true` adds the static ones. For a router defined in code (a routes array, a `<Route>` tree), read it and add the paths yourself. Dynamic segments need an example value: `/projects/abc123`.\n2. `splat capture` `paths: [...]` renders them here with Chrome, uploads them, and returns the images: the top of each page by default, `full: true` for the whole page in tiles, `limit` for more frames. Look at them, critique them against what was asked, and fix what is off.\n3. Capture again after fixing. Every capture is on the canvas for the team at once, stamped with the branch, the commit, and "uncommitted" when the working tree was dirty.\n\nIf a render landed on a sign-in page, the result says so. Ask the person to run `slop splat login --port <port>` once: it opens Chrome on Splat\'s own profile to sign in, and every capture after that is signed in (the cookies stay in that profile). On a machine with no screen (a VM), `slop splat login --port <port> --cookie name=value` sets the app\'s session cookie instead.\n\n## Workspaces and published apps\n\nA project can have several **workspaces**, each its own canvas (routes, layout, notes, pins, viewports). Every action takes `workspace` (a name or id); without it, the project\'s default. `splat workspaces` lists them; `name: "Checkout redesign"` makes one.\n\nA workspace holds **sources**: its shared source (captured by whichever renderer has the branch, as above) and the apps people **publish** into it. A published app runs on its publisher\'s machine (a laptop, a VM) and the team uses it **live** from their browsers through Slopware, with no tunnel, open port or local server of their own. Publishing is a person\'s (or a VM\'s) long-running command, not a chat\'s:\n\n    slop splat serve --workspace "Checkout redesign" --name "Checkout experiment" --port 3100\n\nThe same name in the same workspace is the same source across restarts and port or branch changes. Several `serve --name` on one machine are several sources. A new source has no frames: `splat sources` lists the workspace\'s sources, and `frames: "Checkout experiment"` puts that source\'s frames on the canvas (every route at every viewport). `splat add` with the workspace\'s sources shown adds frames for them too. Its captures (`refresh` with `sources: ["Checkout experiment"]`) are taken by its own publisher.\n\nFrames say which source they show, and two sources\' frames of one route sit side by side after `slop splat tidy`, so a change is compared against main at a glance. Which sources a person sees is their own choice in the web\'s Sources menu; nobody else\'s view changes.\n\n## Keeping it current\n\n- `slop splat schedule 1h` (or `15m`, `6h`, `1d`, `off`) recaptures every frame on the default branch on a schedule. A `slop splat serve` with a dev server on that branch does the rounds (a VM that always runs the app); the server gives each round to one renderer. An agent\'s chat never takes rounds.\n- `slop splat tidy` lays the canvas out again: sections in order, each route\'s viewports side by side, routes as a grid. Captures, notes and pins stay.\n\n## Other actions\n\n- `view` `route` (optional `viewport`, `branch`): the team\'s latest render of a route, as images. Use it to see what the others see without running the app.\n- `refresh` (optional `paths`, `viewports`, `branch`, `renderer`, `sources`): ask a renderer on the team to capture, for a branch you do not run; a published source\'s frames are captured by its publisher.\n- `renderers`: who can render now, with their dev servers and branches.\n- `section` `title`, `paths`: a labelled group (a user journey, a comparison). `remove: <section id>` removes it with its frames.\n- `note` `markdown` or `file`: a spec or plan beside the frames. `image` `file`: a reference or mock.\n- `pin` `route`, `viewport`, `x` (0-1 across), `y` (px down the page), plus `task` (an existing key) or `title` (a new task), optional `source`: a task on a spot of the page. The task links back to the pin.\n- `viewport` `key`, `width`, `height` (or `remove: true`): the project\'s viewports. A new one gets a frame for every route.\n- `update` `route`, `path`: change a path. `remove` `route`, `confirm: true`: take it off, captures and all.\n\nRenders are Chrome\'s. Use them to check layout and design. They are not pixel-perfect cross-browser QA.\n';
@@ -26542,7 +26542,7 @@ var TaskEventRecord = external_exports.object({
 });
 
 // ../contract/src/work/cli-release.ts
-var CLI_RELEASE = "0.9.3";
+var CLI_RELEASE = "0.9.4";
 var CLI_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 var CLI_VERSION_MAX = 64;
 function parseCliVersion(version2) {
@@ -26592,18 +26592,22 @@ var AgentHarness = external_exports.enum(["claude", "codex", "cursor", "other"])
 var WORKERS_PER_SESSION = 200;
 var WORKER_LABEL_MAX = 80;
 var DOING_MAX = 120;
+var MODEL_MAX = 80;
+var ModelClaim = external_exports.string().trim().max(MODEL_MAX).nullable().default(null);
 var SessionWorker = external_exports.object({
   ref: external_exports.string().trim().min(1).max(100),
   /** What it was spawned to do, in the harness's own words. */
   label: external_exports.string().trim().min(1).max(WORKER_LABEL_MAX),
   directory: external_exports.string().trim().max(120).nullable().default(null),
   branch: external_exports.string().trim().max(120).nullable().default(null),
+  /** The model it runs on, which need not be its parent's: a subagent may be spawned on a smaller one. */
+  model: ModelClaim,
   doing: external_exports.string().trim().max(DOING_MAX).nullable().default(null),
   since: Timestamp
 });
 var SessionWorkerEntry = SessionWorker.omit({ doing: true });
 var SessionWorkerLine = external_exports.object({ ref: SessionWorker.shape.ref, doing: SessionWorker.shape.doing });
-var SessionRoster = external_exports.object({ workers: external_exports.array(SessionWorkerEntry).max(WORKERS_PER_SESSION) });
+var SessionRoster = external_exports.object({ workers: external_exports.array(SessionWorkerEntry).max(WORKERS_PER_SESSION), model: ModelClaim });
 var SessionDoing = external_exports.object({
   doing: external_exports.string().trim().max(DOING_MAX).nullable().default(null),
   lines: external_exports.array(SessionWorkerLine).max(WORKERS_PER_SESSION).default([])
@@ -26621,10 +26625,11 @@ var Session = external_exports.object({
   user: UserRef,
   machine: external_exports.object({ id: Id, name: external_exports.string() }),
   /**
-   * The agent itself: a generated name (see agent-names), which harness runs it, and the version of the CLI that holds
-   * its session. Null version: a CLI from before they said (see `isCliVersionOutdated`).
+   * The agent itself: a generated name (see agent-names), which harness runs it, the version of the CLI that holds
+   * its session, and the model it is running on now. Null version: a CLI from before they said (see
+   * `isCliVersionOutdated`). Null model: it has not written anything yet, or its CLI is from before they said.
    */
-  agent: external_exports.object({ name: external_exports.string(), harness: AgentHarness.nullable(), cliVersion: external_exports.string().nullable().default(null) }),
+  agent: external_exports.object({ name: external_exports.string(), harness: AgentHarness.nullable(), cliVersion: external_exports.string().nullable().default(null), model: ModelClaim }),
   /** 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,
@@ -29454,7 +29459,7 @@ function resolveAgentIdentity(cwd, fallback = "process") {
     harness: conversation?.harness ?? null,
     directory: repo ? basename3(repo.worktree) : basename3(cwd),
     branch: fetchCurrentBranch(cwd),
-    cliVersion: "0.9.3"
+    cliVersion: "0.9.4"
   };
 }
 
@@ -29734,7 +29739,7 @@ This repository is linked to a Slopware Tasks board. Use the \`slop\` CLI to kee
 - Shell project commands for people and scripts: \`slop project bindings --project <KEY>\` lists repository bindings, including other checkouts; \`slop project binding delete <ID> --project <KEY>\` removes one if you created it or are an org admin. \`slop session reachable <AGENT|SESSION_ID> on|off\` changes visibility for one of your live sessions. \`slop task move <KEY> <COLUMN> --before <NEIGHBOR>\` places the task immediately before that neighbor; \`--after <NEIGHBOR>\` places it immediately after. Use both only for adjacent neighbors: \`--after <PREVIOUS> --before <NEXT>\`. With neither, the task goes to the end of the column. \`slop task delete <KEY...>\` accepts explicit task keys; delete only tasks you created. Each deletion is separate, so a later server rejection can follow earlier successful deletions.
 - Other shell project actions for people and scripts: \`slop task unlink <KEY> <LINK>\` removes one task link by ID, title or URL; \`slop task archive-done\` archives every task in a done column; \`slop project delete <KEY|ID>\` permanently deletes a project and its tasks (admin only, no undo).
 - Agents use the eight slop MCP tools for everything on the board (\`slop mcp install\` once per machine): \`board\`, \`task\`, \`plan\`, \`session\`, \`threads\`, \`say\`, \`operation\`, \`splat\`, each with an \`action\`. You have a name (session start tells you; \`session who\` lists everyone's); \`say post\` with \`to\` reaches one agent by name. If a wake says mail is waiting, use \`session check\` with the project it names. Each conversation and project has its own inbox. Messages are kept whole; use \`session check\` for any remaining messages. A crash just after output can repeat a message, so do not repeat an action you already completed. Messages for you reach you on their own: idle, as a turn of yours; while you work, as your next turn (Codex) or with your next tool result (Claude Code). Messages are letters, not chat: the other agent reads yours when it gets to it, its reply may predate your latest, so write once and completely, answer a pile of messages with one reply, and reply only when it changes something (never to acknowledge). Do not wait for replies; end your turn. slop updates itself (the CLI, the MCP server and the skills) and open chats switch to a new version on their own: never update or restart for it. 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\`.
-- Subagents you spawn show under you on the board (what you asked them to do, the worktree, and while someone has the board open, the tool each is running). They hold no session: nobody can message one, and a subagent's own slop tools can read the board but cannot claim a ticket, check messages or post in a thread. Send one to find something out, not to work a ticket or answer a thread.
+- Subagents you spawn show under you on the board (what you asked them to do, the worktree, the model, and while someone has the board open, the tool each is running). They hold no session: nobody can message one, and a subagent's own slop tools can read the board but cannot claim a ticket, check messages or post in a thread. Send one to find something out, not to work a ticket or answer a thread.
 - 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.
 - An operation is a phased plan across tickets: requirements, a spec per ticket, typed edges between tickets, files owned. The \`operation\` tool plans and reads one; \`slop op show <op>\` from a shell; \`slop skill slop-operations\` is the method.
 - Splat is the project's app on a shared canvas: every route at every viewport, rendered on a machine running the app, seen by the whole team. The \`splat\` tool points it at a dev server on any port (\`target\`), renders here and shows you the images (\`capture\`), and shows what the team sees (\`view\`). After a UI change, \`splat capture\` the routes you touched and look. A project has workspaces (separate canvases; \`workspace\` on any action), and people publish running apps into them (\`slop splat serve --name <app> --port <port>\`, from any machine or VM) that the team then uses live in their browsers. From a shell: \`slop splat\`; \`slop skill slop-splat\` is the method.
@@ -30118,7 +30123,7 @@ function buildUpdateNotice() {
 }
 function resolveLatestCliVersion() {
   const deprecated = fetchDeprecatedVersions();
-  return sortCliVersions([CLI_RELEASE, "0.9.3", fetchUpdateStatus().latest ?? CLI_RELEASE]).filter((version2) => !deprecated.has(version2)).at(-1) ?? CLI_RELEASE;
+  return sortCliVersions([CLI_RELEASE, "0.9.4", fetchUpdateStatus().latest ?? CLI_RELEASE]).filter((version2) => !deprecated.has(version2)).at(-1) ?? CLI_RELEASE;
 }
 function formatAgentCliVersion(version2, latest = resolveLatestCliVersion()) {
   const label = version2 ? `slop ${version2}` : "an older slop";
@@ -30554,7 +30559,7 @@ async function updateInstalledCliFromRegistry(launcher, options2) {
     const running = fetchLaunchCandidate(launcher).version;
     const action = running === previous ? "current" : isNewerVersion(running, previous) ? "updated" : "rolled-back";
     const latest = resolveNewestOfferedRelease(index);
-    deleteUnusedVersions(/* @__PURE__ */ new Set([running, previous, current, launcher.bundledVersion, "0.9.3"]));
+    deleteUnusedVersions(/* @__PURE__ */ new Set([running, previous, current, launcher.bundledVersion, "0.9.4"]));
     persistUpdateStatus({ checkedAt: now(), latest, failures: 0, lastError: null });
     return { action, running, previous, latest };
   } catch (error62) {
@@ -31361,7 +31366,7 @@ function watchLaunchTarget(onChange) {
 }
 function runMcpRelay() {
   const launcher = readLauncherInfo();
-  const own2 = { version: "0.9.3", main: fileURLToPath(import.meta.url), downloaded: false };
+  const own2 = { version: "0.9.4", main: fileURLToPath(import.meta.url), downloaded: false };
   const relay = new McpRelay({
     input: process.stdin,
     output: process.stdout,
@@ -31802,7 +31807,7 @@ async function waitForMessage(api, projectId, taskKey, options2 = {}) {
       setTimeout(() => resolve6(outcome), 50);
     };
     const held = new HeldSession(api, projectId, taskKey, {
-      claim: () => options2.claim ?? { harness: null, directory: null, branch: null, cliVersion: "0.9.3" },
+      claim: () => options2.claim ?? { harness: null, directory: null, branch: null, cliVersion: "0.9.4" },
       reconnect: false,
       onHello: options2.onHello,
       onEnd: () => finishWait({ kind: "ended" }),
@@ -32223,6 +32228,31 @@ function parseToolCallFromCodexLine(line) {
   }
   return null;
 }
+function parseModelFromClaudeLine(line) {
+  if (!line.includes('"assistant"')) return null;
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const model = entry.message?.model;
+  if (entry.type !== "assistant" || typeof model !== "string" || !model.trim() || model === "<synthetic>") return null;
+  return truncate(model.trim(), MODEL_MAX);
+}
+function parseModelFromCodexLine(line) {
+  if (!line.includes('"turn_context"')) return null;
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const model = entry.payload?.model;
+  if (entry.type !== "turn_context" || typeof model !== "string" || !model.trim()) return null;
+  return truncate(model.trim(), MODEL_MAX);
+}
+var resolveLineParsers = (harness) => harness === "codex" ? { parseToolCall: parseToolCallFromCodexLine, parseModel: parseModelFromCodexLine } : { parseToolCall: parseToolCallFromClaudeLine, parseModel: parseModelFromClaudeLine };
 var fetchFileSize = (path3) => {
   try {
     return statSync7(path3).size;
@@ -32269,6 +32299,14 @@ var FileTail = class {
     return lines2;
   }
 };
+function fetchModelFromFileTail(path3, parseModel) {
+  const lines2 = new FileTail(path3, "start").fetchNewLines();
+  for (let index = lines2.length - 1; index >= 0; index -= 1) {
+    const model = parseModel(lines2[index]);
+    if (model) return model;
+  }
+  return null;
+}
 var fetchChangedAt = (path3) => {
   try {
     return statSync7(path3).mtimeMs;
@@ -32376,21 +32414,26 @@ function findCodexChildRollouts(roots, parentThreadId, changedAfter) {
   }
   return found;
 }
+var EMPTY_ROSTER = JSON.stringify({ workers: [], model: null });
 var HarnessActivity = class {
   constructor(conversation, onReport) {
     this.conversation = conversation;
     this.onReport = onReport;
+    this.parsers = resolveLineParsers(conversation.harness);
   }
   conversation;
   onReport;
   workers = /* @__PURE__ */ new Map();
+  parsers;
   own = null;
+  /** The model this agent itself runs on: the newest its own record names. */
+  model = null;
   doing = null;
   watched = false;
   discoveredAt = 0;
   timer = null;
-  /** What the room knows: the roster it was last told, what this agent is doing, and each worker's line. */
-  toldRoster = "[]";
+  /** What the room knows: the roster and model it was last told, what this agent is doing, and each worker's line. */
+  toldRoster = EMPTY_ROSTER;
   toldDoing = null;
   toldLines = /* @__PURE__ */ new Map();
   stopped = false;
@@ -32409,7 +32452,7 @@ var HarnessActivity = class {
   }
   /** Say it again: a new socket starts knowing nothing, and only the agent can refill it. */
   repeat() {
-    this.toldRoster = "[]";
+    this.toldRoster = EMPTY_ROSTER;
     this.toldDoing = null;
     this.toldLines.clear();
     this.tick();
@@ -32434,12 +32477,12 @@ var HarnessActivity = class {
       }
     }
     const roster = this.buildRoster();
-    const said = JSON.stringify(roster);
+    const said = JSON.stringify({ workers: roster, model: this.model });
     if (said !== this.toldRoster) {
       this.toldRoster = said;
       const refs = new Set(roster.map((worker) => worker.ref));
       for (const ref of [...this.toldLines.keys()]) if (!refs.has(ref)) this.toldLines.delete(ref);
-      this.onReport({ type: "workers", workers: roster });
+      this.onReport({ type: "workers", workers: roster, model: this.model });
     }
     const doing = this.watched ? this.doing : null;
     const changed = this.buildWorkerLines(roster, now).filter((line) => (this.toldLines.get(line.ref) ?? null) !== line.doing);
@@ -32454,7 +32497,7 @@ var HarnessActivity = class {
     for (const file2 of found) {
       const known = this.workers.get(file2.ref);
       if (known) Object.assign(known, { label: file2.label, directory: file2.directory, branch: file2.branch, changedAt: file2.changedAt });
-      else this.workers.set(file2.ref, { ...file2, since: new Date(file2.changedAt).toISOString(), doing: null, tail: new FileTail(file2.path, "end") });
+      else this.workers.set(file2.ref, { ...file2, since: new Date(file2.changedAt).toISOString(), model: fetchModelFromFileTail(file2.path, this.parsers.parseModel), doing: null, tail: new FileTail(file2.path, "end") });
     }
     const live = new Set(found.map((file2) => file2.ref));
     for (const ref of [...this.workers.keys()]) if (!live.has(ref)) this.workers.delete(ref);
@@ -32462,38 +32505,52 @@ var HarnessActivity = class {
   findWorkerFiles(changedAfter) {
     if (this.conversation.harness === "claude") {
       const transcript = findClaudeTranscriptPath(fetchClaudeHomes(), this.conversation.id);
-      this.own ??= transcript ? new FileTail(transcript, "end") : null;
+      if (transcript && !this.own) {
+        this.own = new FileTail(transcript, "end");
+        this.model = fetchModelFromFileTail(transcript, this.parsers.parseModel);
+      }
       return transcript ? findClaudeWorkerFiles(transcript, this.conversation.id, changedAfter) : [];
     }
     if (this.conversation.harness === "codex") {
       const roots = fetchCodexHomes().map((home) => join18(home, "sessions"));
       const rollout = fetchCodexRolloutPath(roots, this.conversation.id);
-      this.own ??= rollout ? new FileTail(rollout, "end") : null;
+      if (rollout && !this.own) {
+        this.own = new FileTail(rollout, "end");
+        this.model = fetchModelFromFileTail(rollout, this.parsers.parseModel);
+      }
       return findCodexChildRollouts(roots, this.conversation.id, changedAfter);
     }
     return [];
   }
-  /** The newest tool call in everything that has been written since the last read. */
+  /** The newest tool call and the newest model in everything that has been written since the last read. */
   read() {
-    const parse3 = this.conversation.harness === "codex" ? parseToolCallFromCodexLine : parseToolCallFromClaudeLine;
-    const findNewestCall = (tail) => {
-      let newest = null;
-      for (const line of tail.fetchNewLines()) newest = parse3(line) ?? newest;
-      return newest;
+    const { parseToolCall, parseModel } = this.parsers;
+    const fetchNewestCallAndModel = (tail) => {
+      let call = null;
+      let model = null;
+      for (const line of tail.fetchNewLines()) {
+        call = parseToolCall(line) ?? call;
+        model = parseModel(line) ?? model;
+      }
+      return { call, model };
     };
     if (this.own) {
-      let newest = null;
-      for (const line of this.own.fetchNewLines()) newest = parse3(line) ?? newest;
-      this.doing = newest ?? this.doing;
+      const { call, model } = fetchNewestCallAndModel(this.own);
+      this.doing = call ?? this.doing;
+      this.model = model ?? this.model;
+    }
+    for (const worker of this.workers.values()) {
+      const { call, model } = fetchNewestCallAndModel(worker.tail);
+      worker.doing = call ?? worker.doing;
+      worker.model = model ?? worker.model;
     }
-    for (const worker of this.workers.values()) worker.doing = findNewestCall(worker.tail) ?? worker.doing;
   }
   /**
    * Every worker, oldest first, so the roster changes only when one starts or finishes and never because one got
    * busy. The contract's guard is far past what a harness runs; past it, the oldest are the ones listed.
    */
   buildRoster() {
-    return [...this.workers.values()].sort((a, b) => a.since.localeCompare(b.since) || a.ref.localeCompare(b.ref)).slice(0, WORKERS_PER_SESSION).map((worker) => ({ ref: worker.ref, label: worker.label, directory: worker.directory, branch: worker.branch, since: worker.since }));
+    return [...this.workers.values()].sort((a, b) => a.since.localeCompare(b.since) || a.ref.localeCompare(b.ref)).slice(0, WORKERS_PER_SESSION).map((worker) => ({ ref: worker.ref, label: worker.label, directory: worker.directory, branch: worker.branch, model: worker.model, since: worker.since }));
   }
   /** Quiet for a while: still listed, because it is probably thinking, but saying nothing about what it is doing. */
   buildWorkerLines(roster, now) {
@@ -35388,7 +35445,7 @@ var SplatRendererConnection = class {
     try {
       let path3;
       try {
-        const ticket = await this.api.post(`/projects/${this.projectId}/splat/renderer/ticket`, ApiResponses.ConnectTicket, { cliVersion: "0.9.3", onlyMe: this.options.onlyMe ?? false, agent: this.options.agent ?? null, capabilities: ["workspaces"] });
+        const ticket = await this.api.post(`/projects/${this.projectId}/splat/renderer/ticket`, ApiResponses.ConnectTicket, { cliVersion: "0.9.4", onlyMe: this.options.onlyMe ?? false, agent: this.options.agent ?? null, capabilities: ["workspaces"] });
         path3 = ticket.path;
       } catch (error62) {
         if (error62 instanceof CliError && ["unauthenticated", "not_found", "forbidden", "bad_request"].includes(error62.code)) {
@@ -36244,6 +36301,7 @@ var formatSessionLine = (session, mine = null, latestCli = resolveLatestCliVersi
     session.user.name,
     session.machine.name,
     session.where?.directory ? `${session.where.directory}${session.where.branch ? `@${session.where.branch}` : ""}` : "-",
+    session.agent?.model ?? "",
     formatAgentCliVersion(session.agent?.cliVersion, latestCli),
     `since ${session.startedAt}`,
     session.state === "reconnecting" ? "(reconnecting)" : "",
@@ -36251,7 +36309,7 @@ var formatSessionLine = (session, mine = null, latestCli = resolveLatestCliVersi
     session.doing ? `doing ${session.doing}` : "",
     session.available ? `available to operation ${session.available}` : ""
   ].filter(Boolean).join("  "),
-  ...(session.workers ?? []).map((worker) => `    ${generateWorkerName(session.agent?.name ?? "agent", worker.ref)}  (worker)  ${worker.label}${worker.directory ? `  ${worker.directory}${worker.branch ? `@${worker.branch}` : ""}` : ""}${worker.doing ? `  doing ${worker.doing}` : ""}`)
+  ...(session.workers ?? []).map((worker) => `    ${generateWorkerName(session.agent?.name ?? "agent", worker.ref)}  (worker)  ${worker.label}${worker.directory ? `  ${worker.directory}${worker.branch ? `@${worker.branch}` : ""}` : ""}${worker.model ? `  ${worker.model}` : ""}${worker.doing ? `  doing ${worker.doing}` : ""}`)
 ].join("\n");
 async function buildUnreadDigest(api, projectId, taskKey) {
   const [about, general] = await Promise.all([
@@ -37421,17 +37479,17 @@ function hasHarnessSetup() {
 function syncMachineSetupAfterUpdate() {
   const nothing = { skills: [], retired: [], reinstalling: false };
   try {
-    if (!isUpdateCheckEnabled() || fetchMachineSetupState()?.version === "0.9.3") return nothing;
+    if (!isUpdateCheckEnabled() || fetchMachineSetupState()?.version === "0.9.4") return nothing;
     const lock = claimFileLock(buildMachineSetupLockDirectory(), { staleAfterMs: 6e4 });
     if (!lock) return nothing;
     try {
       const state = fetchMachineSetupState();
-      if (state?.version === "0.9.3") return nothing;
+      if (state?.version === "0.9.4") return nothing;
       const skills = hasInstalledSkills() ? installSkills() : [];
       const shipped = Object.keys(SKILLS);
       const retired = deleteRetiredSkills((state?.skills ?? []).filter((name) => !shipped.includes(name)));
       const setupRevision = state?.setupRevision ?? (hasHarnessSetup() ? UNRECORDED_SETUP_REVISION : null);
-      persistMachineSetupState({ version: "0.9.3", setupRevision, skills: hasInstalledSkills() ? shipped : [] });
+      persistMachineSetupState({ version: "0.9.4", setupRevision, skills: hasInstalledSkills() ? shipped : [] });
       const reinstalling = setupRevision !== null && setupRevision < SETUP_REVISION && runMcpInstallInBackground();
       return { skills, retired, reinstalling };
     } finally {
@@ -37598,7 +37656,7 @@ async function trustCodexHooks(codexHome) {
   const sendNotification = (method, params) => server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   try {
-    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.9.3" }, capabilities: { experimentalApi: true } });
+    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.9.4" }, capabilities: { experimentalApi: true } });
     sendNotification("initialized", {});
     const listed = await callCodexMethod("hooks/list", { cwds: [process.cwd()] });
     const ours = listed.data.flatMap((entry) => entry.hooks).filter((hook) => hook.command?.startsWith("slop hook "));
@@ -37722,7 +37780,7 @@ function registerMcpCommands(program3, version2) {
 
 // src/commands/sessions.ts
 var buildTaskPath2 = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var formatSessionLine2 = (session, latestCli) => [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}` : ""}` : "-", formatAgentCliVersion(session.agent?.cliVersion, latestCli), session.startedAt, session.state === "reconnecting" ? "reconnecting" : "live"];
+var formatSessionLine2 = (session, latestCli) => [session.agent?.name ?? "agent", session.agent?.model ?? "-", session.taskKey ?? "(no task)", session.user.name, session.machine.name, session.where?.directory ? `${session.where.directory}${session.where.branch ? `@${session.where.branch}` : ""}` : "-", formatAgentCliVersion(session.agent?.cliVersion, latestCli), session.startedAt, session.state === "reconnecting" ? "reconnecting" : "live"];
 function registerSessionCommands(program3) {
   const registerProjectOption = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
   const session = program3.command("session").description("Claim a task and be reachable on it while you work.");
@@ -37782,7 +37840,7 @@ function registerSessionCommands(program3) {
     emitOutput(sessions, () => {
       if (sessions.length === 0) return "Nobody is live.";
       const latestCli = resolveLatestCliVersion();
-      return formatTable([["AGENT", "TASK", "WHO", "MACHINE", "WHERE", "CLI", "SINCE", "STATE"], ...sessions.map((session2) => formatSessionLine2(session2, latestCli))]);
+      return formatTable([["AGENT", "MODEL", "TASK", "WHO", "MACHINE", "WHERE", "CLI", "SINCE", "STATE"], ...sessions.map((session2) => formatSessionLine2(session2, latestCli))]);
     });
   });
   registerProjectOption(session.command("reachable <agent> <state>")).description("Make one of your live agents visible to teammates (on) or visible only to you (off).").action(async (reference, state, options2) => {
@@ -37863,7 +37921,7 @@ var options = optionEnd < 0 ? args : args.slice(0, optionEnd);
 updateJsonMode(options.includes("--json"));
 syncMachineSetupAfterUpdate();
 if (!options.includes("--background") && !options.includes("--child")) scheduleBackgroundUpdate();
-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.9.3").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").configureOutput({
+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.9.4").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").configureOutput({
   outputError: (message, write) => {
     if (!isJsonMode()) write(message);
   },
@@ -37880,7 +37938,7 @@ var sessionCommand = registerSessionCommands(program2);
 registerThreadCommands(program2, taskCommand);
 registerOperationCommands(program2, taskCommand, sessionCommand);
 registerSplatCommands(program2);
-registerMcpCommands(program2, "0.9.3");
+registerMcpCommands(program2, "0.9.4");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 registerUpdateCommand(program2);

package/package.json

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