slopwaresystems 0.2.2 → 0.2.4

package/dist/index.js

@@ -3385,7 +3385,7 @@ var slop_cli_default = '---\nname: slop-cli\ndescription: How to use the slop CL
 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 (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**, or in **a thread you have written in** (that is how answers find you, even from a general thread or another ticket), reaches you at once. Nothing else does.\n- **Everything else waits.** `slop session start <KEY>` prints the unread threads about that task and the unread general ones (read those for context). `slop threads` lists them any time; `slop thread show <id>` reads one.\n- Your own messages never wake your own waiter.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `claim_task(task)`. Assigns the task to you, moves it to in progress, and returns what is unread about it. Read that first.\n2. **Work.** Keep the plan\'s notes current with `note_item`, tick with `finish_item`.\n3. **You are live from now on.** `claim_task` holds your session for as long as the harness runs the server. A message in a thread about your task, or in any thread you have written in, reaches you on its own: right after your next tool call (any tool; a hook on Claude Code and on Codex hands it to you), and in every slop tool\'s result besides. There is nothing to poll and nothing to restart. When one arrives, act or answer with `reply(thread, body)` and carry on.\n4. **Nothing to do but wait?** `wait_for_message(task, minutes)` blocks until the next message. Optional; most of the time you just keep working.\n5. **Finish:** `finish_task(task)` (it also releases the session), or `release_task` to step off without finishing.\n\nBoth harnesses also refuse to stop while messages are unread about your task (a Stop hook), so nothing is lost at the end of a turn.\n\n## The loop without MCP (scripts, older setups)\n\n`slop session start <KEY>`, then `slop session wait <KEY>` in the background. It prints the first message and exits; **the exit is the message**: read it, reply with `slop thread reply <id> "\u2026"`, run `slop session wait <KEY>` again at once. Exit codes: 0 message, 2 ended on purpose (stop), 3 timeout, 4 dropped (relaunch). `--follow` streams instead of exiting, for harnesses that watch output.\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 claim a task that has someone else\'s live session (`sessions`); write in a thread about it first.\n- Answer messages about your task promptly: the other agent is blocked on you.\n- Report progress in the plan\'s notes, not in threads. Threads are for talking to someone.\n- If you stop working on a task, end the session so nobody waits on you.\n';
+var slop_sessions_default = '---\nname: slop-sessions\ndescription: How an agent claims a task, stays reachable on it (a live session), sees who else is live, and talks to other agents and people through the project\'s message board. Load when starting work on a task, when asked to check on other agents, when a `slop session wait` background task finishes, or when asked to leave a message for someone.\n---\n\n# Sessions and the board\n\nA **session** is you, live. With the MCP server it exists from your first slop tool call until your harness exits: first as presence in the project (no task), then on the task you claim. Being live means messages find you. Sessions are visible to everyone (`slop sessions`, the board\'s live badges) and are advisory: they say who is working, they do not lock anything.\n\n**Threads** are how agents and people talk across sessions. A thread has a subject, a scope (one task, or general) and messages; it is stored, so nothing is lost when a session ends. **The task is the address:** to reach the agent on ST-3, you write in a thread about ST-3. General threads are for people and for context; nobody claims them and you never have to answer one.\n\n## What wakes you, and what waits\n\n- A message in a thread **about the task you are live on**, or in **a thread you have written in** (that is how answers find you, even from a general thread or another ticket), reaches you at once. Nothing else does.\n- **Everything else waits.** `slop session start <KEY>` prints the unread threads about that task and the unread general ones (read those for context). `slop threads` lists them any time; `slop thread show <id>` reads one.\n- Your own messages never wake your own waiter.\n\n## The loop (MCP: the way that works)\n\nYour harness has the `slop` MCP server (`slop mcp install` set it up). Use its tools; nothing runs in the background and nothing has to be restarted.\n\n1. **Claim:** `claim_task(task)`. Assigns the task to you, moves it to in progress, and returns what is unread about it. Read that first.\n2. **Work.** Keep the plan\'s notes current with `note_item`, tick with `finish_item`.\n3. **You are live from your first call.** The server holds presence in the project as soon as you use any tool, and `claim_task` upgrades it to the task; `finish_task` or `release_task` drops back to presence. Either way, for as long as the harness runs the server A message in a thread about your task, or in any thread you have written in, reaches you on its own: right after your next tool call (any tool; a hook on Claude Code and on Codex hands it to you), and in every slop tool\'s result besides. There is nothing to poll and nothing to restart. When one arrives, act or answer with `reply(thread, body)` and carry on.\n4. **Nothing to do but wait?** `wait_for_message(task, minutes)` blocks until the next message. Optional; most of the time you just keep working.\n5. **Finish:** `finish_task(task)` (it also releases the session), or `release_task` to step off without finishing.\n\nBoth harnesses also refuse to stop while messages are unread about your task (a Stop hook), so nothing is lost at the end of a turn.\n\n## The loop without MCP (scripts, older setups)\n\n`slop session start <KEY>`, then `slop session wait <KEY>` in the background. It prints the first message and exits; **the exit is the message**: read it, reply with `slop thread reply <id> "\u2026"`, run `slop session wait <KEY>` again at once. Exit codes: 0 message, 2 ended on purpose (stop), 3 timeout, 4 dropped (relaunch). `--follow` streams instead of exiting, for harnesses that watch output.\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, and one agent per working directory: run each agent in its own checkout or git worktree, so its inbox is its own.\n- Do not claim a task that has someone else\'s live session (`sessions`); 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 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';
@@ -23442,8 +23442,9 @@ var TaskEventRecord = external_exports.object({
 // ../contract/src/work/sessions.ts
 var Session = external_exports.object({
   id: Id,
-  taskId: Id,
-  taskKey: external_exports.string(),
+  /** Null: the agent is live in the project but on no task yet (presence). Replies in threads it is part of still reach it. */
+  taskId: Id.nullable(),
+  taskKey: external_exports.string().nullable(),
   user: UserRef,
   machine: external_exports.object({ id: Id, name: external_exports.string() }),
   startedAt: Timestamp
@@ -23517,6 +23518,29 @@ function resolveSession() {
   return { baseUrl, token };
 }
 
+// src/platform/session-file.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+var sessionsDir = () => join3(dirname2(configPath()), "sessions");
+var realCwd = (cwd) => {
+  try {
+    return realpathSync(cwd);
+  } catch {
+    return cwd;
+  }
+};
+var sessionFile = (cwd) => join3(sessionsDir(), `${createHash("sha256").update(realCwd(cwd)).digest("hex").slice(0, 16)}.txt`);
+function rememberSession(cwd, sessionId) {
+  mkdirSync3(sessionsDir(), { recursive: true });
+  if (sessionId) writeFileSync3(sessionFile(cwd), sessionId);
+  else rmSync2(sessionFile(cwd), { force: true });
+}
+function rememberedSession(cwd) {
+  const path3 = sessionFile(cwd);
+  return existsSync3(path3) ? readFileSync3(path3, "utf8").trim() || null : null;
+}
+
 // src/platform/errors.ts
 var CliError = class extends Error {
   constructor(message, hint, code = "error", exitCode = 1) {
@@ -23536,6 +23560,7 @@ function createApi(options) {
     const headers = { accept: "application/json" };
     if (body2 !== void 0) headers["content-type"] = "application/json";
     if (options.token) headers.authorization = `Bearer ${options.token}`;
+    if (client.sessionId) headers["x-slop-session"] = client.sessionId;
     let response;
     try {
       response = await fetch(`${options.baseUrl}/api${path3}`, {
@@ -23561,27 +23586,31 @@ function createApi(options) {
     }
     throw new CliError(`${method} ${path3} failed with HTTP ${response.status}`, void 0, "http");
   }
-  return {
+  const client = {
     baseUrl: options.baseUrl,
+    sessionId: null,
     get: (path3) => request("GET", path3),
     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)
   };
+  return client;
 }
 function authedApi() {
   const session = resolveSession();
   if (!session.token) throw new CliError(`Not signed in to ${session.baseUrl}`, "slop login", "unauthenticated");
-  return createApi(session);
+  const client = createApi(session);
+  client.sessionId = rememberedSession(process.cwd());
+  return client;
 }
 
 // src/platform/machine.ts
 import { execFileSync } from "child_process";
-import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { hostname as hostname3, platform, userInfo } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname3, join as join4 } from "path";
 function run(command, args) {
   try {
     return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
@@ -23595,7 +23624,7 @@ function osMachineId() {
       return /"IOPlatformUUID" = "([^"]+)"/.exec(run("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]) ?? "")?.[1] ?? null;
     case "linux":
       for (const path3 of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-        if (existsSync3(path3)) return readFileSync3(path3, "utf8").trim() || null;
+        if (existsSync4(path3)) return readFileSync4(path3, "utf8").trim() || null;
       }
       return null;
     case "win32":
@@ -23607,18 +23636,18 @@ function osMachineId() {
   }
 }
 function persistedMachineId() {
-  const path3 = join3(dirname2(configPath()), "machine-id");
-  if (existsSync3(path3)) return readFileSync3(path3, "utf8").trim();
+  const path3 = join4(dirname3(configPath()), "machine-id");
+  if (existsSync4(path3)) return readFileSync4(path3, "utf8").trim();
   const id = randomUUID();
-  mkdirSync3(dirname2(path3), { recursive: true, mode: 448 });
-  writeFileSync3(path3, `${id}
+  mkdirSync4(dirname3(path3), { recursive: true, mode: 448 });
+  writeFileSync4(path3, `${id}
 `, { mode: 384 });
   return id;
 }
 function machineInfo() {
   const raw = `${osMachineId() ?? persistedMachineId()}:${userInfo().username}`;
   return {
-    fingerprint: createHash("sha256").update(raw).digest("hex"),
+    fingerprint: createHash2("sha256").update(raw).digest("hex"),
     name: hostname3().replace(/\.local$/, ""),
     platform: platform()
   };
@@ -23759,9 +23788,9 @@ function registerGuideCommand(program3) {
 
 // src/platform/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename, join as join4, resolve } from "path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { basename, join as join5, resolve } from "path";
 function git(args, cwd = process.cwd()) {
   try {
     return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
@@ -23774,7 +23803,7 @@ function findRepo() {
   if (!commonDir) return null;
   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") };
+  return { root, worktree: worktree ?? root, linkPath: join5(commonDir, "slop.json") };
 }
 function requireRepo() {
   const repo = findRepo();
@@ -23783,17 +23812,17 @@ function requireRepo() {
 }
 function readLink(repo) {
   try {
-    return JSON.parse(readFileSync4(repo.linkPath, "utf8"));
+    return JSON.parse(readFileSync5(repo.linkPath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeLink(repo, link) {
-  writeFileSync4(repo.linkPath, `${JSON.stringify(link, null, 2)}
+  writeFileSync5(repo.linkPath, `${JSON.stringify(link, null, 2)}
 `);
 }
 function removeLink(repo) {
-  if (existsSync4(repo.linkPath)) rmSync2(repo.linkPath);
+  if (existsSync5(repo.linkPath)) rmSync3(repo.linkPath);
 }
 function normalizeRemote(url2) {
   const scp = /^[^@/]+@([^:/]+):(.+)$/.exec(url2);
@@ -23807,7 +23836,7 @@ function describeRepo(repo, existing) {
   let fingerprint;
   let localRepoId;
   if (roots) {
-    fingerprint = createHash2("sha256").update(roots.split("\n").sort().join("\n")).digest("hex");
+    fingerprint = createHash3("sha256").update(roots.split("\n").sort().join("\n")).digest("hex");
   } else {
     localRepoId = existing?.localRepoId ?? randomUUID2();
     fingerprint = `local:${localRepoId}`;
@@ -23951,10 +23980,11 @@ linked to ${link.projectKey}  ${link.projectName}  (${link.baseUrl})`
 
 // src/commands/mcp.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8, readdirSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync, realpathSync as realpathSync2, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4 } from "path";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/platform/live.ts
 async function waitForMessage(api, projectId, taskKey, options = {}) {
@@ -23969,6 +23999,8 @@ async function waitForMessage(api, projectId, taskKey, options = {}) {
     socket.addEventListener("message", (event) => {
       const push = JSON.parse(String(event.data));
       if (push.type === "hello") {
+        api.sessionId = push.session.id;
+        rememberSession(process.cwd(), push.session.id);
         options.onHello?.(push.session);
         return;
       }
@@ -23983,6 +24015,7 @@ async function waitForMessage(api, projectId, taskKey, options = {}) {
     socket.addEventListener("close", (event) => done({ kind: "dropped", reason: event.reason || `code ${event.code}` }));
     socket.addEventListener("error", () => done({ kind: "dropped", reason: "socket error" }));
   });
+  if (outcome.kind !== "message") rememberSession(process.cwd(), null);
   if (outcome.kind === "message" || outcome.kind === "timeout") {
     socket.close(1e3, outcome.kind === "message" ? "handled" : "timeout");
     await new Promise((resolve2) => {
@@ -24014,7 +24047,7 @@ var HeldSession = class {
   async connect() {
     if (this.stopped) return;
     try {
-      const ticket = await this.api.post(`/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket`);
+      const ticket = await this.api.post(this.taskKey ? `/projects/${this.projectId}/tasks/${encodeURIComponent(this.taskKey)}/session/ticket` : `/projects/${this.projectId}/session/ticket`);
       const socket = new WebSocket(`${this.api.baseUrl.replace(/^http/, "ws")}/api${ticket.path}`);
       this.socket = socket;
       socket.addEventListener("open", () => {
@@ -24022,6 +24055,11 @@ var HeldSession = class {
       });
       socket.addEventListener("message", (event) => {
         const push = JSON.parse(String(event.data));
+        if (push.type === "hello") {
+          this.api.sessionId = push.session.id;
+          rememberSession(process.cwd(), push.session.id);
+          return;
+        }
         if (push.type === "end") {
           this.stopped = true;
           return;
@@ -24047,6 +24085,8 @@ var HeldSession = class {
   }
   stop() {
     this.stopped = true;
+    this.api.sessionId = null;
+    rememberSession(process.cwd(), null);
     if (this.timer) clearTimeout(this.timer);
     this.socket?.close(1e3, "released");
   }
@@ -24109,11 +24149,11 @@ function serveMcp(tools2, info) {
 }
 
 // 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 readText = (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> -";
@@ -24140,7 +24180,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 })) });
@@ -24197,7 +24237,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) {
@@ -24348,8 +24388,8 @@ ${taskUrl(api.baseUrl, project.id, created)}`);
 }
 
 // src/commands/threads.ts
-import { readFileSync as readFileSync7 } from "fs";
-var readText2 = (value) => value === "-" ? readFileSync7(0, "utf8").trim() : value;
+import { readFileSync as readFileSync8 } from "fs";
+var readText2 = (value) => value === "-" ? readFileSync8(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) {
@@ -24430,24 +24470,28 @@ var int2 = (description2) => ({ type: "integer", description: description2 });
 var schema = (properties, required2 = []) => ({ type: "object", properties, required: required2, additionalProperties: false });
 var PROJECT = str("Project key. Defaults to the project this repository is linked to.");
 var taskPath = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var inboxDir = () => join5(dirname3(configPath()), "inbox");
-var inboxFile = (projectId) => join5(inboxDir(), `${projectId}.jsonl`);
-function inboxWrite(projectId, push) {
-  mkdirSync4(inboxDir(), { recursive: true });
-  appendFileSync(inboxFile(projectId), `${JSON.stringify(push)}
+var inboxDir = () => join6(dirname4(configPath()), "inbox");
+var realCwd2 = (cwd) => {
+  try {
+    return realpathSync2(cwd);
+  } catch {
+    return cwd;
+  }
+};
+var inboxKey = (cwd) => createHash4("sha256").update(realCwd2(cwd)).digest("hex").slice(0, 16);
+var inboxFile = (cwd) => join6(inboxDir(), `${inboxKey(cwd)}.jsonl`);
+function inboxWrite(cwd, push) {
+  mkdirSync5(inboxDir(), { recursive: true });
+  appendFileSync(inboxFile(cwd), `${JSON.stringify(push)}
 `);
 }
-function inboxDrain(projectId) {
-  const path3 = inboxFile(projectId);
-  if (!existsSync5(path3)) return [];
-  const lines = readFileSync8(path3, "utf8").split("\n").filter(Boolean);
-  rmSync3(path3, { force: true });
+function inboxDrain(cwd) {
+  const path3 = inboxFile(cwd);
+  if (!existsSync6(path3)) return [];
+  const lines = readFileSync9(path3, "utf8").split("\n").filter(Boolean);
+  rmSync4(path3, { force: true });
   return lines.map((line) => JSON.parse(line));
 }
-function inboxDrainAll() {
-  if (!existsSync5(inboxDir())) return [];
-  return readdirSync(inboxDir()).flatMap((name) => inboxDrain(name.replace(/\.jsonl$/, "")));
-}
 async function digest(api, projectId, taskKey) {
   const [about, mine, general] = await Promise.all([
     taskKey ? api.get(`/projects/${projectId}/threads?task=${encodeURIComponent(taskKey)}&unread=1&read=1`) : Promise.resolve([]),
@@ -24463,17 +24507,21 @@ async function digest(api, projectId, taskKey) {
 }
 function tools() {
   const api = authedApi();
-  const project = (args) => resolveProject(api, args.project);
+  const resolveOnly = (args) => resolveProject(api, args.project);
   let held = null;
   const hold = async (projectId, taskKey) => {
     if (held && held.projectId === projectId && held.taskKey === taskKey) return;
     held?.stop();
-    held = new HeldSession(api, projectId, taskKey, (push) => inboxWrite(projectId, push));
+    held = new HeldSession(api, projectId, taskKey, (push) => inboxWrite(process.cwd(), push));
     await held.start();
   };
-  const release = () => {
-    held?.stop();
-    held = null;
+  const project = async (args) => {
+    const target = await resolveOnly(args);
+    if (!held) await hold(target.id, null);
+    return target;
+  };
+  const release = async () => {
+    if (held?.taskKey) await hold(held.projectId, null);
   };
   return [
     {
@@ -24483,7 +24531,7 @@ function tools() {
       run: async (args) => {
         const target = await project(args);
         await hold(target.id, String(args.task));
-        const queued = inboxDrain(target.id);
+        const queued = inboxDrain(process.cwd());
         if (queued.length) return queued.map(pushBlock).join("\n\n");
         const minutes = typeof args.minutes === "number" ? args.minutes : 10;
         const push = await new Promise((resolve2) => {
@@ -24506,7 +24554,7 @@ function tools() {
       inputSchema: schema({ task: str("Task key"), project: PROJECT }),
       run: async (args) => {
         const target = await project(args);
-        const queued = inboxDrain(target.id).map(pushBlock);
+        const queued = inboxDrain(process.cwd()).map(pushBlock);
         const rest = await digest(api, target.id, args.task ?? null);
         return [...queued, rest].join("\n\n");
       }
@@ -24552,11 +24600,11 @@ function tools() {
     },
     {
       name: "sessions",
-      description: "Who is live on which task right now.",
+      description: "Who is live right now: on which task, or present in the project on no task yet.",
       inputSchema: schema({ project: PROJECT }),
       run: async (args) => {
         const list = await api.get(`/projects/${(await project(args)).id}/sessions`);
-        return list.length ? list.map((session) => `${session.taskKey}  ${session.user.name}  ${session.machine.name}  since ${session.startedAt}`).join("\n") : "Nobody is live.";
+        return list.length ? list.map((session) => `${session.taskKey ?? "(no task)"}  ${session.user.name}  ${session.machine.name}  since ${session.startedAt}`).join("\n") : "Nobody is live.";
       }
     },
     {
@@ -24575,11 +24623,11 @@ ${await digest(api, target.id, task.key)}`;
     },
     {
       name: "release_task",
-      description: "Stop being live on the task you hold (without finishing it).",
+      description: "Step off the task you hold without finishing it. You stay live in the project, reachable in threads you are part of.",
       inputSchema: schema({ project: PROJECT }),
       run: async () => {
-        release();
-        return "Released.";
+        await release();
+        return "Released. Still live in the project.";
       }
     },
     {
@@ -24631,15 +24679,15 @@ ${task.notes}` : ""].filter(Boolean).join("\n");
       run: async (args) => {
         const target = await loadProject(api, (await project(args)).id);
         const task = await api.patch(taskPath(target.id, String(args.task)), { status: statusInCategory(target, "done") });
-        release();
-        return `${task.key} is done.`;
+        await release();
+        return `${task.key} is done. You are still live in the project, reachable in threads you are part of.`;
       }
     }
   ];
 }
 function readJson(path3) {
   try {
-    return JSON.parse(readFileSync8(path3, "utf8"));
+    return JSON.parse(readFileSync9(path3, "utf8"));
   } catch {
     return {};
   }
@@ -24652,13 +24700,13 @@ function installClaude() {
   } catch {
     done.push("Claude Code: run `claude mcp add --scope user slop -- slop mcp` (the claude command was not found here)");
   }
-  const dir = join5(homedir3(), ".claude");
-  const path3 = join5(dir, "settings.json");
-  mkdirSync4(dir, { recursive: true });
+  const dir = join6(homedir3(), ".claude");
+  const path3 = join6(dir, "settings.json");
+  mkdirSync5(dir, { recursive: true });
   const settings = readJson(path3);
   settings.hooks = mergeHooks(settings.hooks ?? {});
   settings.env = { ...settings.env ?? {}, MCP_TOOL_TIMEOUT: "1800000" };
-  writeFileSync5(path3, `${JSON.stringify(settings, null, 2)}
+  writeFileSync6(path3, `${JSON.stringify(settings, null, 2)}
 `);
   done.push(`Claude Code: PostToolUse and Stop hooks and MCP_TOOL_TIMEOUT written to ${path3}`);
   return done;
@@ -24676,29 +24724,42 @@ function mergeHooks(hooks) {
 }
 function installCodex() {
   const done = [];
-  const dir = join5(homedir3(), ".codex");
-  mkdirSync4(dir, { recursive: true });
-  const configPath2 = join5(dir, "config.toml");
-  const current = existsSync5(configPath2) ? readFileSync8(configPath2, "utf8") : "";
+  const dir = join6(homedir3(), ".codex");
+  mkdirSync5(dir, { recursive: true });
+  const configPath2 = join6(dir, "config.toml");
+  const current = existsSync6(configPath2) ? readFileSync9(configPath2, "utf8") : "";
   if (/^\[mcp_servers\.slop\]/m.test(current)) done.push(`Codex: MCP server already in ${configPath2}`);
   else {
-    writeFileSync5(configPath2, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
+    writeFileSync6(configPath2, `${current.trimEnd()}${current.trim() ? "\n\n" : ""}[mcp_servers.slop]
 command = "slop"
 args = ["mcp"]
 tool_timeout_sec = 1800
 `);
     done.push(`Codex: MCP server "slop" added to ${configPath2}`);
   }
-  const hooksPath = join5(dir, "hooks.json");
+  const hooksPath = join6(dir, "hooks.json");
   const file2 = readJson(hooksPath);
   file2.hooks = mergeHooks(file2.hooks ?? {});
-  writeFileSync5(hooksPath, `${JSON.stringify(file2, null, 2)}
+  writeFileSync6(hooksPath, `${JSON.stringify(file2, null, 2)}
 `);
   done.push(`Codex: PostToolUse and Stop hooks written to ${hooksPath}. Codex asks you to trust new hooks once (/hooks in a session).`);
   return done;
 }
-function tickHook() {
-  const arrived = inboxDrainAll();
+async function hookCwd() {
+  const input2 = await new Promise((resolve2) => {
+    let data = "";
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve2(data));
+    setTimeout(() => resolve2(data), 2e3);
+  });
+  try {
+    return JSON.parse(input2).cwd ?? process.cwd();
+  } catch {
+    return process.cwd();
+  }
+}
+async function tickHook() {
+  const arrived = inboxDrain(await hookCwd());
   if (arrived.length === 0) return;
   const text = `Messages arrived on Slopware Tasks while you worked:
 
@@ -24709,19 +24770,9 @@ Act or answer with the slop MCP \`reply\` tool, then carry on.`;
 `);
 }
 async function stopHook() {
-  const input2 = await new Promise((resolve2) => {
-    let data = "";
-    process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve2(data));
-    setTimeout(() => resolve2(data), 2e3);
-  });
-  let cwd = process.cwd();
-  try {
-    cwd = JSON.parse(input2).cwd ?? cwd;
-  } catch {
-  }
+  const cwd = await hookCwd();
   process.chdir(cwd);
-  const parts = inboxDrainAll().map(pushBlock);
+  const parts = inboxDrain(cwd).map(pushBlock);
   const repo = findRepo();
   const link = repo ? readLink(repo) : null;
   if (!link) {
@@ -24753,7 +24804,7 @@ function withInbox(list) {
       ...tool,
       run: async (args) => {
         const result = await tool.run(args);
-        const arrived = inboxDrainAll();
+        const arrived = inboxDrain(process.cwd());
         return arrived.length ? `${result}
 
 --- Messages arrived while you worked ---
@@ -24775,9 +24826,9 @@ function registerMcpCommands(program3, version2) {
 }
 
 // src/commands/sessions.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 var taskPath2 = (projectId, key) => `/projects/${projectId}/tasks/${encodeURIComponent(key)}`;
-var sessionLine = (session) => [session.taskKey, session.user.name, session.machine.name, session.startedAt];
+var sessionLine = (session) => [session.taskKey ?? "(no task)", session.user.name, session.machine.name, session.startedAt];
 function registerSessionCommands(program3, task) {
   const withProject = (command) => command.option("-p, --project <key>", "project key (default: the project this repository is linked to)");
   const session = program3.command("session").description("Claim a task and be reachable on it while you work.");
@@ -24859,13 +24910,13 @@ ${written.map((path3) => `  ${path3}`).join("\n")}`);
 }
 
 // src/index.ts
-var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.2.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.4").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => setJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
 registerAuthCommands(program2);
 registerProjectCommands(program2);
 var taskCommand = registerTaskCommands(program2);
 registerSessionCommands(program2, taskCommand);
 registerThreadCommands(program2, taskCommand);
-registerMcpCommands(program2, "0.2.2");
+registerMcpCommands(program2, "0.2.4");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(fail);

package/package.json

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