@clipboard-health/groundcrew 3.1.1 → 3.1.3

package/README.md

@@ -42,7 +42,7 @@ Eligibility
 - **Linear-native.** Polls a project, respects `agent-*` labels, honors blockers.
 - **One worktree per ticket.** Agents work in parallel without stepping on each other.
 - **Local-first sandboxing.** Safehouse on macOS, Docker Sandboxes on Linux, or an explicit `none` escape hatch.
-- **Multi-agent.** Ships with `claude` and `codex`; bring your own CLI by dropping a definition into `config.ts`.
+- **Multi-agent.** Ships with `claude` and `codex`; bring your own CLI by dropping a definition into `crew.config.ts`.
 
 ## Install
 
@@ -64,11 +64,13 @@ Installs the `crew` binary. `@clipboard-health/clearance` is pulled in transitiv
 
    ```bash
    mkdir -p "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew"
-   cp "$(npm root -g)/@clipboard-health/groundcrew/configExample.ts" \
-      "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/config.ts"
-   $EDITOR "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/config.ts"
+   cp "$(npm root -g)/@clipboard-health/groundcrew/crew.config.example.ts" \
+      "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/crew.config.ts"
+   $EDITOR "${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/crew.config.ts"
    ```
 
+   Or drop `crew.config.ts` at the root of any repo you run `crew` from — `crew` discovers it via cosmiconfig project-walk. Any of `crew.config.{ts,mjs,js,json}`, `.crewrc{,.json,.ts}`, `.config/crew.config.{ts,json}`, or `.config/crewrc{,.json}` work.
+
    Set `linear.projectSlug` (paste the trailing slug of your Linear project URL, e.g. `ai-strategy-5152195762f3`), `workspace.projectDir`, and `workspace.knownRepositories`. Defaults cover everything else.
 
    Then clone each repo before the first `crew run` — groundcrew creates per-ticket worktrees from these clones, it does not auto-clone:
