slopwaresystems 0.1.2 → 0.2.0

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\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 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]\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(`}`);
 }
@@ -23305,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"];
@@ -23415,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
@@ -23490,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) {
@@ -23522,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)
   };
 }
@@ -23652,20 +23694,20 @@ function registerAuthCommands(program3) {
   program3.command("login").description("Sign this machine in. Opens the web app, where you approve the login. On a VM or over SSH, open the printed link on any device.").option("--url <url>", "the Slopware Tasks instance to sign in to").option("--no-browser", "print the link instead of opening it").action(async (options) => {
     const baseUrl = (options.url || process.env.SLOP_URL || 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 a browser${remote ? " on any device (this machine has no browser; your laptop or phone is fine)" : ""}:
-  ${started.verifyUrl}
+  ${started2.verifyUrl}
 
-Confirm the code matches:  ${started.userCode}
+Confirm the code matches:  ${started2.userCode}
 
 `);
-    if (options.browser && !remote) 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;
@@ -23704,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.
@@ -23908,14 +23950,91 @@ 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> -";
@@ -23942,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 })) });
@@ -23952,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 [
@@ -23971,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) => {
@@ -23999,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) {
@@ -24014,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.");
@@ -24097,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"]]) {
@@ -24151,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)");
@@ -24165,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`);
@@ -24190,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) => {
@@ -24202,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 });
@@ -24230,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
@@ -24260,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.2").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => setJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
+var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.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.2",
+  "version": "0.2.0",
   "private": false,
   "description": "slop: the Slopware Tasks board from the terminal, for people and coding agents.",
   "type": "module",