slopwaresystems 0.1.1 → 0.2.0

package/README.md

@@ -4,7 +4,7 @@ The [Slopware Tasks](https://tasks.slopware.systems) board from the terminal. Bu
 
 ```bash
 npm i -g slopwaresystems
-slop login                # approve the machine in your browser
+slop login                # approve the machine in your browser (on a VM or over SSH: open the printed link on any device)
 cd your-repo && slop link WEB
 slop task create "Retry storms on 429" -s high -d -
 slop skills install       # puts the agent skills into .claude/skills/

package/dist/index.js

@@ -3379,16 +3379,16 @@ import { homedir } from "os";
 import { join } from "path";
 
 // skills/slop-cli.md
-var slop_cli_default = '---\nname: slop-cli\ndescription: How to use the slop CLI to read and update the task board this repository is linked to. Load when asked to create, update, plan, comment on or finish tasks.\n---\n\n# slop: the board from the terminal\n\nThe repository you are in is linked to a project on Slopware Tasks. Everything a person can do on the board, you can do with `slop`. Add `--json` to any command for machine-readable output.\n\n## Orientation\n\n```bash\nslop status                 # which project this checkout is linked to\nslop statuses               # the board\'s columns (key, label, category)\nslop members                # who tasks can be assigned to\nslop task list [--all] [--status <column>] [--assignee me]\nslop task show <KEY>        # title, status, severity, assignee, links, plan, description\nslop task history <KEY>     # everything that happened to it, in order\n```\n\nTask keys look like `WEB-12`; the bare number works inside the linked project.\n\n## Creating and changing tasks\n\n```bash\nslop task create "Short imperative title" -d "What, where, why" -s <low|medium|high|critical> [--status <column>] [-a <email|me|none>]\nslop task update <KEY> [--title \u2026] [-d \u2026] [-s \u2026] [--status \u2026] [-a \u2026]\nslop task move <KEY> "<column label or key>"\nslop task start <KEY>       # first "in progress" column\nslop task done <KEY>        # first "done" column\nslop task assign <KEY> <email|me|none>\nslop task link <KEY> <url>  # a PR, a design, a log; GitHub PRs are recognised\nslop task notes <KEY> [text|-]  # the scratchpad under the links: read it, or replace it whole\n\n## Sessions (see the `slop-sessions` skill)\n\n```bash\nslop session start <KEY>      # claim: assign me, move to in progress\nslop session wait <KEY>       # be live until someone says something; run in the background\nslop session end <KEY>\nslop sessions                 # who is live on what\nslop task ask <KEY> "\u2026"       # say something to whoever is live on it (also on the timeline)\n```\nslop task archive <KEY>     # off the board, history kept\n```\n\nDescriptions are Markdown and are shown in full. Long text: `-d -` reads stdin.\n\n## Plans (see the `slop-planning` skill)\n\n```bash\nslop task items <KEY>                       # the plan, numbered, with notes\nslop task plan <KEY> - <<\'EOF\'              # one item per line, appended in order\nInventory the Intercom data model\nWrite the export script\nEOF\nslop task item add <KEY> "title" [-n "note"]\nslop task item done <KEY> <n>               # by number from `items`\nslop task item reopen <KEY> <n>\nslop task item note <KEY> <n> "what is true now"\nslop task item rename <KEY> <n> "new title"\nslop task item remove <KEY> <n>\n```\n\n## Projects\n\n```bash\nslop projects\nslop project create "Name" [--key KEY]\nslop project update [--name \u2026] [--description \u2026] [--theme <theme>]\nslop project status add "In review" -c in_progress      # columns: add | rename | remove | order\n```\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. There is no chat: the plan\'s notes are the running state, the description holds decisions.\n- When you open a pull request for a task, link it.\n';
+var slop_cli_default = '---\nname: slop-cli\ndescription: How to use the slop CLI to read and update the task board this repository is linked to. Load when asked to create, update, plan, comment on or finish tasks.\n---\n\n# slop: the board from the terminal\n\nThe repository you are in is linked to a project on Slopware Tasks. Everything a person can do on the board, you can do with `slop`. Add `--json` to any command for machine-readable output.\n\n## Orientation\n\n```bash\nslop status                 # which project this checkout is linked to\nslop statuses               # the board\'s columns (key, label, category)\nslop members                # who tasks can be assigned to\nslop task list [--all] [--status <column>] [--assignee me]\nslop task show <KEY>        # title, status, severity, assignee, links, plan, description\nslop task history <KEY>     # everything that happened to it, in order\n```\n\nTask keys look like `WEB-12`; the bare number works inside the linked project.\n\nA link belongs to the clone: every git worktree of it (including agent sandboxes made with `git worktree add`) is linked without doing anything. On a machine with no browser, `slop login` prints a link and a code; open it on any device.\n\n## Creating and changing tasks\n\n```bash\nslop task create "Short imperative title" -d "What, where, why" -s <low|medium|high|critical> [--status <column>] [-a <email|me|none>]\nslop task update <KEY> [--title \u2026] [-d \u2026] [-s \u2026] [--status \u2026] [-a \u2026]\nslop task move <KEY> "<column label or key>"\nslop task start <KEY>       # first "in progress" column\nslop task done <KEY>        # first "done" column\nslop task assign <KEY> <email|me|none>\nslop task link <KEY> <url>  # a PR, a design, a log; GitHub PRs are recognised\nslop task notes <KEY> [text|-]  # the scratchpad under the links: read it, or replace it whole\n\n## Sessions (see the `slop-sessions` skill)\n\n```bash\nslop session start <KEY>      # claim: assign me, move to in progress\nslop session wait <KEY>       # be live until someone says something; run in the background\nslop session end <KEY>\nslop sessions                 # who is live on what\nslop threads [--task KEY] [--general] [--unread]   # the project\'s threads\nslop thread show <id> | reply <id> "\u2026" | new "Subject" -m "\u2026" [--task KEY]\nslop task ask <KEY> "\u2026"       # a new thread about the task, to whoever is live on it\n```\nslop task archive <KEY>     # off the board, history kept\n```\n\nDescriptions are Markdown and are shown in full. Long text: `-d -` reads stdin.\n\n## Plans (see the `slop-planning` skill)\n\n```bash\nslop task items <KEY>                       # the plan, numbered, with notes\nslop task plan <KEY> - <<\'EOF\'              # one item per line, appended in order\nInventory the Intercom data model\nWrite the export script\nEOF\nslop task item add <KEY> "title" [-n "note"]\nslop task item done <KEY> <n>               # by number from `items`\nslop task item reopen <KEY> <n>\nslop task item note <KEY> <n> "what is true now"\nslop task item rename <KEY> <n> "new title"\nslop task item remove <KEY> <n>\n```\n\n## Projects\n\n```bash\nslop projects\nslop project create "Name" [--key KEY]\nslop project update [--name \u2026] [--description \u2026]\nslop project status add "In review" -c in_progress      # columns: add | rename | remove | order\n```\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. There is no chat: the plan\'s notes are the running state, the description holds decisions.\n- When you open a pull request for a task, link it.\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: `slop task show <KEY>`. 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```bash\nslop task plan <KEY> - <<\'EOF\'\nInventory every Intercom object we rely on (conversations, users, tags)\nDecide the target schema for the support agent\nWrite and test the export script against a sample\nRun the full export; record counts\nImport into the support agent; verify counts match\nSwitch inbound routing; keep Intercom read-only for a week\nRemove the Intercom SDK and env vars\nEOF\n```\n\n\n## Working\n\n- Before an item: `slop task item note <KEY> <n> "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: `slop task item done <KEY> <n>`. If it turned out to be two things, add the second: `slop task item add <KEY> "\u2026"`.\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: `slop task create "\u2026" --status backlog -d "Found while doing <KEY>: \u2026"`.\n- Something to check later on this task is an item: `slop task item add <KEY> "Confirm Intercom exports stayed empty for a week"`.\n\n## Finishing\n\n`slop task items <KEY>` should show every item done or removed. Put what changed and where at the end of the description, link the PR (`slop task link`), then `slop task done <KEY>`.\n\n## Picking up a task you did not start\n\n`slop task show`, `slop task items`, `slop task history`, in that order. 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 while working (a live session), sees who else is live, and talks to them on the task. Load when starting work on a task, when asked to check on other agents, or when a `slop session wait` background task finishes.\n---\n\n# Sessions: being on a task\n\nA **session** is you, live on one task. It exists while `slop session wait` is running. When that process ends (you exit, or your thread closes), the session ends with it. Sessions are visible to everyone (`slop sessions`, the board) and are advisory: they say who is working, they do not lock anything.\n\n## The loop\n\n1. **Claim:** `slop session start <KEY>`. Assigns the task to you and moves it to in progress.\n2. **Go live:** run `slop session wait <KEY>` **in the background** (Claude Code: a background Bash task; Codex: a background command). It blocks until someone says something on the task, prints it, and exits.\n3. **Work.** Keep the plan's notes current (`slop-planning`).\n4. **When the wait exits with a message:** read it, act or answer with `slop task ask <KEY> \"\u2026\"`, then start `slop session wait <KEY>` in the background again. While no wait is running you are not live.\n5. **Finish:** `slop task done <KEY>`, then `slop session end <KEY>` (or just let the wait exit).\n\nExit codes of `wait`: 0 a message was printed; 2 the session was ended on purpose (someone ran `slop session end`); 3 `--timeout` elapsed with nothing said; 4 the connection dropped. On 2 do not relaunch. On 3 or 4 relaunch if you are still working.\n\n## Talking\n\n- `slop task ask <KEY> \"Which schema did you settle on?\"` reaches whoever is live on that task right now and lands on the task's timeline either way.\n- `slop sessions` shows who is live where. `slop task history <KEY>` shows what was said before you arrived.\n- Keep it to questions and answers the other agent needs; state goes in the plan's notes, decisions in the description.\n\n## Etiquette\n\n- One live session per agent. Do not `session start` a task that has someone else's live session; ask them first.\n- Answer asks promptly: the other agent is blocked on you.\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 on one task. It exists while `slop session wait` is running: when that process ends (you exit, or your thread closes), the session ends with it. 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** reaches your waiter at once. Nothing else does: another task\'s thread, or a general one, never interrupts you.\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\n\n1. **Claim:** `slop session start <KEY>`. Assigns the task to you, moves it to in progress, and prints what is waiting for you. Read it before touching anything.\n2. **Go live:** run `slop session wait <KEY>` **in the background** (Claude Code: a background Bash task; Codex: a background command). It blocks until someone writes in a thread about your task, prints the message with its thread id, and exits. **The exit is the message.** If your harness can watch a stream instead, `slop session wait <KEY> --follow` stays up and prints each message as it comes.\n3. **Work.** Keep the plan\'s notes current (`slop-planning`).\n4. **When the wait exits with a message:** read it, act or answer with `slop thread reply <id> "\u2026"`, then start `slop session wait <KEY>` in the background **immediately**. Coming back within two minutes continues the same session; not coming back means you have gone dark.\n5. **Finish:** `slop task done <KEY>`, then `slop session end <KEY>` (or just let the wait exit).\n\nExit codes of `wait`: 0 a message was printed; 2 the session was ended on purpose (someone ran `slop session end`); 3 `--timeout` elapsed with nothing said; 4 the connection dropped. On 2 do not relaunch. On 3 or 4 relaunch if you are still working.\n\n## Talking\n\n```bash\nslop sessions                                   # who is live on what\nslop threads [--task KEY] [--general] [--unread]\nslop thread show <id>                           # read it (marks it read)\nslop thread reply <id> "\u2026"                      # in a task thread: reaches whoever is live on it, or waits for them\nslop thread new "Subject" -m "\u2026" --task WEB-12  # a new thread about a task\nslop thread new "Subject" -m "\u2026"                # a general thread: for people, and for context\nslop task ask WEB-12 "\u2026"                        # shorthand: a new thread about WEB-12 from one message\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. Do not `session start` a task that has someone else\'s live session; 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:** `slop task list --assignee me` (or `slop task list`). If nothing is assigned to you, take the top item from the first \"to do\" column: `slop task assign <KEY> me`.\n2. **Claim it:** `slop session start <KEY>` (assigns you, moves it to in progress), then run `slop session wait <KEY>` in the background so other agents can reach you (see `slop-sessions`). Read `slop task show <KEY>` fully, including the plan and its notes.\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:** link the PR, put what changed and where at the end of the description, `slop task done <KEY>`, `slop session end <KEY>`.\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 |\n| A decision and its reason | the description (edit it) |\n| A question, a discovery, a hand-off | the description, or a new task if it is work |\n| A pull request, a design, a log | a link |\n| Loose working notes nobody needs to act on | the task's notes (`slop task notes`) |\n| Work you found but will not do now | a new task in backlog |\n\n# Etiquette\n\n- One task in progress at a time per agent. `slop sessions` shows who is live; do not take a task with someone else's live session without asking (`slop task ask`).\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";
+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:** `slop task list --assignee me` (or `slop task list`). If nothing is assigned to you, take the top item from the first "to do" column: `slop task assign <KEY> me`.\n2. **Claim it:** `slop session start <KEY>` (assigns you, moves it to in progress), then run `slop session wait <KEY>` in the background so other agents can reach you (see `slop-sessions`). Read `slop task show <KEY>` fully, including the plan and its notes.\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:** link the PR, put what changed and where at the end of the description, `slop task done <KEY>`, `slop session end <KEY>`.\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 |\n| A decision and its reason | the description (edit it) |\n| A question for the agent on a ticket | a thread about that ticket (`slop task ask KEY "\u2026"`) |\n| A note for people, or for whoever comes next | a general thread (`slop post "\u2026"`) |\n| A discovery, a hand-off | the description, or a new task if it is work |\n| A pull request, a design, a log | a link |\n| Loose working notes nobody needs to act on | the task\'s notes (`slop task notes`) |\n| Work you found but will not do now | a new task in backlog |\n\n# Etiquette\n\n- One task in progress at a time per agent. `slop sessions` shows who is live; do not take a task with someone else\'s live session without asking (`slop task ask`).\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';
 
 // src/platform/skills.ts
 var SKILLS = { "slop-cli": slop_cli_default, "slop-planning": slop_planning_default, "slop-sessions": slop_sessions_default, "slop-working": slop_working_default };
@@ -17722,7 +17722,7 @@ function generateRecordCheck(doc, ctx, schema, accessor) {
   }, `return INVALID;`);
   return outputVar;
 }