@@ -134,7 +136,7 @@ Net effect: by the time the agent process exists, the values are gone from the e
 | `sdx`       | Linux / WSL | [Docker Sandboxes](https://docs.docker.com/sandboxes/) (`sbx`) — required when the agent needs `docker`. |
 | `none`      | —           | Unsandboxed escape hatch. Never picked implicitly; doctor warns when configured.                         |
 
-For `sdx`: each model that runs under it needs a `sandbox: { agent: "<sbx-agent>" }` block in `config.ts`. Groundcrew names sandboxes `groundcrew-<agent>` (e.g. `groundcrew-claude`) and reuses one sandbox per agent across repos and tickets. First-time agent auth happens inside the sandbox the first time it launches. To bootstrap manually instead, run `sbx create --name groundcrew-<agent> <agent> <projectDir>` once.
+For `sdx`: each model that runs under it needs a `sandbox: { agent: "<sbx-agent>" }` block in `crew.config.ts`. Groundcrew names sandboxes `groundcrew-<agent>` (e.g. `groundcrew-claude`) and reuses one sandbox per agent across repos and tickets. First-time agent auth happens inside the sandbox the first time it launches. To bootstrap manually instead, run `sbx create --name groundcrew-<agent> <agent> <projectDir>` once.
 
 <details>
 <summary>Safehouse clearance allowlist</summary>
@@ -167,7 +169,7 @@ Three keys are required; everything else has a default.
 | `workspace.projectDir`        | Parent dir for cloned repos and sibling ticket worktrees.                  |
 | `workspace.knownRepositories` | Repos searched for in ticket descriptions to infer where work belongs.     |
 
-`crew` resolves config as: `GROUNDCREW_CONFIG` if set → `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/config.ts` if it exists → a `config.ts` next to `crew`'s own source (only useful from a local checkout). The branch prefix (`<prefix>-<TICKET>`) is derived from `os.userInfo().username` — not configurable.
+`crew` resolves config as: `GROUNDCREW_CONFIG` if set → project-walk from cwd (cosmiconfig: `crew.config.{ts,mjs,js,json}`, `.crewrc{,.json,.ts}`, `.config/crew.config.{ts,json}`, `.config/crewrc{,.json}`) → `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/crew.config.ts` (also accepts legacy `config.ts` for one release). The branch prefix (`<prefix>-<TICKET>`) is derived from `os.userInfo().username` — not configurable.
 
 Agent selection uses Linear labels: `agent-claude`, `agent-codex`, `agent-<name>`. `crew run` without `--ticket` only fetches tickets carrying an `agent-*` label — the GraphQL query filters server-side, so unlabeled tickets are never returned by Linear and do not appear on the board. Use `crew run --ticket <TICKET>` to provision an unlabeled ticket on demand (falls back to `models.default`). `agent-any` routes to the model with the most available session capacity. Todo tickets blocked by non-terminal blockers are skipped until their blockers reach a terminal status.
 
@@ -180,7 +182,7 @@ For a personal workflow, keep the prompt next to your local config and load it w
 ```ts
 import { readFileSync } from "node:fs";
 
-export const config = {
+export default {
   // ...
   prompts: {
     initial: readFileSync(new URL("./initial-prompt.md", import.meta.url), "utf8"),
@@ -195,7 +197,7 @@ This keeps package defaults portable while letting your private config reference
 
 | Key                                     | Default             | What it does                                                                                                                                                                                                                                                                                                                                                            |
 | --------------------------------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `linear.projectSlug`                    | **required**        | Linear project URL slug (e.g. `ai-strategy-5152195762f3`). The trailing 12-char hex `slugId` is what's matched against Linear's API; the leading name keeps `config.ts` self-documenting and the lookup survives project renames.                                                                                                                                       |
+| `linear.projectSlug`                    | **required**        | Linear project URL slug (e.g. `ai-strategy-5152195762f3`). The trailing 12-char hex `slugId` is what's matched against Linear's API; the leading name keeps `crew.config.ts` self-documenting and the lookup survives project renames.                                                                                                                                  |
 | `linear.statuses.todo`                  | `"Todo"`            | Status name picked up for new work.                                                                                                                                                                                                                                                                                                                                     |
 | `linear.statuses.inProgress`            | `"In Progress"`     | Status set after a workspace is provisioned; counts toward `maximumInProgress`.                                                                                                                                                                                                                                                                                         |
 | `linear.statuses.done`                  | `"Done"`            | Status that triggers worktree cleanup.                                                                                                                                                                                                                                                                                                                                  |
@@ -214,7 +216,7 @@ This keeps package defaults portable while letting your private config reference
 | `models.definitions.<name>.usage`       | optional            | If set, codexbar usage is fetched for this model and gated by `sessionLimitPercentage`. Falls back to default when unset, with gating enabled for known models. When `usage.codexbar.source` is omitted, groundcrew uses `oauth` for Codex/Claude on macOS, `auto` for other macOS providers, and `cli` elsewhere. Set to `{ disabled: true }` to disable usage gating. |
 | `models.definitions.<name>.sandbox`     | optional            | Docker Sandboxes binding for the model. Required at launch when `local.runner` resolves to `sdx`. Fields: `agent` (required sbx agent name), `template`, `kits`, `setupCommand` (override for the inside-sandbox setup script).                                                                                                                                         |
 | `models.definitions.<name>.disabled`    | optional            | When set to exactly `true`, drops the named shipped default (`claude` or `codex`). Doctor skips probing it; `agent-<name>` labels fall back to `models.default` with a warning.                                                                                                                                                                                         |
-| `prompts.initial`                       | unattended template | First message sent to the agent. Placeholders: `{{ticket}}`, `{{worktree}}`, `{{title}}`, `{{description}}`. Override this from `config.ts` for team-specific statuses, tools, plugins, or review loops.                                                                                                                                                                |
+| `prompts.initial`                       | unattended template | First message sent to the agent. Placeholders: `{{ticket}}`, `{{worktree}}`, `{{title}}`, `{{description}}`. Override this from `crew.config.ts` for team-specific statuses, tools, plugins, or review loops.                                                                                                                                                           |
 | `workspaceKind`                         | `"auto"`            | Terminal session manager. `"auto"` picks `cmux` when on PATH, else `tmux`. Set to `"cmux"` or `"tmux"` to fail loudly when the chosen backend is missing.                                                                                                                                                                                                               |
 | `local.runner`                          | `"auto"`            | Local isolation backend. `"auto"` → `safehouse` on macOS, `sdx` on Linux/WSL. Explicit: `"safehouse"`, `"sdx"`, `"none"`. `"none"` is never picked implicitly.                                                                                                                                                                                                          |
 | `logging.file`                          | XDG state path      | Append-mode log file. `log()` / `logEvent()` tee here in addition to stdout. Defaults to `${XDG_STATE_HOME:-$HOME/.local/state}/groundcrew/groundcrew.log`.                                                                                                                                                                                                             |
@@ -227,8 +229,8 @@ This keeps package defaults portable while letting your private config reference
 Groundcrew ships `claude` and `codex` as default model definitions, additively merged into every resolved config. To stop probing one:
 
 ```ts
-// config.ts
-export const config = {
+// crew.config.ts
+export default {
   // …
   models: {
     default: "claude",
@@ -314,14 +316,16 @@ crew run                                                 # one-shot dispatch
 crew run --watch                                         # poll forever
 crew run --ticket <TICKET>                               # provision one ticket and exit
 crew setup repos [--dry-run] [<repo>...]
+crew interrupt <TICKET> [--reason <text>]                # stop the live workspace, keep the worktree
+crew resume <TICKET>                                     # reopen an existing ticket worktree
 crew cleanup <TICKET>                                    # tear down every worktree carrying this ticket
 ```
 
-`crew doctor --ticket <TICKET>` covers the full per-ticket lifecycle: pre-dispatch eligibility (Todo status, `agent-*` label, model resolution, repository mention, local clone, blockers, model session usage, in-progress capacity) **and** post-dispatch local-state recovery (host worktree, workspace pane, local branch, remote branch, open PR). Verdict precedence runs from post-dispatch outcomes down: `pr-open` > `pr-merged` > `in-flight` > `recoverable` > `unresolvable` > `ineligible` > `would-dispatch` > `lost`. Exits 0 on `would-dispatch`, `pr-open`, or `pr-merged`; any other verdict exits 1. `--watch` and `--ticket` are mutually exclusive. To inspect codexbar session windows directly, run `codexbar usage`.
+`crew doctor --ticket <TICKET>` covers the full per-ticket lifecycle: pre-dispatch eligibility (Todo status, `agent-*` label, model resolution, repository mention, local clone, blockers, model session usage, in-progress capacity) **and** post-dispatch local-state recovery (recorded run state, host worktree, workspace pane, local branch, remote branch, open PR). Verdict precedence starts with PR outcomes (`pr-open` > `pr-merged`). Recorded failed launches report before ordinary local recovery, interrupted runs report concrete recoverable git work first when it exists and otherwise report `interrupted`, and ordinary post-dispatch cases report `in-flight` before `recoverable`. If none of those apply, doctor falls through to `unresolvable` > `ineligible` > `would-dispatch` > `lost`. Exits 0 on `would-dispatch`, `pr-open`, or `pr-merged`; any other verdict exits 1. `--watch` and `--ticket` are mutually exclusive. To inspect codexbar session windows directly, run `codexbar usage`.
 
 ### `crew doctor --ticket <ticket>`
 
-Diagnose where a ticket is in its lifecycle and what to do next. Runs the same resolution and eligibility chain as the dispatcher, plus probes the host worktree, workspace pane, local branch, remote branch, and PR; prints a single verdict with a copy-pasteable recovery step when one applies.
+Diagnose where a ticket is in its lifecycle and what to do next. Runs the same resolution and eligibility chain as the dispatcher, plus probes recorded run state, host worktree, workspace pane, local branch, remote branch, and PR; prints a single verdict with a copy-pasteable recovery step when one applies.
 
 Flags:
 
@@ -342,6 +346,13 @@ Resolution
 Eligibility
   (skipped — post-dispatch — pre-dispatch checks are irrelevant)
 
+Run state
+  [ok] Local run state (running)
+  [ok] Recorded model (claude)
+  [ok] Recorded worktree (/Users/paul/dev/groundcrew-workspaces/herds-social/herds-hrd-442)
+  [ok] Recorded branch (paul-hrd-442)
+  [ok] Resume count (0)
+
 Worktree
   [ok] Host worktree exists (/Users/paul/dev/groundcrew-workspaces/herds-social/herds-hrd-442)
   [--] Working tree clean (0 modified, 1 untracked)
@@ -372,11 +383,31 @@ The verdict on the last line maps to a recovery action:
 | `pr-merged`      | Done.                                                                                         |
 | `in-flight`      | The ticket is still being worked on; the verdict line names the workspace pane to attach to.  |
 | `recoverable`    | Run the printed `nextStep` exactly.                                                           |
+| `interrupted`    | Resume the preserved worktree with `crew resume <ticket>` or inspect it by hand.              |
+| `failed-launch`  | Fix the launch failure, then run `crew resume <ticket>` or `crew cleanup <ticket>`.           |
 | `would-dispatch` | Pre-dispatch checks pass; the orchestrator will pick the ticket up on its next tick.          |
 | `ineligible`     | A resolution or eligibility check failed; the reason after the colon names the failing check. |
 | `unresolvable`   | The Linear ticket couldn't be fetched; the reason after the colon names the error.            |
 | `lost`           | No trace exists. Re-dispatch via `crew run --ticket <ticket>`.                                |
 
+### `crew interrupt <ticket>`
+
+Stop a live workspace pane while preserving the ticket worktree and branch. This is the manual pause button for cases where you need terminal capacity back, want to stop an agent that is going in the wrong direction, or need to inspect the diff before letting another agent continue.
+
+```bash
+crew interrupt HRD-442 --reason "wrong implementation direction"
+crew doctor --ticket HRD-442
+crew resume HRD-442
+```
+
+The command closes the cmux/tmux workspace when it exists, records local run state under the groundcrew state directory, and never tears down the worktree. If the workspace was already gone but the worktree is still present, interrupt records that fact so doctor can point at the preserved branch instead of reporting a mystery ticket.
+
+### `crew resume <ticket>`
+
+Reopen an existing ticket worktree with a continuation prompt. Resume never creates a new worktree; if none exists, it fails and leaves re-dispatch to `crew run --ticket <ticket>`.
+
+The resume prompt tells the agent to inspect current git status and diff before editing, includes the previous interrupt reason when recorded, and reuses the recorded model, repository, branch, runner, sandbox, and workspace backend. When no run-state file exists but a worktree does, resume falls back to Linear resolution for the model and ticket context.
+
 ## Troubleshooting
 
 First stop for "labeled but not on the board": `crew doctor --ticket <ticket>` lists every check the dispatcher runs and flags the failing one.
@@ -491,7 +522,7 @@ node --run crew -- doctor
 node --run crew:op -- run --watch
 ```
 
-Both forms read `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/config.ts` by default; set `GROUNDCREW_CONFIG` to point elsewhere. The `crew:op` wrapper additionally reads `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/op.env` (1Password env-file with `op://` references resolved at launch).
+Both forms discover config via cosmiconfig — project-walk from cwd for `crew.config.ts` and friends, then `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/crew.config.ts` (legacy `config.ts` is still accepted for one release). Set `GROUNDCREW_CONFIG` to point elsewhere. The `crew:op` wrapper additionally reads `${XDG_CONFIG_HOME:-$HOME/.config}/groundcrew/op.env` (1Password env-file with `op://` references resolved at launch).
 
 Logs land in `${XDG_STATE_HOME:-$HOME/.local/state}/groundcrew/groundcrew.log` by default (override via `logging.file`). The "Loaded config from …" line at startup tells you which config won.
 

package/{configExample.ts → crew.config.example.ts}

@@ -1,7 +1,7 @@
 import type { Config } from "./src/lib/config.js";
 // import { readFileSync } from "node:fs";
 
-export const config: Config = {
+export default {
   linear: {
     // Project URL slug to scope polling. Copy the trailing segment of
     // your Linear project URL —
@@ -9,7 +9,7 @@ export const config: Config = {
     // — verbatim, for example "ai-strategy-5152195762f3". The 12-char hex
     // tail is the canonical ID groundcrew uses, so the orchestrator stays
     // resilient across project renames and across same-name projects in
-    // different teams. The leading name segment keeps `config.ts`
+    // different teams. The leading name segment keeps the file
     // self-documenting at a glance.
     projectSlug: "your-project-name-0123456789ab",
     // statuses: { todo: "Todo", inProgress: "In Progress", done: "Done", terminal: ["Done"] },
@@ -76,4 +76,4 @@ export const config: Config = {
   //   // evidence with it. Default: `${XDG_STATE_HOME:-~/.local/state}/groundcrew/groundcrew.log`.
   //   file: "~/Library/Logs/groundcrew/groundcrew.log",
   // },
-};
+} satisfies Config;

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAiJA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BvD"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA6JA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BvD"}

package/dist/cli.js

@@ -1,7 +1,9 @@
 import { createRequire } from "node:module";
 import { cleanupWorkspaceCli } from "./commands/cleanupWorkspace.js";
 import { doctor } from "./commands/doctor.js";
+import { interruptWorkspaceCli } from "./commands/interruptWorkspace.js";
 import { orchestrate } from "./commands/orchestrator.js";
+import { resumeWorkspaceCli } from "./commands/resumeWorkspace.js";
 import { setupReposCli } from "./commands/setupRepos.js";
 import { setupWorkspaceCli } from "./commands/setupWorkspace.js";
 import { errorMessage, readTicketArgument, writeError, writeOutput } from "./lib/util.js";
@@ -90,6 +92,16 @@ const SUBCOMMANDS = {
         usage: "[--force] <ticket>",
         invoke: cleanupWorkspaceCli,
     },
+    interrupt: {
+        summary: "Stop a live ticket workspace while preserving its worktree",
+        usage: "<ticket> [--reason <text>]",
+        invoke: interruptWorkspaceCli,
+    },
+    resume: {
+        summary: "Reopen an existing ticket worktree with a continuation prompt",
+        usage: "<ticket>",
+        invoke: resumeWorkspaceCli,
+    },
     setup: {
         summary: "Project-level setup commands (currently: repos)",
         usage: "repos [--dry-run] [<repo>...]",

package/dist/commands/cleaner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleaner.d.ts","sourceRoot":"","sources":["../../src/commands/cleaner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,qBAAqB,CAAC;AAGpE,UAAU,WAAW;IACnB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,UAAU,EAAE;QAClB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,SAAS,aAAa,EAAE,CAAC;QAC1C,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAqDxD"}
+{"version":3,"file":"cleaner.d.ts","sourceRoot":"","sources":["../../src/commands/cleaner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,qBAAqB,CAAC;AAGpE,UAAU,WAAW;IACnB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,UAAU,EAAE;QAClB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,SAAS,aAAa,EAAE,CAAC;QAC1C,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAsDxD"}

package/dist/commands/cleaner.js

@@ -4,6 +4,7 @@
  * invocation; stateless across iterations. Mirrors `Dispatcher`.
  */
 import { isTerminalStatus } from "../lib/boardSource.js";
+import { recordCleanedUpRuns } from "../lib/runStateCleanup.js";
 import { log, logEvent } from "../lib/util.js";
 import { worktrees } from "../lib/worktrees.js";
 import { logTeardown, recordTeardownEvents } from "./teardownReporter.js";
@@ -41,6 +42,7 @@ export function createCleaner(deps) {
         const result = signal === undefined
             ? await worktrees.teardown(config, stale)
             : await worktrees.teardown(config, stale, { signal });
+        recordCleanedUpRuns(config, result.removed);
         logTeardown(result);
         recordTeardownEvents(result);
     }

package/dist/commands/cleanupWorkspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleanupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/cleanupWorkspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKnE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAwBD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvE"}
+{"version":3,"file":"cleanupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/cleanupWorkspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMnE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAwBD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAef;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvE"}

package/dist/commands/cleanupWorkspace.js

@@ -1,4 +1,5 @@
 import { loadConfig } from "../lib/config.js";
+import { recordCleanedUpRuns } from "../lib/runStateCleanup.js";
 import { log } from "../lib/util.js";
 import { worktrees } from "../lib/worktrees.js";
 import { logTeardown } from "./teardownReporter.js";
@@ -29,6 +30,7 @@ export async function cleanupWorkspace(config, options) {
         return;
     }
     const result = await worktrees.teardown(config, entries, { force });
+    recordCleanedUpRuns(config, result.removed);
     logTeardown(result);
     if (result.failures.length > 0) {
         throw result.failures[0]?.error;

package/dist/commands/interruptWorkspace.d.ts

@@ -0,0 +1,8 @@
+import { type ResolvedConfig } from "../lib/config.ts";
+export interface InterruptWorkspaceOptions {
+    ticket: string;
+    reason?: string;
+}
+export declare function interruptWorkspace(config: ResolvedConfig, options: InterruptWorkspaceOptions): Promise<void>;
+export declare function interruptWorkspaceCli(argv: string[]): Promise<void>;
+//# sourceMappingURL=interruptWorkspace.d.ts.map

package/dist/commands/interruptWorkspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interruptWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/interruptWorkspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMnE,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAuGD,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAGzE"}

package/dist/commands/interruptWorkspace.js

@@ -0,0 +1,108 @@
+import { loadConfig } from "../lib/config.js";
+import { readRunState, recordRunState } from "../lib/runState.js";
+import { errorMessage, log } from "../lib/util.js";
+import { workspaces } from "../lib/workspaces.js";
+import { worktrees } from "../lib/worktrees.js";
+function parseArguments(argv) {
+    let reason;
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        /* v8 ignore next @preserve -- loop bounds ensure argv[index] exists; guard satisfies noUncheckedIndexedAccess */
+        if (argument === undefined) {
+            continue;
+        }
+        if (argument === "--reason") {
+            const value = argv[index + 1];
+            if (value === undefined || value.length === 0 || value.startsWith("-")) {
+                throw new Error("crew interrupt --reason: reason text is required");
+            }
+            reason = value;
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            throw new Error(`Unknown option: ${argument}\nUsage: crew interrupt <ticket> [--reason <text>]`);
+        }
+        positionals.push(argument);
+    }
+    const [ticket, ...extras] = positionals;
+    if (ticket === undefined || ticket.length === 0 || extras.length > 0) {
+        throw new Error("Usage: crew interrupt <ticket> [--reason <text>]");
+    }
+    return { ticket: ticket.toLowerCase(), ...(reason === undefined ? {} : { reason }) };
+}
+function sourceFromState(state) {
+    return {
+        ticket: state.ticket,
+        repository: state.repository,
+        model: state.model,
+        worktreeDir: state.worktreeDir,
+        branchName: state.branchName,
+        workspaceName: state.workspaceName,
+        resumeCount: state.resumeCount,
+    };
+}
+function sourceFromWorktree(config, ticket, entry) {
+    return {
+        ticket,
+        repository: entry.repository,
+        model: config.models.default,
+        worktreeDir: entry.dir,
+        branchName: entry.branchName,
+        workspaceName: ticket,
+        resumeCount: 0,
+    };
+}
+function resolveInterruptSource(arguments_) {
+    if (arguments_.state !== undefined) {
+        return sourceFromState(arguments_.state);
+    }
+    if (arguments_.entry !== undefined) {
+        return sourceFromWorktree(arguments_.config, arguments_.ticket, arguments_.entry);
+    }
+    throw new Error(`No run state or worktree found for ${arguments_.ticket}; nothing to interrupt.`);
+}
+function interruptDetail(result) {
+    if (result.kind === "missing") {
+        return "workspace missing";
+    }
+    return undefined;
+}
+function failOnUnavailable(result) {
+    if (result.kind !== "unavailable") {
+        return;
+    }
+    const detail = result.error === undefined ? "workspace adapter unavailable" : errorMessage(result.error);
+    throw new Error(`Could not interrupt workspace: ${detail}`);
+}
+export async function interruptWorkspace(config, options) {
+    const ticket = options.ticket.toLowerCase();
+    const state = readRunState(config, ticket);
+    const [entry] = worktrees.findByTicket(config, ticket);
+    const source = resolveInterruptSource({ config, ticket, state, entry });
+    const result = await workspaces.interrupt(config, source.workspaceName);
+    failOnUnavailable(result);
+    const detail = interruptDetail(result);
+    recordRunState({
+        config,
+        state: {
+            ticket,
+            repository: source.repository,
+            model: source.model,
+            worktreeDir: source.worktreeDir,
+            branchName: source.branchName,
+            workspaceName: source.workspaceName,
+            state: "interrupted",
+            resumeCount: source.resumeCount,
+            ...(options.reason === undefined ? {} : { reason: options.reason }),
+            ...(detail === undefined ? {} : { detail }),
+        },
+    });
+    log(`Interrupted ${ticket}; worktree preserved at ${source.worktreeDir}`);
+    log(`Next: crew doctor --ticket ${ticket}`);
+}
+export async function interruptWorkspaceCli(argv) {
+    const config = await loadConfig();
+    await interruptWorkspace(config, parseArguments(argv));
+}

package/dist/commands/resumeWorkspace.d.ts

@@ -0,0 +1,7 @@
+import { type ResolvedConfig } from "../lib/config.ts";
+export interface ResumeWorkspaceOptions {
+    ticket: string;
+}
+export declare function resumeWorkspace(config: ResolvedConfig, options: ResumeWorkspaceOptions): Promise<void>;
+export declare function resumeWorkspaceCli(argv: string[]): Promise<void>;
+//# sourceMappingURL=resumeWorkspace.d.ts.map

package/dist/commands/resumeWorkspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resumeWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/resumeWorkspace.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAcnE,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB;AA6HD,wBAAsB,eAAe,CACnC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA6Df;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAGtE"}

package/dist/commands/resumeWorkspace.js

@@ -0,0 +1,163 @@
+import { fetchResolvedIssue } from "../lib/boardSource.js";
+import { loadConfig } from "../lib/config.js";
+import { ensureAgentSandbox, openAgentWorkspace, prepareAgentLaunch } from "../lib/agentLaunch.js";
+import { buildLaunchCommand } from "../lib/launchCommand.js";
+import { readRunState, recordRunState } from "../lib/runState.js";
+import { removeStagedPrompt, stageBuildSecrets, stagePromptText, stageWorkspaceLaunchCommand, } from "../lib/stagedLaunch.js";
+import { errorMessage, getLinearClient, log } from "../lib/util.js";
+import { workspaces } from "../lib/workspaces.js";
+import { worktrees } from "../lib/worktrees.js";
+function parseArguments(argv) {
+    const [ticket, ...extras] = argv;
+    if (ticket === undefined || ticket.length === 0 || extras.length > 0 || ticket.startsWith("-")) {
+        throw new Error("Usage: crew resume <ticket>");
+    }
+    return { ticket: ticket.toLowerCase() };
+}
+async function fetchTicketDetails(ticket) {
+    try {
+        const issue = await getLinearClient().issue(ticket.toUpperCase());
+        return {
+            title: issue.title,
+            description: issue.description ?? "",
+        };
+    }
+    catch (error) {
+        log(`Resume Linear detail lookup failed for ${ticket}: ${errorMessage(error)}`);
+        return undefined;
+    }
+}
+async function contextFromLinear(config, ticket, worktree) {
+    const resolved = await fetchResolvedIssue({ client: getLinearClient(), config, ticket });
+    return {
+        ticket,
+        repository: resolved.repository,
+        model: resolved.model,
+        worktree,
+        title: resolved.title,
+        description: resolved.description,
+        resumeCount: 0,
+    };
+}
+async function contextFromState(ticket, state, worktree) {
+    const details = await fetchTicketDetails(ticket);
+    return {
+        ticket,
+        repository: state.repository,
+        model: state.model,
+        worktree,
+        title: details?.title ?? ticket.toUpperCase(),
+        description: details?.description ?? "",
+        ...(state.reason === undefined ? {} : { reason: state.reason }),
+        resumeCount: state.resumeCount,
+    };
+}
+async function buildResumeContext(config, ticket) {
+    const state = readRunState(config, ticket);
+    const entries = worktrees.findByTicket(config, ticket);
+    const worktree = state === undefined
+        ? entries[0]
+        : (entries.find((entry) => entry.repository === state.repository) ?? entries[0]);
+    if (worktree === undefined) {
+        throw new Error(`No worktree found for ${ticket}; cannot resume.`);
+    }
+    if (state !== undefined) {
+        return await contextFromState(ticket, state, worktree);
+    }
+    return await contextFromLinear(config, ticket, worktree);
+}
+function renderResumePrompt(context) {
+    return [
+        `You are resuming Groundcrew ticket ${context.ticket} (${context.title}) in an existing worktree.`,
+        "",
+        "Ticket description:",
+        "",
+        context.description,
+        "",
+        "## Continuation context",
+        "",
+        `- Worktree: ${context.worktree.dir}`,
+        `- Branch: ${context.worktree.branchName}`,
+        context.reason === undefined
+            ? "- Previous interrupt reason: none recorded"
+            : `- Previous interrupt reason: ${context.reason}`,
+        "",
+        "Before editing, inspect the current git status and diff. Continue from the work already present in this worktree; do not restart from scratch unless the diff proves that is necessary.",
+        "",
+        "Run the repository's documented verification before stopping, then leave the branch ready or open a PR when possible.",
+    ].join("\n");
+}
+async function failIfWorkspaceAlreadyLive(config, ticket) {
+    const probe = await workspaces.probe(config);
+    if (probe.kind === "unavailable") {
+        const detail = probe.error === undefined ? "" : `: ${errorMessage(probe.error)}`;
+        throw new Error(`Could not verify whether workspace for ${ticket} is already live${detail}. Retry or inspect the workspace backend manually before resuming.`);
+    }
+    if (probe.names.has(ticket)) {
+        throw new Error(`Workspace for ${ticket} is already live; attach to it instead of resuming.`);
+    }
+}
+export async function resumeWorkspace(config, options) {
+    const ticket = options.ticket.toLowerCase();
+    await failIfWorkspaceAlreadyLive(config, ticket);
+    const context = await buildResumeContext(config, ticket);
+    const definition = config.models.definitions[context.model];
+    if (definition === undefined) {
+        throw new Error(`Unknown model: ${context.model}`);
+    }
+    const { runner, sandboxName } = await prepareAgentLaunch({
+        config,
+        model: context.model,
+        definition,
+        purpose: "resumes",
+    });
+    const stagedPrompt = stagePromptText({
+        prefix: "groundcrew-resume",
+        ticket,
+        text: renderResumePrompt(context),
+    });
+    const secretsFile = stageBuildSecrets(stagedPrompt.directory);
+    await ensureAgentSandbox({ config, definition, sandboxName });
+    const launchCommand = buildLaunchCommand({
+        definition,
+        promptFile: stagedPrompt.file,
+        worktreeDir: context.worktree.dir,
+        secretsFile,
+        runner,
+        sandboxName,
+    });
+    const launchCmd = stageWorkspaceLaunchCommand(stagedPrompt.directory, launchCommand);
+    try {
+        await openAgentWorkspace({
+            config,
+            name: ticket,
+            cwd: context.worktree.dir,
+            command: launchCmd,
+            model: context.model,
+            color: definition.color,
+        });
+    }
+    catch (error) {
+        removeStagedPrompt(stagedPrompt.directory);
+        throw error;
+    }
+    recordRunState({
+        config,
+        state: {
+            ticket,
+            repository: context.repository,
+            model: context.model,
+            worktreeDir: context.worktree.dir,
+            branchName: context.worktree.branchName,
+            workspaceName: ticket,
+            state: "resumed",
+            resumeCount: context.resumeCount + 1,
+            ...(context.reason === undefined ? {} : { reason: context.reason }),
+        },
+    });
+    log(`Resumed ${ticket} in ${context.worktree.dir} (${context.model})`);
+}
+export async function resumeWorkspaceCli(argv) {
+    const config = await loadConfig();
+    await resumeWorkspace(config, parseArguments(argv));
+}

package/dist/commands/setupWorkspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/setupWorkspace.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAUvF,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAgBD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAmED,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,qBAAqB,EAC9B,UAAU,GAAE,wBAA6B,GACxC,OAAO,CAAC,IAAI,CAAC,CAuGf;AA0FD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAoBf"}
+{"version":3,"file":"setupWorkspace.d.ts","sourceRoot":"","sources":["../../src/commands/setupWorkspace.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAenE,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAWD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAqBD,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,qBAAqB,EAC9B,UAAU,GAAE,wBAA6B,GACxC,OAAO,CAAC,IAAI,CAAC,CA6Gf;AAwHD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAoBf"}