lobstah 0.6.4 → 0.6.6

package/dist/runner.js

@@ -770,7 +770,8 @@ var DEFAULT_SOAK = {
   deferSecs: 90,
   ttlSecs: 1800,
   beat: true,
-  pausedTtlSecs: 86400
+  pausedTtlSecs: 86400,
+  signOffGraceSecs: 600
 };
 var DEFAULT_HELM = {
   ttlSecs: 1800,
@@ -1741,10 +1742,10 @@ function chainPr(id, lane) {
 // packages/core/dist/pr-repair.js
 var PUSH_RETRIES = 3;
 var PUSH_REJECTED = "push rejected:";
-function pushRule(branch, id = "<dispatch id>", mode = "rebase") {
+function pushRule(branch, id = "<dispatch id>", mode = "rebase", also = []) {
   const b = branch ?? "the PR's head branch";
   return [
-    `Push only to the existing branch ${b}.`,
+    also.length ? `Push only to the existing branch ${b} and the branches of the PRs stacked on it named below.` : `Push only to the existing branch ${b}.`,
     mode === "merge" ? `If the push is rejected as non-fast-forward because ${b} moved, fetch ${b}, merge the moved head into your branch, and push again with a normal push. Retry at most ${PUSH_RETRIES} times. Never force-push.` : `If the push is rejected as non-fast-forward because ${b} moved, fetch ${b}, rebase your commits onto the moved head again, and push with \`--force-with-lease=${b}:<the head you just fetched>\`. Retry at most ${PUSH_RETRIES} times.`,
     "If a push hook fails with a real test or type error, do not retry the push: fix the error, commit, and push again.",
     `If you still cannot push, report \`lobstah report ${id} failed "${PUSH_REJECTED} <rejection text>; moved head <full sha of the head you fetched>"\` and leave the PR as it was.`,

package/docs/configuration.md

@@ -107,6 +107,7 @@ send a continuation.
 | `deferSecs` | `90` | A soaking session whose park heartbeat is this fresh holds unaddressed matching bait — the daemon waits instead of spawning. Addressed bait (`--for session:<id>`) waits regardless, until the registration is gone. |
 | `ttlSecs` | `1800` | Heartbeat age past which a registration is a ghost trap: the sweep removes it and requeues an unfinished catch, finalizes done/failed in `done/`, or finalizes a cancelled catch as failed. A fresh `lobstah report` or beat counts as liveness. If the daemon's own tick gap exceeds this TTL, it grants a full TTL after resume before sweeping any traps. |
 | `beat` | `true` | The post-tool hook (`lobstah soak beat`) refreshes a soaking session's liveness and writes its catch's activity, at most once per 30 seconds per trap. With `false` the hook does nothing, and a trap's liveness comes from its reports and its park only. |
+| `signOffGraceSecs` | `600` | After a trap signs off, its address is held this long: messages to it wait for a re-soak of the same worktree instead of bouncing, `send` to it queues with a warning, and work addressed to it raises no `bait-orphaned` notice. After the grace the daemon bounces the held messages. `0` bounces at sign-off. |
 | `pausedTtlSecs` | `86400` (24 hours) | A trap whose catch last reported `paused` is kept out of the ghost sweep this long after the report. `report paused --until <iso|duration>` sets the expiry instead. After it, the sweep removes the trap as usual, and the notice says the pause expired. |
 
 ## `[helm]` — the orchestrator seat (`lobstah man helm`)

package/docs/design.md

@@ -694,7 +694,7 @@ with [Preact](https://preactjs.com) and [htm](https://github.com/developit/htm)
 | `src/store.ts` | the one store: the latest snapshot, the route, the prefs, the open modal, the stale flag, the lob state |
 | `src/actions.ts` | every change the page can make (open or close a modal, set a preference, hide a lob, receive a snapshot) |
 | `src/main.ts` | the entry: builds the store from localStorage and the URL, renders `App` into the body on every change, starts polling |
-| `src/poll.ts` | `/data` polling: every 2s, one request at a time, paused while the tab is hidden |
+| `src/poll.ts` | `/data` polling: every 2s, one request at a time, paused while the tab is hidden; a 304 applies only the beats (server time and heartbeats) |
 | `src/route.ts` | the hash tabs (`#deck`, `#dispatches`, `#traps`, `#prs`, `#notices`) |
 | `src/prefs.ts` | the per-browser preferences and lob hides, in localStorage |
 | `src/components/*.ts` | `App`, `Header`, `Deck`, `Dispatches`, `Traps`, `PRs`, `Notices`, `Modal` (dispatch, trap, helm, PR, settings), `Lobs` |
@@ -710,9 +710,14 @@ the active tab's section renders.
 The pure helpers stay beside the server in `apps/cli/src` and are imported by
 both sides: `glass-diff.ts` (the per-section selectors, tab route, filters,
 PR modal data) and `glass-lobs.ts` (which lobs walk). The `/data` payload
-type, `GlassSnapshot`, lives in `@lobstah/core`: `buildGlassSnapshot()`
-returns it and every component reads it, so a renamed field fails typecheck
-on both sides. The client typechecks under its own
+type, `GlassSnapshot`, lives in `@lobstah/core`: `glass-poll.ts` builds it
+from `buildGlassSnapshot()` and every component reads it, so a renamed field
+fails typecheck on both sides. `/data` carries dispatch summaries and the
+last day's history (at least the newest few of each kind), with an ETag that
+leaves out heartbeats and ages; those ride in the `x-lobstah-beats` header
+of every answer, a 304 too. A dispatch modal fetches the rest from
+`/data/dispatch/<id>`, and `/data/older?kind=dispatches|notices|prs&offset=<n>`
+pages in older history. The client typechecks under its own
 `apps/cli/glass/tsconfig.json` (DOM lib). `preact` and `htm` are dev
 dependencies of `apps/cli`: they exist only inside the bundled page.
 

package/docs/harness/claude-code.md

@@ -1,9 +1,9 @@
 # lobstah in Claude Code
 
-Use `/lobstah:man` to load the lobstah man skill. `/lobstah:helm` signs on
-without loading the skill. You can also say "Lobstah man, take the helm."
+Use `/lobstah:man` to take the helm. You can also say "Lobstah man, take
+the helm."
 
-This page covers the plugin's commands, skills, session id, and Stop hook.
+This page covers the plugin's skills, session id, and Stop hook.
 See [docs/man.md](../man.md) for the full pattern.
 
 The lobstah man skill brings up the glass and prints its URL. Open it in the
@@ -41,18 +41,17 @@ row, and the session-start brief says when the plugin is behind.
 `lobstah send <id> "<instruction>"` steers live or queued work and wakes a
 finished dispatch as a follow-up.
 
-Slash commands, each a shortcut for a CLI verb:
+The plugin has four skills and no slash commands:
 
-| Command | CLI equivalent |
-| ------- | -------------- |
-| `/lobstah:helm [grounds]` | `lobstah man helm` |
-| `/lobstah:relieve` | `lobstah man relieve` |
-| `/lobstah:tend` | `lobstah man tend` |
-| `/lobstah:soak` | `lobstah soak` |
-| `/lobstah:stow` | `lobstah stow` |
+| Skill | What it does |
+| ----- | ------------ |
+| `/lobstah:man` | Take the helm: `lobstah man helm`, the glass, then the orchestrator flow. |
+| `/lobstah:trap` | Sign on as a trap: `lobstah soak`, then the worker flow. |
+| `/lobstah:stow` | Sign the trap off with `lobstah stow` and report which trap was stowed. |
+| `/lobstah:relieve` | Step down with `lobstah man relieve`; afterwards no `man wait` or `man report`, and no re-take unless asked. |
 
-Claude Code also loads the `man` and `trap` skills on its own when you ask
-for that kind of work ("take the helm", "work as a trap").
+Claude Code also loads these skills on its own when you ask for that kind of
+work ("take the helm", "work as a trap", "stow", "step down").
 
 ## The session id
 
@@ -101,7 +100,7 @@ Without the plugin, `lobstah man init` merges the Stop hook into
 
 ## CLI vs desktop app
 
-The plugin, hooks, skills, and slash commands are the same whether you run
+The plugin, hooks, and skills are the same whether you run
 `claude` in a terminal or use the Code tab of the Claude desktop app. What
 differs:
 

package/docs/harness/codex.md

@@ -59,8 +59,13 @@ mentions below. Plain-language requests load the same skills:
 /skills
 $lobstah:man take the helm for this repo
 $lobstah:trap work as a trap in this linked worktree
+$lobstah:stow sign this trap off
+$lobstah:relieve step down from the helm
 ```
 
+The plugin has these four skills and no commands; the Claude Code plugin has
+the same four.
+
 The skill instructions lead to `lobstah man helm` and `lobstah soak`,
 respectively. This verification stopped before running either sign-on
 command. The desktop task's supplied skill catalog names

package/docs/man.md

@@ -229,7 +229,7 @@ of the stack are recorded too:
 
 The report prints `prs` with every PR it recorded. `lobstah catch` and
 `lobstah status <id>` list each PR (`prs`), `man tend` lists each with its
-state in the story's `pr` column, and the glass links each by number. Each
+state in the story's `pr` column, and the glass lists each in stack order with its state. Each
 PR has its own record, so `pr:*` attention and the merged/closed notice are
 per PR. `[limits].releaseOnMerge` keeps the worktree while another PR of
 the dispatch is open. What you get depends on what runs:
@@ -344,9 +344,11 @@ and the glass show the repair's PR, chore lane, worker, and trap wait.
   PR's watch. `lobstah watch hold <key> [--for <id>]`
   holds one PR's watch; with `--for`, the hold ends when that dispatch
   ends. `lobstah watch release <key>` ends any hold.
+- A repair of a PR below this one in the same stack is queued or running
+  (`heldBy: stack`): that repair also updates this PR.
 
 A waiting repair is recorded on the PR record as `repair.status: waiting`,
-with `heldBy` (`wt:<trap>`, `dispatch:<id8>`, `helm`, `hold`, `settle`,
+with `heldBy` (`wt:<trap>`, `dispatch:<id8>`, `helm`, `hold`, `settle`, `stack`,
 `checks`, `human-gate`, or `repaired`) and `reason`. `repaired` means each
 failing check already had its round at this head; a new commit ends it.
 Unlike the other waits, `repaired` also raises `pr:checks` attention with
@@ -378,7 +380,25 @@ base is another PR's branch) rebases onto that base and pushes with
 `--force-with-lease`; on a rejection it rebases onto the moved head again
 and pushes with a lease on the head just fetched. A checks or review
 repair follows the rebase rule on a rejection. Each retries at most three
-times. A push hook that fails with a real test or
+times.
+
+**A repair updates the PRs stacked on it.** When open PRs are stacked on
+the repaired PR (lobstah's PR records show PRs whose base is its head
+branch, and theirs), the brief names each one, in order, and the push rule
+allows their branches. After pushing the repaired PR, the worker brings
+each one up to date with its base:
+
+- After a merge-based repair (a standalone PR, or any checks or review
+  repair), it merges the updated base into each one and pushes normally,
+  never with force.
+- After a rebase-based repair (a conflict repair of a stacked PR), it
+  rebases each one onto its updated base and pushes with
+  `--force-with-lease`, with the same retries.
+
+An update that conflicts is aborted and left as it was, with the PRs above
+it. lobstah repairs that PR as its own conflict repair, under the same
+rules (`repairSettleSecs`, the attempt limit, and the no-progress breaker).
+The list stops below a PR that a live worker holds. A push hook that fails with a real test or
 type error is not retried: the worker fixes the error and pushes again.
 For code already on main, the repair keeps main's version and only this
 PR's own changes. It does not change behavior. If a conflict resolution
@@ -675,9 +695,21 @@ watcher that is still starting, so arming and ending the turn at once is safe.
 wait for attention itself. Without a Stop hook, use the
 [foreground loop below](#without-a-plugin).
 
-The hook is a CLI command — `lobstah man haul` (the lobstah man hauls the
-trapline; every orchestrator-facing command lives under `lobstah man`).
-Install it from the project you'll run the lobstah man in:
+Each plugin hook runs one CLI command, `lobstah hook <event>`:
+
+| Hook | Command | What it does |
+| ---- | ------- | ------------ |
+| SessionStart | `lobstah hook session-start` | Announces the session id and a one-line fleet state; for the helm, its charter; for a trap, its worktree. A session with neither role gets its id and the sign-on commands. |
+| Stop | `lobstah hook stop` | Parks the helm or a trap: blocks with standing attention, asks for a watcher in arm mode, or waits in the hook with `--park` (`--timeout <secs>`). Inert for a session with neither role. |
+| PostToolUse | `lobstah hook post-tool-use` | A trap's beat: liveness, activity, pushes, and its PR. Inert for a session with neither role. |
+| SessionEnd | `lobstah hook session-end` | Signs a trap off and keeps its worktree. Inert for a session with neither role. |
+
+Each command detects the session's role: the helm (a helm registration, or a
+session opted in with `LOBSTAH_MAN=1` or `.lobstah-man`), a trap (a soaking
+registration), or neither. The older commands stay as aliases and do the same:
+`lobstah man brief`, `lobstah man haul`, `lobstah soak beat`, and
+`lobstah stow --quiet`. Install the Stop hook from the project you'll run the
+lobstah man in:
 
 ```bash
 # Easiest: the plugin ships the hooks + the man and trap skills, no settings
@@ -694,10 +726,26 @@ Idempotent, and it only appends to `hooks.Stop` — existing hooks and settings
 are preserved verbatim. What it writes:
 
 ```json
-{ "hooks": { "Stop": [{ "hooks": [{ "type": "command", "command": "lobstah man haul", "timeout": 14400 }] }] } }
+{ "hooks": { "Stop": [{ "hooks": [{ "type": "command", "command": "lobstah hook stop", "timeout": 14400 }] }] } }
 ```
 
-`haul` applies to a signed-on helm or trap, or a session opted in with
+**A trap's park renews.** When a trap parks in the Stop hook (park mode:
+`--park`, `[helm].park = "block"`, or the default for a Codex trap) and the
+park reaches its `--timeout` with nothing to act on, the hook blocks the stop
+with one instruction: park again, by ending the turn. The next Stop hook
+parks again. Both harnesses take this as a Stop hook's
+`{"decision":"block","reason":…}` output. The hook stops renewing:
+
+- when the trap is stowed or its registration is gone (silently);
+- when the daemon is unreachable (no heartbeat in the last 90 s);
+- after 3 parks in a row that each returned within 5 seconds.
+
+In the last two cases it prints a `systemMessage` that says why and how to
+park again. A trap in arm mode (the Claude Code default) needs no renewal:
+its background `soak --wait` is re-armed at each turn end.
+
+A Stop hook that runs `lobstah man haul` already counts as installed.
+The Stop hook applies to a signed-on helm or trap, or a session opted in with
 `LOBSTAH_MAN=1` or `.lobstah-man`. Queued dispatches count as work in flight.
 
 **Delivery guarantee.** Attention wakes are at-least-once with backoff. An
@@ -851,8 +899,9 @@ lobstah soak --wait             # hookless sessions: listen in the foreground
 lobstah soak --link <url>       # store this session's link for the glass's ↗ open button
 lobstah focus <trap>           # focus a live trap from the CLI
 lobstah stow                    # sign off; an open catch requeues, unread
-                                # messages bounce back to the helm; removes
-                                # the worktree when soak created it
+                                # messages wait [soak].signOffGraceSecs for a
+                                # re-soak, then bounce back to the helm;
+                                # removes the worktree when soak created it
 lobstah stow --keep             # sign off and keep the worktree
 lobstah soak --name amber-gull  # choose or change this trap's two-word name
 ```
@@ -914,6 +963,29 @@ upstream: on some remote branch);
 otherwise it prints `branchKept: <branch> (<reason>)`. A deleted branch
 prints as `branchDeleted:`. `stow --wt <id>` follows the same rules. The
 SessionEnd hook (`lobstah stow --quiet`) signs off and keeps the worktree.
+
+**Only the trap's own session signs it off from a hook.** `lobstah hook
+session-end` (and `stow --quiet`) stows a trap only when the ending session
+is the one registered as the trap. Another session in the same worktree (a
+second window, a child session) ending leaves the trap signed on. The
+PostToolUse and SessionStart hooks never beat or adopt a trap for a session
+that is not the trap's.
+
+**A sign-off holds the address for a while.** A session that restarts or
+compacts can end (SessionEnd stows it) and sign on again a minute later.
+SessionEnd cannot tell that from an exit: Claude Code's `reason` is `clear`,
+`resume`, `logout`, `prompt_input_exit`, or `other`, and Codex's is always
+`other`. So for `[soak].signOffGraceSecs` (default 600) after any sign-off:
+
+- unread messages stay in the trap's inbox, and `send wt:<trap>` queues
+  more with a warning instead of refusing;
+- work addressed to the trap raises no `bait-orphaned` notice;
+- a re-soak of the same worktree releases the hold, and the messages deliver
+  at its next park.
+
+After the grace, the daemon bounces the held messages to the helm
+(`message-bounced`), and `bait-orphaned` is raised as before. A stow that
+removes the worktree, or a grace of `0`, bounces at once.
 Releasing a claim whose last report is `done` or `failed` moves it to `done/`;
 only an unfinished catch requeues (a cancelled catch finalizes as failed).
 
@@ -1011,7 +1083,7 @@ The output holds a one-time ticket and the command that starts the session in
 the repo's primary checkout:
 
 ```bash
-cd <repo> && CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1 claude "/lobstah:soak --ticket <ticket>"
+cd <repo> && CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1 claude "/lobstah:trap soak --ticket <ticket>"
 cd <repo> && codex '$lobstah:trap soak --ticket <ticket>'
 ```
 
@@ -1065,6 +1137,28 @@ redeemed or withdrawn. The glass sends it only to a page on this machine's
 own glass address, only on the starting card, and no notice or log carries
 it.
 
+### The sign-on title
+
+Sign-on asks the session to apply a title: `lobstah soak` prints
+`step: Apply this title: <title>` (the trap's name). The session applies it
+with its harness's title tool when there is one (`set_session_title` in the
+Claude desktop Code tab, `set_thread_title` in the Codex app) and skips that
+part when it has none. Then it runs `lobstah soak title-set` (`--session
+<id>` from outside the worktree), which prints `signOn: complete`.
+`lobstah trap title-set` does the same, but Claude Code's worktree isolation
+refuses any command line with the word `trap` in it (it reads it as the
+shell builtin), so a trap runs `soak title-set`.
+
+Until then, sign-on is not complete. The SessionStart hook adds the
+reminder to the session brief, and the Stop hook blocks the stop once per
+turn with it: `lobstah: sign-on is not complete. Apply this title: <title>
+(skip this if you have no tool that sets the session title). Then run
+\`lobstah soak title-set\`.` A turn the Stop hook already continued
+(`stop_hook_active`) is not reminded again. After three reminders (the
+third says it is the last), both hooks stop asking; `soak title-set` still
+completes sign-on later. A session that signs on again keeps a title it
+confirmed.
+
 ### The terminal tab name
 
 At sign-on, soak names the session's terminal tab after the trap. It finds the

package/docs/vocabulary.md

@@ -298,6 +298,41 @@ session id's UUID version (v7 codex, v4 claude), else the descriptor.
 | `fail` | Broken configuration or missing requirement — fix before relying on lobstah. |
 | `skip` | The check does not apply on this host (e.g. no harness plugin installed). Never fails the run. |
 
+### Hook readiness
+
+Parks and wakes run through the plugin's hooks, so doctor checks them. It
+prints one `hooks claude` and one `hooks codex` row for each harness whose
+lobstah plugin is installed (`skip` otherwise). The row starts with the
+readiness of each role: the helm needs `Stop` and `SessionStart`; a trap
+needs all four (`helm ready, trap not ready (needs PostToolUse)`). Then, for
+each hook (`Stop`, `SessionStart`, `PostToolUse`, `SessionEnd`), it says:
+
+- **installed**: the plugin's `hooks/hooks.json` declares it (`missing`
+  otherwise), and whether the harness has it turned off (`installed but
+  disabled`);
+- **trusted**: Codex runs a plugin hook only after the user trusts it in
+  `/hooks`, and records trust in `config.toml` as
+  `[hooks.state."lobstah@lobstah:hooks/hooks.json:<event>:<group>:<handler>"]`
+  with a `trusted_hash`, a hash of the hook's definition. The row says
+  `trusted` when that hash matches the hook as the plugin declares it now,
+  `changed since trusted` when the hook changed after it was trusted (a
+  plugin update; Codex asks again), and `untrusted` without an entry. Claude
+  Code has no per-hook trust: `trust n/a`;
+- **last run**: when lobstah last saw the hook run (`never run` when it has
+  not). Each hook run stamps `~/.lobstah/hook-runs.json` (`<harness>:<event>`
+  → time; a hook that runs on every tool call stamps at most every 30 s).
+
+A hook that is missing, untrusted, or off makes the row `fail`, and the row
+ends with the step to take, for example `In Codex, open /hooks and trust
+lobstah's Stop and SessionStart hooks.` Doctor reads the harness config and
+never writes it.
+
+A `listeners` row follows: for each signed-on helm, whether it listens (a
+live `man wait`, or a park in the Stop hook), and for each trap whether it is
+`parked`, `working a catch`, or `not listening`. A helm or trap that is not
+listening makes the row `warn`: no automatic wake reaches it until it parks
+again.
+
 ## Watch contract
 
 A **watch** is a standing outbound poll on something external (a ume review
@@ -354,7 +389,7 @@ evidence).
 | `draft` | Draft flipped (`value`). Evidence only. |
 | `merged` / `closed` | Terminal; the check sets `done`, and the watch retires once delivered. Emitted only on an open → terminal change, never on the first observation. |
 | evidence `pr` | `{ url, number, state, draft, reviewDecision, mergeStateStatus, headSha, checks: { total, passed, failed, pending, unknown? }, review: { unresolvedThreads, changesRequested, lastReviewAt }, observedAt }`. Check counts use only the latest run per check name and app/workflow. `CANCELLED` and `STALE` latest runs are unknown, not failed. The PR record also stores repair status, attempts, and reason. `prBadge` shows `repairing: conflict (attempt 1 of 2)` while a repair is in flight, and ends in `repair waits: <heldBy>` while a repair waits; tend, `catch`, and the glass share the badge. |
-| waiting repair | `repair.status: waiting` on a PR record: a repair is due but is not queued. `heldBy` names the holder: `wt:<trap>` or `dispatch:<id8>` (a live worker holds the PR's head branch or the head branch of a PR below it in the stack), `helm` (the helm cancelled a repair of this PR), `hold` or `dispatch:<id8>` (`watch hold`), `settle` (the head, base head, or failing checks changed less than `[watch].repairSettleSecs` ago, or, for a conflict repair, the PR was approved less than that ago; `until` says when), or `checks` (the latest run of a failing check is in progress or passed). `reason` says what holds it. A wait is not an attempt and raises no attention item. |
+| waiting repair | `repair.status: waiting` on a PR record: a repair is due but is not queued. `heldBy` names the holder: `wt:<trap>` or `dispatch:<id8>` (a live worker holds the PR's head branch or the head branch of a PR below it in the stack), `helm` (the helm cancelled a repair of this PR), `stack` (a repair of a PR below it in the stack is queued or running, and updates this PR too), `hold` or `dispatch:<id8>` (`watch hold`), `settle` (the head, base head, or failing checks changed less than `[watch].repairSettleSecs` ago, or, for a conflict repair, the PR was approved less than that ago; `until` says when), or `checks` (the latest run of a failing check is in progress or passed). `reason` says what holds it. A wait is not an attempt and raises no attention item. |
 | repair chore | A daemon repair or rebase runs in the `chore` lane under `[limits].choreConcurrent`. A repair chore for a trap-built PR waits for its live owning trap up to `[watch].repairTrapWaitSecs` (default 600), then runs headless in its own PR-branch checkout. A headless-built PR's repair runs headless in its origin worktree when safe. No headless chore uses a trap's worktree. This bounded fallback applies only to system repair chores; a person's addressed work is sticky and never falls back. Tend, daemon status, doctor, and the glass show the PR, lane, worker, and trap wait. |
 | live worker | An active headless dispatch, or a trap with an open catch. It holds a branch that its worktree has checked out, that its current branch tracks, or that it pushed during its current dispatch (evidence `pushes`). It holds a PR that its evidence names or that its chain owns. |
 | evidence `pushes` | `[{ branch, at }]`: the branches a dispatch pushed, as lobstah saw them. The runner records its own pushes; the runner records a headless worker's `git push` from the harness event stream (branch names only); `soak beat` records a trap's `git push`. |
@@ -431,11 +466,14 @@ worktree is refused (the session lock); a stale one is adopted.
 | Word | Meaning |
 | ---- | ------- |
 | `soak` | Sign the worktree's trap on and take matching work. From a primary checkout, or with `--repo <key>` from outside any configured repo, it first creates a linked worktree like a dispatch does (fetch trunk, new branch from `origin/<trunk>`, `setup` commands), prints `worktree:`, `created: true`, `branch:`, and, when the session is elsewhere, `instruction: cd <path> ...`; the session works in that directory. If creation fails, nothing is signed on and the partial worktree and branch are removed. `--repo` in a linked worktree must match its repo. A session that already mans a trap re-uses it (resolved from the session id) and never gets a second worktree. `--session` is needed only on first sign-on. `--one` stows after the first catch. `--wait` registers a watcher and waits for work; a quiet timeout exits 3. Workers never run `man` verbs. |
-| `stow` | Sign the trap off (in the worktree, or elsewhere by session id: `--session <id>` or `$CLAUDE_CODE_SESSION_ID`); an unfinished catch requeues, done/failed finalizes in `done/`, and a cancelled catch finalizes as failed. Unread messages bounce to the helm. A trap always stows itself freely; stowing someone else's (`--wt`) is steering — the claimed helm's alone. Stow closes the seat, never the session: an opted-in session can only be asked to stop, and a still-looping worker re-enlists visibly (`trap-signed-on`). By default stow removes the worktree when soak created it (`createdWorktree: true`) and prints `worktree: removed`, `path:`, and `returnTo:`; `--keep` leaves it. It keeps the worktree (`worktree: kept`, `reason:`) when soak did not create it, or when it holds uncommitted changes, untracked files that are not ignored, commits absent from its upstream, or no upstream. `--force` explicitly allows discarding unsaved checkout files; `--keep` still keeps it. The branch is deleted (`branchDeleted:`) only when all its commits are on its upstream (with no upstream: on some remote branch); otherwise `branchKept: <branch> (<reason>)`. `--wt` follows the same rules. The SessionEnd hook (`stow --quiet`) signs off and keeps the worktree. |
+| `soak title-set` (alias `trap title-set`) | Confirm this session applied the title sign-on printed (`step: Apply this title: <title>`). The registration records `titleSet` and `titleSetAt` and drops `titlePending`; sign-on is complete. Until then, SessionStart and Stop remind the session once per turn, at most three times. A trap runs `soak title-set`: Claude Code's worktree isolation refuses a command line containing `trap`. |
+| `stow` | Sign the trap off (in the worktree, or elsewhere by session id: `--session <id>` or `$CLAUDE_CODE_SESSION_ID`); an unfinished catch requeues, done/failed finalizes in `done/`, and a cancelled catch finalizes as failed. Unread messages are held for `[soak].signOffGraceSecs` (default 600): they deliver if the same worktree re-soaks in time, else the daemon bounces them to the helm (at once when stow removed the worktree or the grace is `0`). A trap always stows itself freely; stowing someone else's (`--wt`) is steering — the claimed helm's alone. Stow closes the seat, never the session: an opted-in session can only be asked to stop, and a still-looping worker re-enlists visibly (`trap-signed-on`). By default stow removes the worktree when soak created it (`createdWorktree: true`) and prints `worktree: removed`, `path:`, and `returnTo:`; `--keep` leaves it. It keeps the worktree (`worktree: kept`, `reason:`) when soak did not create it, or when it holds uncommitted changes, untracked files that are not ignored, commits absent from its upstream, or no upstream. `--force` explicitly allows discarding unsaved checkout files; `--keep` still keeps it. The branch is deleted (`branchDeleted:`) only when all its commits are on its upstream (with no upstream: on some remote branch); otherwise `branchKept: <branch> (<reason>)`. `--wt` follows the same rules. The SessionEnd hook (`stow --quiet`) signs off only when the ending session is the trap's registered session (another session in the worktree ending is a no-op) and keeps the worktree; SessionEnd cannot tell a restart or compaction from an exit (Claude Code's `reason` is `clear`, `resume`, `logout`, `prompt_input_exit`, or `other`; Codex's is always `other`), so the grace covers a session that signs on again. |
+| sign-off grace | For `[soak].signOffGraceSecs` after a trap signs off (`~/.lobstah/signed-off/<trap>.json`), its address is held: `send wt:<trap>` queues and warns instead of refusing, held messages wait, and work addressed to it raises no `bait-orphaned` notice. A re-soak of the same worktree releases the hold; after the grace, the daemon bounces the held messages (`message-bounced`). |
 | address | `--for wt:<trap>` targets one trap; `session:<id>` is an alias resolved to the trap at dispatch time. **Sticky:** addressed work is never the daemon's — it waits for its trap; an orphan (trap gone) surfaces as a `bait-orphaned` notice for the helm to re-address, release, or cancel. Delivery stamps a receipt (`deliveredTo`/`deliveredAt`) into evidence. Unaddressed work defers to a parked matching trap for `[soak].deferSecs`, then the daemon spawns headless. |
 | message | `send wt:<trap> "<text>"` — a conversational continuation, not work: no branch, no catch, no report obligation. Delivered before bait at the trap's next park, stamped with its sender (`helm` / `session:<id>` / `terminal`); undeliverable messages bounce to the helm as notices. |
 | catch | The active dispatch a trap claimed (`claim.json`, `by: wt:<id>`). One catch per trap; one active item per worktree. The daemon never spawns or restarts it — the session's reports are its liveness. |
-| beat | `lobstah soak beat`, run by the plugin's post-tool hook after every tool call. It resolves the trap from the working directory, else from the session id (files only: no git, no network), refreshes the trap's beat (`soaking/<trap>.beat`, separate from the registration), and writes the claimed catch's [activity](#activity). Throttled to one per 30 seconds per trap. Inert in a session that is not soaking, or with `[soak].beat = false`. Always exits 0; errors go to `logs/beat.log`. |
+| hook command | `lobstah hook session-start\|stop\|post-tool-use\|session-end`: the command each plugin hook runs. Each detects the session's role (helm, trap, or neither) and runs what `man brief`, `man haul`, `soak beat`, and `stow --quiet` run; those stay as aliases. Stop, PostToolUse, and SessionEnd are inert for a session with neither role; SessionStart announces the session id to every session. |
+| beat | `lobstah soak beat` (`lobstah hook post-tool-use`), run by the plugin's post-tool hook after every tool call. It resolves the trap from the working directory, else from the session id (files only: no git, no network), refreshes the trap's beat (`soaking/<trap>.beat`, separate from the registration), and writes the claimed catch's [activity](#activity). Throttled to one per 30 seconds per trap. Inert in a session that is not soaking, or with `[soak].beat = false`. Always exits 0; errors go to `logs/beat.log`. |
 | ghost trap | A registration whose heartbeat **and** beat lapsed past `[soak].ttlSecs` **after having parked at least once**. The sweep removes the registration, requeues only unfinished catches, finalizes done/failed in `done/`, and posts a `trap-ghosted` notice. It removes a soak-created checkout only when clean and pushed to its upstream; dirty, unpushed, no-upstream, or unreadable checkouts stay, protected from later culls too. The notice includes path, branch, modified-file and unpushed-commit counts, or `unknown` when unavailable. A kept anchor preserves the address on re-soaking. A fresh report or beat keeps a working session out of the sweep; a fresh beat also holds the session lock. A catch whose last report is `paused` keeps its trap until the pause expires ([Waiting on](#waiting-on)). A daemon tick gap longer than the soak TTL starts one full TTL of resume grace before any ghost sweep. |
 | defective enlistment | A stale registration that **never parked** — signed on but never listened (usually no Stop hook). Not swept: the helm gets a `trap-defective` notice with the remedy (`soak --wait`), and the registration stays so the address keeps protecting its work. |
 | reserved trap | A trap `lobstah trap reserve` created before any session signs on as it: a name, a `wt:` id, and a one-time ticket, shown as `starting`. Work addressed to it waits. A session redeems the ticket with `soak --ticket` (or `LOBSTAH_TRAP_TICKET`) and signs on as that trap. Unredeemed past its deadline, it fails with a `trap-start-failed` notice and its work stays queued. `stow --wt <name>` withdraws it. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobstah",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Harness-agnostic, token-efficient supervision framework for coding agents",
   "license": "MIT",
   "author": "aequitas labs LLC",