-function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
+function emitOwnKeys(doc, ctx, accessor, kVar, body2, onSymbol) {
   const propIsEnumerableConst = addConstant(ctx, Object.prototype.propertyIsEnumerable);
   const symsVar = newVar(ctx);
   const keysVar = newVar(ctx);
@@ -17733,7 +17733,7 @@ function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
   doc.indented((d) => {
     d.write(`const ${kVar} = ${keysVar}[${iVar}];`);
     d.write(`if (${kVar} === "__proto__" || !${propIsEnumerableConst}.call(${accessor}, ${kVar})) continue;`);
-    body(d);
+    body2(d);
   });
   doc.write(`}`);
   doc.write(`for (let ${iVar} = 0; ${iVar} < ${symsVar}.length; ${iVar}++) {`);
@@ -17743,7 +17743,7 @@ function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
     if (onSymbol)
       d.write(onSymbol);
     else
-      body(d);
+      body2(d);
   });
   doc.write(`}`);
 }
@@ -23207,9 +23207,21 @@ var Invitation = external_exports.object({
   role: OrgRole,
   createdAt: Timestamp
 });
+var InviteLink = external_exports.object({
+  id: Id,
+  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 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({
   members: external_exports.array(Member),
-  invitations: external_exports.array(Invitation)
+  invitations: external_exports.array(Invitation),
+  /** Active links only. Admins see them; members get an empty list. */
+  links: external_exports.array(InviteLink)
 });
 var InviteMemberInput = external_exports.object({ email: Email, role: OrgRole.default("member") });
 var UpdateMemberInput = external_exports.object({ role: OrgRole });
@@ -23241,8 +23253,6 @@ function findStatus(statuses, ref) {
 
 // ../contract/src/work/projects.ts
 var ProjectKey = external_exports.string().trim().toUpperCase().pipe(external_exports.string().regex(/^[A-Z][A-Z0-9]{1,7}$/, "2\u20138 letters or digits, starting with a letter"));
-var PROJECT_THEMES = ["slate", "stone", "zinc", "mist", "sand", "rose", "violet", "emerald"];
-var ProjectTheme = external_exports.enum(PROJECT_THEMES);
 var TaskCounts = external_exports.record(external_exports.string(), external_exports.number());
 var Project = external_exports.object({
   id: Id,
@@ -23250,8 +23260,6 @@ var Project = external_exports.object({
   key: external_exports.string(),
   name: external_exports.string(),
   description: external_exports.string(),
-  /** Null: no theme of its own; the viewer's personal theme applies. */
-  theme: ProjectTheme.nullable(),
   /** The board's columns, in order. */
   statuses: external_exports.array(ProjectStatus),
   createdAt: Timestamp,
@@ -23266,8 +23274,7 @@ var CreateProjectInput = external_exports.object({
 });
 var UpdateProjectInput = external_exports.object({
   name: external_exports.string().trim().min(1).max(80),
-  description: external_exports.string().trim().max(2e3),
-  theme: ProjectTheme.nullable()
+  description: external_exports.string().trim().max(2e3)
 }).partial();
 function suggestProjectKey(name) {
   const words = name.toUpperCase().replace(/[^A-Z0-9 ]+/g, " ").split(/\s+/).filter(Boolean);
@@ -23298,6 +23305,44 @@ var UpdateItemInput = external_exports.object({ title, note, done: external_expo
 var ReorderItemsInput = external_exports.object({ ids: external_exports.array(Id).min(1) });
 var ItemProgress = external_exports.object({ done: external_exports.number(), total: external_exports.number() });
 
+// ../contract/src/work/threads.ts
+var MessageVia = external_exports.enum(["person", "agent"]);
+var ThreadMessage = external_exports.object({
+  id: Id,
+  threadId: Id,
+  author: UserRef,
+  /** A person on the web, or an agent through the CLI (with its machine). */
+  via: MessageVia,
+  machine: external_exports.string().nullable(),
+  body: external_exports.string(),
+  createdAt: Timestamp
+});
+var Thread = external_exports.object({
+  id: Id,
+  projectId: Id,
+  /** Null: general. */
+  taskId: Id.nullable(),
+  taskKey: external_exports.string().nullable(),
+  subject: external_exports.string(),
+  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()
+});
+var ThreadDetail = Thread.extend({ messages: external_exports.array(ThreadMessage) });
+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),
+  /** A task key or number; absent means general. */
+  task: external_exports.string().trim().min(1).optional(),
+  body
+});
+var ReplyInput = external_exports.object({ body });
+var ProjectThreadSummary = external_exports.object({ projectId: Id, unread: external_exports.number(), threads: external_exports.array(Thread) });
+
 // ../contract/src/work/tasks.ts
 var TaskStatus = StatusKey;
 var TASK_SEVERITIES = ["low", "medium", "high", "critical"];
@@ -23408,8 +23453,12 @@ var AskInput = external_exports.object({ body: external_exports.string().trim().
 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 }),
   /** The room is closing this session (someone ran `slop session end`). */
-  external_exports.object({ type: external_exports.literal("end") })
+  external_exports.object({ type: external_exports.literal("end") }),
+  /** To board watchers: something in the project changed; refetch. */
+  external_exports.object({ type: external_exports.literal("changed"), scope: external_exports.string() })
 ]);
 
 // ../contract/src/work/bindings.ts
@@ -23483,16 +23532,16 @@ var CliError = class extends Error {
 
 // src/platform/api.ts
 function createApi(options) {
-  async function request(method, path3, body) {
+  async function request(method, path3, body2) {
     const headers = { accept: "application/json" };
-    if (body !== void 0) headers["content-type"] = "application/json";
+    if (body2 !== void 0) headers["content-type"] = "application/json";
     if (options.token) headers.authorization = `Bearer ${options.token}`;
     let response;
     try {
       response = await fetch(`${options.baseUrl}/api${path3}`, {
         method,
         headers,
-        body: body === void 0 ? void 0 : JSON.stringify(body),
+        body: body2 === void 0 ? void 0 : JSON.stringify(body2),
         signal: AbortSignal.timeout(2e4)
       });
     } catch (error62) {
@@ -23515,9 +23564,9 @@ function createApi(options) {
   return {
     baseUrl: options.baseUrl,
     get: (path3) => request("GET", path3),
-    post: (path3, body) => request("POST", path3, body ?? {}),
-    patch: (path3, body) => request("PATCH", path3, body),
-    put: (path3, body) => request("PUT", path3, body),
+    post: (path3, body2) => request("POST", path3, body2 ?? {}),
+    patch: (path3, body2) => request("PATCH", path3, body2),
+    put: (path3, body2) => request("PUT", path3, body2),
     delete: (path3) => request("DELETE", path3)
   };
 }
@@ -23640,23 +23689,25 @@ function openBrowser(url2) {
   }
 }
 var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+var headless = () => Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY) || platform2() === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
 function registerAuthCommands(program3) {
-  program3.command("login").description("Sign this machine in. Opens the web app, where you approve the login.").option("--url <url>", "the Slopware Tasks instance to sign in to").option("--no-browser", "print the link instead of opening it").action(async (options) => {
+  program3.command("login").description("Sign this machine in. Opens the web app, where you approve the login. On a VM or over SSH, open the printed link on any device.").option("--url <url>", "the Slopware Tasks instance to sign in to").option("--no-browser", "print the link instead of opening it").action(async (options) => {
     const baseUrl = (options.url || process.env.SLOP_URL || readConfig()?.baseUrl || DEFAULT_URL).replace(/\/+$/, "");
     const api = createApi({ baseUrl, token: null });
-    const started = await api.post("/cli/auth/start", { machine: machineInfo() });
+    const started2 = await api.post("/cli/auth/start", { machine: machineInfo() });
+    const remote = headless();
     process.stderr.write(`
-Approve this login in your browser:
-  ${started.verifyUrl}
+Approve this login in a browser${remote ? " on any device (this machine has no browser; your laptop or phone is fine)" : ""}:
+  ${started2.verifyUrl}
 
-Confirm the code matches:  ${started.userCode}
+Confirm the code matches:  ${started2.userCode}
 
 `);
-    if (options.browser) openBrowser(started.verifyUrl);
-    const deadline = Date.now() + started.expiresIn * 1e3;
+    if (options.browser && !remote) openBrowser(started2.verifyUrl);
+    const deadline = Date.now() + started2.expiresIn * 1e3;
     while (Date.now() < deadline) {
-      await sleep(started.interval * 1e3);
-      const poll = await api.post("/cli/auth/poll", { deviceCode: started.deviceCode });
+      await sleep(started2.interval * 1e3);
+      const poll = await api.post("/cli/auth/poll", { deviceCode: started2.deviceCode });
       if (poll.status === "pending") continue;
       if (poll.status === "denied") throw new CliError("The login was denied in the web app");
       if (poll.status === "expired") break;
@@ -23695,7 +23746,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 -\`.
-- Claim a task with \`slop session start <KEY>\` and run \`slop session wait <KEY>\` in the background so other agents can reach you (\`slop task ask\`); \`slop sessions\` shows who is live. Method: \`slop skill slop-sessions\`.
+- Claim a task with \`slop session start <KEY>\` (it prints what was said to you) and run \`slop session wait <KEY>\` in the background so other agents can reach you. 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.
@@ -23721,8 +23772,9 @@ function git(args, cwd = process.cwd()) {
 function findRepo() {
   const commonDir = git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
   if (!commonDir) return null;
-  const root = basename(commonDir) === ".git" ? resolve(commonDir, "..") : git(["rev-parse", "--show-toplevel"]) ?? commonDir;
-  return { root, linkPath: join4(commonDir, "slop.json") };
+  const worktree = git(["rev-parse", "--show-toplevel"]);
+  const root = basename(commonDir) === ".git" ? resolve(commonDir, "..") : worktree ?? commonDir;
+  return { root, worktree: worktree ?? root, linkPath: join4(commonDir, "slop.json") };
 }
 function requireRepo() {
   const repo = findRepo();
@@ -23845,17 +23897,13 @@ function registerProjectCommands(program3) {
     const statuses = await api.put(`/projects/${target.id}/statuses/order`, { ids: refs.map((ref) => columnOf(target, ref).id) });
     emit(statuses, () => list(statuses));
   });
-  project.command("update").description("Change the linked project's name, description or theme.").option("-p, --project <key>", "project key (default: the linked project)").option("-n, --name <name>").option("-d, --description <text>").option("--theme <theme>", `${PROJECT_THEMES.join(" | ")} | none`).action(async (options) => {
+  project.command("update").description("Change the linked project's name or description.").option("-p, --project <key>", "project key (default: the linked project)").option("-n, --name <name>").option("-d, --description <text>").action(async (options) => {
     const api = authedApi();
     const target = await resolveProject(api, options.project);
-    const theme = options.theme === void 0 ? void 0 : options.theme === "none" ? null : options.theme;
-    if (theme && !PROJECT_THEMES.includes(theme)) {
-      throw new CliError(`Unknown theme "${theme}"`, `use one of: ${PROJECT_THEMES.join(", ")}, none`);
+    if (options.name === void 0 && options.description === void 0) {
+      throw new CliError("Nothing to change", "pass --name or --description");
     }
-    if (options.name === void 0 && options.description === void 0 && theme === void 0) {
-      throw new CliError("Nothing to change", "pass --name, --description or --theme");
-    }
-    const updated = await api.patch(`/projects/${target.id}`, { name: options.name, description: options.description, theme });
+    const updated = await api.patch(`/projects/${target.id}`, { name: options.name, description: options.description });
     emit(updated, () => `Updated ${updated.key}  ${updated.name}`);
   });
   project.command("create <name>").description("Create a project.").option("-k, --key <key>", "task key prefix, e.g. WEB (default: derived from the name)").option("-d, --description <text>", "what the project is").option("--org <slug-or-id>", "which org, if you belong to several").action(async (name, options) => {
@@ -23891,24 +23939,102 @@ Try: slop task create "My first task"`);
   program3.command("status").description("Show what this repository is linked to.").action(async () => {
     const repo = findRepo();
     const link = repo ? readLink(repo) : null;
+    const where = !repo ? "" : repo.worktree === repo.root ? repo.root : `${repo.worktree}  (worktree of ${repo.root})`;
     emit(
-      { repo: repo?.root ?? null, link },
-      () => !repo ? "Not inside a git repository." : !link ? `${repo.root}
-not linked. Run: slop link <PROJECT_KEY>` : `${repo.root}
+      { repo: repo?.root ?? null, worktree: repo?.worktree ?? null, link },
+      () => !repo ? "Not inside a git repository." : !link ? `${where}
+not linked. Run: slop link <PROJECT_KEY>` : `${where}
 linked to ${link.projectKey}  ${link.projectName}  (${link.baseUrl})`
     );
   });
 }
 
 // src/commands/sessions.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
+
+// src/commands/threads.ts
+import { readFileSync as readFileSync5 } from "fs";
+var readText = (value) => value === "-" ? readFileSync5(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}` : ""})` : ""}`;
+function threadLine(thread) {
+  const scope = thread.taskKey ?? "general";
+  const unread = thread.unread > 0 ? `  ${thread.unread} unread` : "";
+  const last = thread.last ? `
+    ${who(thread.last)}: ${thread.last.body.split("\n")[0]}` : "";
+  return `${thread.id}  [${scope}]  ${thread.subject}  (${thread.messageCount} msg, ${when(thread.lastMessageAt)})${unread}${last}`;
+}
+function messageBlock(message) {
+  return `${who(message)}  ${when(message.createdAt)}
+${message.body.replace(/^/gm, "  ")}`;
+}
+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}
+${messageBlock(push.message)}
+Reply: slop thread reply ${push.thread.id} "\u2026"`;
+}
+function registerThreadCommands(program3, task) {
+  const withProject = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
+  withProject(program3.command("threads")).description("List the project's threads, newest activity first.").option("-t, --task <key>", "only threads about this task").option("--general", "only general threads").option("--unread", "only threads with messages you have not read").action(async (options) => {
+    const api = authedApi();
+    const project = await resolveProject(api, options.project);
+    const query = new URLSearchParams();
+    if (options.task) query.set("task", options.task);
+    if (options.general) query.set("scope", "general");
+    if (options.unread) query.set("unread", "1");
+    const threads = await api.get(`/projects/${project.id}/threads${query.size ? `?${query}` : ""}`);
+    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) => {
+    const api = authedApi();
+    const project = await resolveProject(api, options.project);
+    const result = await api.post(`/projects/${project.id}/threads`, { subject, task: options.task, body: readText(options.message) });
+    emit(result, () => started(result));
+  });
+  withProject(thread.command("show <id>")).description("Read a thread (and mark it read).").action(async (id, options) => {
+    const api = authedApi();
+    const project = await resolveProject(api, options.project);
+    const detail = await api.get(`/projects/${project.id}/threads/${id}`);
+    emit(detail, () => threadBlock(detail));
+  });
+  withProject(thread.command("reply <id> <text>")).description('Reply in a thread. About a task: reaches whoever is live on it. "-" reads stdin.').action(async (id, text, options) => {
+    const api = authedApi();
+    const project = await resolveProject(api, options.project);
+    const result = await api.post(`/projects/${project.id}/threads/${id}/messages`, { body: readText(text) });
+    emit(result, () => result.delivered ? `Replied; reached ${result.delivered} live session${result.delivered === 1 ? "" : "s"}.` : "Replied. Nobody is live on it; they see it when they start.");
+  });
+  withProject(program3.command("post <text>")).description('Start a general thread from one message (the first line is the subject). For a task, use --task. "-" reads stdin.').option("-t, --task <key>", "about this task").action(async (text, options) => {
+    const api = authedApi();
+    const project = await resolveProject(api, options.project);
+    const body2 = readText(text);
+    const result = await api.post(`/projects/${project.id}/threads`, { subject: subjectOf(body2), 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 = readText(text);
+    const result = await api.post(`/projects/${project.id}/threads`, { subject: subjectOf(body2), 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.`;
 
 // src/commands/tasks.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 
 // src/commands/items.ts
-import { readFileSync as readFileSync5 } from "fs";
-var readText = (value) => value === "-" ? readFileSync5(0, "utf8").trim() : value;
+import { readFileSync as readFileSync6 } from "fs";
+var readText2 = (value) => value === "-" ? readFileSync6(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> -";
@@ -23935,7 +24061,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] === "-" ? readFileSync5(0, "utf8") : lines.join("\n");
+    const source = lines.length === 1 && lines[0] === "-" ? readFileSync6(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 })) });
@@ -23945,7 +24071,7 @@ function registerItemCommands(task, withProject) {
   withProject(item.command("add <key> <title>")).description("Add an item to the end of the plan.").option("-n, --note <text>", 'what is true about it now; "-" reads stdin').action(async (key, title3, options) => {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
-    const items = await api.post(path2(project.id, key), { title: title3, note: options.note ? readText(options.note) : "" });
+    const items = await api.post(path2(project.id, key), { title: title3, note: options.note ? readText2(options.note) : "" });
     emit(items, () => renderItems(items));
   });
   for (const [name, done, help] of [
@@ -23964,7 +24090,7 @@ function registerItemCommands(task, withProject) {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
     const target = await itemAt(api, project.id, key, ref);
-    const items = await api.patch(`${path2(project.id, key)}/${target.id}`, { note: readText(text) });
+    const items = await api.patch(`${path2(project.id, key)}/${target.id}`, { note: readText2(text) });
     emit(items, () => renderItems(items));
   });
   withProject(item.command("rename <key> <item> <title>")).description("Retitle an item.").action(async (key, ref, title3, options) => {
@@ -23992,7 +24118,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 === "-" ? readFileSync6(0, "utf8").trim() : value;
+var readDescription = (value) => value === "-" ? readFileSync7(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) {
@@ -24007,17 +24133,17 @@ function statusInCategory(project, category) {
   return status.key;
 }
 var ASSIGNEE_HELP = 'an email, a name, "me", or "none"';
-async function resolveAssignee(api, projectId, who) {
-  if (who === void 0) return void 0;
-  if (who.toLowerCase() === "none") return null;
-  if (who.toLowerCase() === "me") return (await api.get("/me")).user.id;
-  const needle = who.toLowerCase();
+async function resolveAssignee(api, projectId, who2) {
+  if (who2 === void 0) return void 0;
+  if (who2.toLowerCase() === "none") return null;
+  if (who2.toLowerCase() === "me") return (await api.get("/me")).user.id;
+  const needle = who2.toLowerCase();
   const members2 = await listMembers(api, projectId);
   const exact = members2.filter((member) => member.email.toLowerCase() === needle || member.name.toLowerCase() === needle);
   const matches = exact.length > 0 ? exact : members2.filter((member) => member.email.toLowerCase().includes(needle) || member.name.toLowerCase().includes(needle));
   if (matches.length === 1) return matches[0].userId;
-  if (matches.length === 0) throw new CliError(`Nobody in this project matches "${who}"`, "slop members");
-  throw new CliError(`"${who}" matches ${matches.map((member) => member.email).join(", ")}`, "use the full email");
+  if (matches.length === 0) throw new CliError(`Nobody in this project matches "${who2}"`, "slop members");
+  throw new CliError(`"${who2}" matches ${matches.map((member) => member.email).join(", ")}`, "use the full email");
 }
 function registerTaskCommands(program3) {
   const task = program3.command("task").alias("tasks").description("Create, read and move tasks in the linked project.");
@@ -24090,10 +24216,10 @@ ${taskUrl(api.baseUrl, project.id, created)}`);
     const updated = await api.patch(`/projects/${project.id}/tasks/${encodeURIComponent(key)}`, { status: resolveStatus(project, column) });
     emit(updated, () => `${updated.key} is now in ${statusLabel(project.statuses, updated.status)}.`);
   });
-  withProject(task.command("assign <key> <who>")).description(`Assign a task to ${ASSIGNEE_HELP}.`).action(async (key, who, options) => {
+  withProject(task.command("assign <key> <who>")).description(`Assign a task to ${ASSIGNEE_HELP}.`).action(async (key, who2, options) => {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
-    const updated = await api.patch(`/projects/${project.id}/tasks/${encodeURIComponent(key)}`, { assigneeId: await resolveAssignee(api, project.id, who) });
+    const updated = await api.patch(`/projects/${project.id}/tasks/${encodeURIComponent(key)}`, { assigneeId: await resolveAssignee(api, project.id, who2) });
     emit(updated, () => `${updated.key} is assigned to ${updated.assignee?.name ?? "nobody"}.`);
   });
   for (const [name, category] of [["start", "in_progress"], ["done", "done"]]) {
@@ -24144,11 +24270,10 @@ ${taskUrl(api.baseUrl, project.id, created)}`);
 
 // src/commands/sessions.ts
 var taskPath = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var readText2 = (value) => value === "-" ? readFileSync7(0, "utf8").trim() : value;
 var sessionLine = (session) => [session.taskKey, session.user.name, session.machine.name, session.startedAt];
 function messageLine(record2) {
-  const body = record2.event.kind === "message" ? record2.event.body : JSON.stringify(record2.event);
-  return `${record2.actor.name} (${record2.createdAt}): ${body}`;
+  const body2 = record2.event.kind === "message" ? record2.event.body : JSON.stringify(record2.event);
+  return `${record2.actor.name} (${record2.createdAt}): ${body2}`;
 }
 function registerSessionCommands(program3, task) {
   const withProject = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
@@ -24158,10 +24283,19 @@ function registerSessionCommands(program3, task) {
     const project = await loadProject(api, (await resolveProject(api, options.project)).id);
     const assigneeId = await resolveAssignee(api, project.id, "me");
     const updated = await api.patch(taskPath(project.id, key), { assigneeId, status: statusInCategory(project, "in_progress") });
-    emit(updated, () => `Claimed ${updated.key}  ${updated.title}
-Go live (in the background, and relaunch it after each message):  slop session wait ${updated.key}`);
+    const [about, general] = await Promise.all([
+      api.get(`/projects/${project.id}/threads?task=${encodeURIComponent(updated.key)}&unread=1&read=1`),
+      api.get(`/projects/${project.id}/threads?scope=general&unread=1&read=1`)
+    ]);
+    emit({ task: updated, threads: { task: about, general } }, () => {
+      const lines = [`Claimed ${updated.key}  ${updated.title}`];
+      if (about.length) lines.push("", `Unread about ${updated.key} (read one with slop thread show <id>):`, ...about.map(threadLine));
+      if (general.length) lines.push("", `Unread general threads (for context; nobody has to answer):`, ...general.map(threadLine));
+      lines.push("", `Go live (in the background, and relaunch it after each message):  slop session wait ${updated.key}`);
+      return lines.join("\n");
+    });
   });
-  withProject(session.command("wait <key>")).description("Hold a live session on the task until someone says something; print it and exit. Exit 2 if the session was ended, 3 on timeout, 4 if the connection dropped (relaunch).").option("--timeout <seconds>", "give up after this long (default: never)").action(async (key, options) => {
+  withProject(session.command("wait <key>")).description("Hold a live session on the task until someone says something in a thread about it; print it and exit. Exit 2 if the session was ended, 3 on timeout, 4 if the connection dropped (relaunch). --follow stays up and prints each message as it comes.").option("--timeout <seconds>", "give up after this long (default: never)").option("--follow", "keep the session and print every message instead of exiting on the first").action(async (key, options) => {
     const api = authedApi();
     const project = await resolveProject(api, options.project);
     const ticket = await api.post(`${taskPath(project.id, key)}/session/ticket`);
@@ -24183,6 +24317,16 @@ Go live (in the background, and relaunch it after each message):  slop session w
           resolve2({ ended: true });
           return;
         }
+        if (push.type === "thread") {
+          if (options.follow) {
+            emit({ thread: push.thread, message: push.message }, () => `${pushBlock(push)}
+`);
+            return;
+          }
+          resolve2({ push });
+          return;
+        }
+        if (push.type !== "event") return;
         resolve2({ record: push.record });
       });
       socket.addEventListener("close", (event) => {
@@ -24195,8 +24339,9 @@ Go live (in the background, and relaunch it after each message):  slop session w
         resolve2({ closed: "socket error" });
       });
     });
-    if ("record" in outcome) {
-      emit(outcome.record, () => messageLine(outcome.record));
+    if ("record" in outcome || "push" in outcome) {
+      if ("push" in outcome) emit(outcome.push, () => pushBlock(outcome.push));
+      else emit(outcome.record, () => messageLine(outcome.record));
       socket.close(1e3, "handled");
       await new Promise((resolve2) => {
         socket.addEventListener("close", () => resolve2(), { once: true });
@@ -24223,12 +24368,6 @@ Go live (in the background, and relaunch it after each message):  slop session w
     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)]));
   });
-  withProject(task.command("ask <key> <text>")).description('Say something to whoever is live on the task; "-" reads stdin. It also goes on the timeline.').action(async (key, text, options) => {
-    const api = authedApi();
-    const project = await resolveProject(api, options.project);
-    const result = await api.post(`${taskPath(project.id, key)}/ask`, { body: readText2(text) });
-    emit(result, () => result.delivered ? `Delivered to ${result.delivered} live session${result.delivered === 1 ? "" : "s"}.` : "Nobody is live on it; left on the timeline.");
-  });
 }
 
 // src/commands/skills.ts
@@ -24253,10 +24392,12 @@ ${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.1.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)");
+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.2.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)");
 registerAuthCommands(program2);
 registerProjectCommands(program2);
-registerSessionCommands(program2, registerTaskCommands(program2));
+var taskCommand = registerTaskCommands(program2);
+registerSessionCommands(program2, taskCommand);
+registerThreadCommands(program2, taskCommand);
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(fail);

package/package.json

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