@martintrojer/mu 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -342,6 +342,19 @@ declare function enableMuPaneBordersForPane(paneId: string): Promise<void>;
  * in hud_visual_cue_impl.
  */
 declare function enableMuPaneBorders(target: string): Promise<void>;
+/**
+ * Look up the TTY device path for a pane (e.g. `/dev/ttys012` on macOS,
+ * `/dev/pts/3` on Linux). Used by `mu agent kick` to find the
+ * foreground process group on the pane's TTY so it can be signalled
+ * directly — `tmux send-keys C-c` does NOT propagate to wrapped
+ * subprocesses inside a CLI like pi/claude/codex (the CLI catches it
+ * itself and treats it as a UI input). The escape hatch is signalling
+ * the foreground pgid of the underlying TTY from outside the pane.
+ *
+ * Throws `PaneNotFoundError` when the pane id is invalid or the pane
+ * has vanished. Throws `TmuxError` on any other tmux failure.
+ */
+declare function paneTTY(paneId: string): Promise<string>;
 declare function getPaneTitle(paneId: string): Promise<string | undefined>;
 /**
  * Read the title of the *current* pane (the one whose shell is running this
@@ -451,6 +464,7 @@ declare const tmux$1_newSession: typeof newSession;
 declare const tmux$1_newSessionWithPane: typeof newSessionWithPane;
 declare const tmux$1_newWindow: typeof newWindow;
 declare const tmux$1_paneExists: typeof paneExists;
+declare const tmux$1_paneTTY: typeof paneTTY;
 declare const tmux$1_parseAgentNameFromTitle: typeof parseAgentNameFromTitle;
 declare const tmux$1_resetSleep: typeof resetSleep;
 declare const tmux$1_resetTmuxExecutor: typeof resetTmuxExecutor;
@@ -464,7 +478,7 @@ declare const tmux$1_sleep: typeof sleep;
 declare const tmux$1_splitWindow: typeof splitWindow;
 declare const tmux$1_tmux: typeof tmux;
 declare namespace tmux$1 {
-  export { type tmux$1_CaptureOptions as CaptureOptions, type tmux$1_NewSessionOptions as NewSessionOptions, type tmux$1_NewSessionWithPaneOptions as NewSessionWithPaneOptions, type tmux$1_NewWindowOptions as NewWindowOptions, tmux$1_PANE_ID_RE as PANE_ID_RE, tmux$1_PaneNotFoundError as PaneNotFoundError, type tmux$1_SendOptions as SendOptions, type tmux$1_SplitWindowOptions as SplitWindowOptions, tmux$1_TmuxError as TmuxError, type tmux$1_TmuxExecResult as TmuxExecResult, type tmux$1_TmuxExecutor as TmuxExecutor, type tmux$1_TmuxPane as TmuxPane, type tmux$1_TmuxSession as TmuxSession, type tmux$1_TmuxWindow as TmuxWindow, tmux$1_assertValidPaneId as assertValidPaneId, tmux$1_capturePane as capturePane, tmux$1_currentAgentName as currentAgentName, tmux$1_currentPaneSize as currentPaneSize, tmux$1_currentPaneTitle as currentPaneTitle, tmux$1_defaultSendDelayMs as defaultSendDelayMs, tmux$1_enableMuPaneBorders as enableMuPaneBorders, tmux$1_enableMuPaneBordersForPane as enableMuPaneBordersForPane, tmux$1_enableMuPaneBordersForSession as enableMuPaneBordersForSession, tmux$1_getPaneTitle as getPaneTitle, tmux$1_getWindowIdForPane as getWindowIdForPane, tmux$1_isValidPaneId as isValidPaneId, tmux$1_killPane as killPane, tmux$1_killSession as killSession, tmux$1_listPanes as listPanes, tmux$1_listPanesInSession as listPanesInSession, tmux$1_listSessions as listSessions, tmux$1_listWindows as listWindows, tmux$1_newSession as newSession, tmux$1_newSessionWithPane as newSessionWithPane, tmux$1_newWindow as newWindow, tmux$1_paneExists as paneExists, tmux$1_parseAgentNameFromTitle as parseAgentNameFromTitle, tmux$1_resetSleep as resetSleep, tmux$1_resetTmuxExecutor as resetTmuxExecutor, tmux$1_selectLayout as selectLayout, tmux$1_sendToPane as sendToPane, tmux$1_sessionExists as sessionExists, tmux$1_setPaneTitle as setPaneTitle, tmux$1_setSleepForTests as setSleepForTests, tmux$1_setTmuxExecutor as setTmuxExecutor, tmux$1_sleep as sleep, tmux$1_splitWindow as splitWindow, tmux$1_tmux as tmux };
+  export { type tmux$1_CaptureOptions as CaptureOptions, type tmux$1_NewSessionOptions as NewSessionOptions, type tmux$1_NewSessionWithPaneOptions as NewSessionWithPaneOptions, type tmux$1_NewWindowOptions as NewWindowOptions, tmux$1_PANE_ID_RE as PANE_ID_RE, tmux$1_PaneNotFoundError as PaneNotFoundError, type tmux$1_SendOptions as SendOptions, type tmux$1_SplitWindowOptions as SplitWindowOptions, tmux$1_TmuxError as TmuxError, type tmux$1_TmuxExecResult as TmuxExecResult, type tmux$1_TmuxExecutor as TmuxExecutor, type tmux$1_TmuxPane as TmuxPane, type tmux$1_TmuxSession as TmuxSession, type tmux$1_TmuxWindow as TmuxWindow, tmux$1_assertValidPaneId as assertValidPaneId, tmux$1_capturePane as capturePane, tmux$1_currentAgentName as currentAgentName, tmux$1_currentPaneSize as currentPaneSize, tmux$1_currentPaneTitle as currentPaneTitle, tmux$1_defaultSendDelayMs as defaultSendDelayMs, tmux$1_enableMuPaneBorders as enableMuPaneBorders, tmux$1_enableMuPaneBordersForPane as enableMuPaneBordersForPane, tmux$1_enableMuPaneBordersForSession as enableMuPaneBordersForSession, tmux$1_getPaneTitle as getPaneTitle, tmux$1_getWindowIdForPane as getWindowIdForPane, tmux$1_isValidPaneId as isValidPaneId, tmux$1_killPane as killPane, tmux$1_killSession as killSession, tmux$1_listPanes as listPanes, tmux$1_listPanesInSession as listPanesInSession, tmux$1_listSessions as listSessions, tmux$1_listWindows as listWindows, tmux$1_newSession as newSession, tmux$1_newSessionWithPane as newSessionWithPane, tmux$1_newWindow as newWindow, tmux$1_paneExists as paneExists, tmux$1_paneTTY as paneTTY, tmux$1_parseAgentNameFromTitle as parseAgentNameFromTitle, tmux$1_resetSleep as resetSleep, tmux$1_resetTmuxExecutor as resetTmuxExecutor, tmux$1_selectLayout as selectLayout, tmux$1_sendToPane as sendToPane, tmux$1_sessionExists as sessionExists, tmux$1_setPaneTitle as setPaneTitle, tmux$1_setSleepForTests as setSleepForTests, tmux$1_setTmuxExecutor as setTmuxExecutor, tmux$1_sleep as sleep, tmux$1_splitWindow as splitWindow, tmux$1_tmux as tmux };
 }
 
 /**
@@ -542,6 +556,52 @@ interface ReconcileReport {
 }
 declare function reconcile(db: Db, opts: ReconcileOptions): Promise<ReconcileReport>;
 
+/**
+ * Pre-flight failure: the command mu would have spawned in the new
+ * pane doesn't resolve to a binary on PATH (and isn't an absolute /
+ * relative path that exists + is executable). Thrown by `spawnAgent`
+ * BEFORE `prestageWorkspace` so a typo in `--cli` never leaves an
+ * orphan workspace dir behind.
+ *
+ * Source: feedback ws task `fb_agent_spawn_no_validation`. Live
+ * dogfood report: `mu agent spawn worker-1 --cli pi-meta` on a host
+ * where the `pi-meta` binary wasn't on PATH printed `Spawned worker-1
+ * (pi-meta)` and the pane immediately died with `command not found`;
+ * the existing 1.5s liveness check sometimes missed it (the shell
+ * stays alive after the failed exec). Pre-flighting the PATH lookup
+ * surfaces the typo before any side effects (workspace, pane, DB row).
+ *
+ * Distinct from `AgentSpawnStartupError` (pane alive but parked at an
+ * error prompt) and `AgentDiedOnSpawnError` (pane vanished within the
+ * liveness window). All three carry different remediation hints, so
+ * they're separate types.
+ */
+declare class AgentSpawnCliNotFoundError extends Error implements HasNextSteps {
+    readonly cli: string;
+    /** First whitespace-separated token of the resolved command — the
+     *  thing actually missing on PATH. Surfaced verbatim in the
+     *  message so the operator sees what mu searched for (which may
+     *  differ from `cli` when `$MU_<UPPER_CLI>_COMMAND` rewrites it). */
+    readonly binary: string;
+    /** Name of the env var that mu consulted before falling back to
+     *  the bare `cli` value (e.g. `MU_PI_META_COMMAND`). Always set
+     *  to the conventional name so the nextSteps hint can recommend
+     *  exporting it. */
+    readonly envVarChecked: string;
+    readonly name = "AgentSpawnCliNotFoundError";
+    constructor(cli: string, 
+    /** First whitespace-separated token of the resolved command — the
+     *  thing actually missing on PATH. Surfaced verbatim in the
+     *  message so the operator sees what mu searched for (which may
+     *  differ from `cli` when `$MU_<UPPER_CLI>_COMMAND` rewrites it). */
+    binary: string, 
+    /** Name of the env var that mu consulted before falling back to
+     *  the bare `cli` value (e.g. `MU_PI_META_COMMAND`). Always set
+     *  to the conventional name so the nextSteps hint can recommend
+     *  exporting it. */
+    envVarChecked: string);
+    errorNextSteps(): NextStep[];
+}
 declare class AgentExistsError extends Error implements HasNextSteps {
     readonly agentName: string;
     readonly name = "AgentExistsError";
@@ -600,6 +660,52 @@ declare class AgentDiedOnSpawnError extends Error implements HasNextSteps {
     constructor(agentName: string, paneId: string, scrollback: string | undefined);
     errorNextSteps(): NextStep[];
 }
+/**
+ * Thrown when an agent's pane is alive AND staying alive after the
+ * liveness window, but its first burst of output matches a known
+ * provider-startup-failure pattern (missing API key, auth rejected, …).
+ * Source: feedback ws task `agent_spawn_model_auth_failure_counts_as_live`.
+ * Live dogfood report: `pi-meta --no-solo --model sonnet:high` printed
+ * `Error: No API key found for amazon-bedrock` and parked at a prompt.
+ * The pane stayed alive (1.5s liveness check passed) but the worker
+ * could never do work — the orchestrator only discovered this when
+ * `mu task wait` stalled minutes later.
+ *
+ * Distinct from `AgentDiedOnSpawnError`:
+ *   - `AgentDiedOnSpawnError` → pane vanished within the liveness window
+ *     (CLI exited fast).
+ *   - `AgentSpawnStartupError` → pane alive, but the captured scrollback
+ *     tail contains a curated provider-auth-failure pattern.
+ * The two carry different remediation hints (CLI override vs. fix the
+ * env var), so they're separate types instead of one with a flag.
+ *
+ * The pattern list is curated and short to keep false-positive risk low
+ * — the scan only looks at the last ~30 lines of the 50-line capture
+ * taken right after the liveness sleep, so matches naturally come from
+ * the CLI's first ~1.5s of output (not arbitrary later prompts the
+ * agent might type into).
+ */
+declare class AgentSpawnStartupError extends Error implements HasNextSteps {
+    readonly agentName: string;
+    readonly paneId: string;
+    /** The single scrollback line that matched a known startup-error
+     *  pattern. Surfaced verbatim in the message so the operator sees
+     *  what mu saw. */
+    readonly matchedLine: string;
+    /** Full captured scrollback (tail-trimmed already by
+     *  awaitSpawnLiveness). Attached to the message for context. */
+    readonly scrollback: string;
+    readonly name = "AgentSpawnStartupError";
+    constructor(agentName: string, paneId: string, 
+    /** The single scrollback line that matched a known startup-error
+     *  pattern. Surfaced verbatim in the message so the operator sees
+     *  what mu saw. */
+    matchedLine: string, 
+    /** Full captured scrollback (tail-trimmed already by
+     *  awaitSpawnLiveness). Attached to the message for context. */
+    scrollback: string);
+    errorNextSteps(): NextStep[];
+}
 /**
  * Thrown when `closeAgent` is called on an agent that has an associated
  * workspace AND the caller didn't explicitly opt into discarding it.
@@ -740,6 +846,31 @@ interface VcsBackend {
      * the on-disk dir without touching the agent or pane.
      */
     rebaseTo(workspacePath: string, fromRef?: string): Promise<RebaseResult>;
+    /**
+     * Cheap "is the working copy clean?" probe used by close-auto-free
+     * (allow_mu_agent_close_without_discard). Definition: ZERO uncommitted
+     * changes (no working-tree modifications, no staged changes, no
+     * untracked-not-ignored files). Pure observation; no fetch, no commit.
+     *
+     * Backend-specific:
+     *   - git: empty `git status --porcelain` output.
+     *   - jj:  jj is auto-snapshotted, so the @ commit IS the WC; clean
+     *          here means @ has no diff from its parent (empty `jj diff
+     *          -r @ --summary`). A description-only difference still
+     *          counts as clean.
+     *   - sl:  empty `sl status` output.
+     *   - none: meaningless (cp -a snapshot has no notion of
+     *          "committed" vs "uncommitted"); always returns true so the
+     *          close-auto-free path treats every none-workspace as
+     *          eligible for silent free (no commits can be lost; the only
+     *          loss is local file edits, which the operator implicitly
+     *          accepts by closing the agent).
+     *
+     * Returns false on any backend command failure — be conservative
+     * (we'd rather refuse a close than auto-free a workspace whose
+     * cleanliness we couldn't verify).
+     */
+    isClean(workspacePath: string): Promise<boolean>;
     /**
      * List commits the workspace has on top of `baseRef`, oldest-first.
      * Used by `mu workspace commits` (fb_workspace_commits_verb) to
@@ -754,6 +885,27 @@ interface VcsBackend {
      * on backend command failure (unknown ref, missing repo).
      */
     commitsSinceBase(workspacePath: string, baseRef: string): Promise<CommitSummary[]>;
+    /**
+     * Return the list of dirty (uncommitted / unstaged / untracked-not-
+     * ignored) paths in the workspace. Empty array = clean.
+     *
+     * Used by `mu workspace recreate` to refuse a free+create cycle on
+     * a dirty workspace unless the operator passes `--force` (the lossy
+     * escape hatch). Mirrors the dirty-check `rebaseTo` does internally.
+     *
+     * Backend semantics:
+     *   - git: `git status --porcelain` (working-tree + staged +
+     *     untracked-not-ignored, mirroring the rebaseTo path).
+     *   - sl:  `sl status` parsed for non-empty output.
+     *   - jj:  always-snapshotted, so no concept of "dirty" — returns [].
+     *   - none: cp -a snapshots have no VCS, so we can't decide "dirty";
+     *     returns [] so the caller doesn't refuse for an unanswerable
+     *     question.
+     *
+     * Throws on backend command failure (the operator should see a
+     * real error, not a silent "clean").
+     */
+    listDirtyFiles(workspacePath: string): Promise<string[]>;
 }
 declare const noneBackend: VcsBackend;
 declare const gitBackend: VcsBackend;
@@ -779,6 +931,48 @@ declare function backendByName(name: VcsBackendName): VcsBackend;
  * are still recognised as agents.
  */
 declare function resolveCliCommand(cli: string): string;
+/**
+ * Compute the `MU_<UPPER_CLI>_COMMAND` env var name mu consults when
+ * resolving `--cli <key>`. Hyphens in the cli key become underscores
+ * (env var names can't contain `-`); this matches the operator-aliases
+ * convention documented in the mu skill (e.g. `--cli pi-meta` →
+ * `MU_PI_META_COMMAND`).
+ */
+declare function envVarNameForCli(cli: string): string;
+/**
+ * Resolve `--cli <key>` to its actual command string AND tell the
+ * caller whether the resolution came from a `MU_<UPPER_CLI>_COMMAND`
+ * env var or fell through to the bare cli name. The CLI uses this to
+ * surface env-var attribution in the spawn-success line so config
+ * issues are visible without `mu agent show`
+ * (fb_agent_spawn_no_validation, part C).
+ */
+declare function resolveCliCommandWithSource(cli: string): {
+    command: string;
+    envVar: string;
+    resolvedFromEnv: boolean;
+};
+interface CommandResolutionResult {
+    ok: boolean;
+    /** First whitespace-separated token of the command — the binary
+     *  whose presence on PATH we checked. */
+    binary: string;
+    /** Absolute path of the resolved binary on PATH, when ok=true. */
+    resolvedPath?: string;
+}
+type CommandResolver = (command: string) => Promise<CommandResolutionResult>;
+/** Override the PATH resolver. Tests use this to simulate "binary
+ *  absent" / "binary present" without depending on what's actually
+ *  installed. Production callers should never touch this. */
+declare function setCommandResolverForTests(resolver: CommandResolver): void;
+/** Restore the default PATH resolver. */
+declare function resetCommandResolverForTests(): void;
+/**
+ * Verify the first token of `command` resolves to a binary on PATH.
+ * Public so tests can call it directly; spawnAgent calls it before
+ * prestageWorkspace so a bad --cli never creates an orphan workspace.
+ */
+declare function checkCommandResolvable(command: string): Promise<CommandResolutionResult>;
 interface SpawnAgentOptions {
     name: string;
     workstream: string;
@@ -899,6 +1093,119 @@ interface AdoptAgentResult {
  */
 declare function adoptAgent(db: Db, opts: AdoptAgentOptions): Promise<AdoptAgentResult>;
 
+/** The signal set kick supports. SIGINT is graceful (matches Ctrl-C
+ *  semantics — what the operator probably wanted in the first place);
+ *  SIGTERM is the polite escalation; SIGKILL is the unblockable
+ *  hammer. We deliberately don't expose arbitrary signals — the
+ *  three above are the actionable ones for "interrupt a wedged
+ *  foreground tool subprocess." */
+type KickSignal = "SIGINT" | "SIGTERM" | "SIGKILL";
+declare function isKickSignal(s: string): s is KickSignal;
+/**
+ * Thrown when the foreground pgid lookup on a pane's TTY yields
+ * either no rows at all (the pane is sitting at an idle shell with
+ * no foreground job) or only the wrapping shell itself (the LLM CLI
+ * — pi/claude/codex — is the foreground; signalling it would close
+ * the agent, which is what `mu agent close` is for).
+ *
+ * Maps to the generic exit code 1 in handle.ts (this is a
+ * runtime-state condition, not a typed not-found / conflict).
+ */
+declare class NoForegroundProcessError extends Error implements HasNextSteps {
+    readonly agentName: string;
+    readonly tty: string;
+    readonly reason: "no-foreground" | "shell-only";
+    readonly name = "NoForegroundProcessError";
+    constructor(agentName: string, tty: string, reason: "no-foreground" | "shell-only");
+    errorNextSteps(): NextStep[];
+}
+interface KickProcessExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}
+type KickProcessExecutor = (cmd: string, args: readonly string[]) => Promise<KickProcessExecResult>;
+/** Install a custom executor (for tests). Returns the previous one so
+ *  tests can restore cleanly. */
+declare function setKickProcessExecutor(executor: KickProcessExecutor): KickProcessExecutor;
+/** Restore the real executor. */
+declare function resetKickProcessExecutor(): void;
+interface PsRow {
+    pid: number;
+    pgid: number;
+    /** ps's `stat` (or `state`) field. The presence of `+` means
+     *  "foreground process group on its controlling tty". */
+    stat: string;
+    /** Process command (just the comm; truncated, used for diagnostics). */
+    comm: string;
+}
+/**
+ * Parse `ps -t <tty> -o pid=,pgid=,stat=,comm=` output. Each non-blank
+ * line is one process: four whitespace-separated fields. Defensive
+ * about leading whitespace and command names with embedded spaces
+ * (the comm is the LAST field — join the tail).
+ */
+declare function parsePsTtyOutput(output: string): PsRow[];
+/**
+ * Resolve the foreground process group id for a TTY device path. The
+ * canonical signal `ps`'s `stat` field uses is `+` (BSD/Darwin AND
+ * Linux procps). We pick the first row whose stat contains `+`; its
+ * `pgid` is the foreground pgid of that controlling terminal.
+ *
+ * Returns:
+ *   - `{ kind: "ok", pgid, fgRow }` on success
+ *   - `{ kind: "no-foreground" }` when no row carries `+` AND there
+ *     are no candidate rows at all
+ *   - `{ kind: "shell-only", pgid, fgRow }` when the foreground pgid
+ *     resolves to a shell whose comm is the agent's wrapping CLI
+ *     (caller decides whether to refuse — kick refuses)
+ *
+ * The wrapping-CLI guard is intentionally narrow: we only refuse
+ * when the foreground process command matches one of the known
+ * pi/claude/codex/zsh/bash shapes. Anything else (a `find`, a
+ * `cargo build`, a `python script.py`) is exactly what we want to
+ * signal — that's the unbounded-tool case the verb was built for.
+ */
+interface ForegroundLookup {
+    kind: "ok" | "shell-only" | "no-foreground";
+    pgid?: number;
+    fgRow?: PsRow;
+    /** All rows ps returned for the tty, for diagnostics / tests. */
+    rows: PsRow[];
+}
+declare function foregroundPgid(tty: string): Promise<ForegroundLookup>;
+interface KickAgentOptions {
+    workstream: string;
+    /** Defaults to SIGINT (matches Ctrl-C semantics). */
+    signal?: KickSignal;
+}
+interface KickAgentResult {
+    agentName: string;
+    paneId: string;
+    /** TTY device path the foreground pgid was resolved against. */
+    tty: string;
+    /** The pgid we signalled. */
+    signaledPgid: number;
+    signal: KickSignal;
+    /** The comm of the foreground process at the time of signal — useful
+     *  diagnostic in the event log ("we kicked a `find`, not a `cargo`"). */
+    foregroundComm: string;
+}
+/**
+ * Send `signal` to the foreground process group of an agent's pane
+ * TTY. Default signal is SIGINT.
+ *
+ * Errors:
+ *   - `AgentNotFoundError` — the agent doesn't exist in this workstream.
+ *   - `PaneNotFoundError` (from paneTTY) — the agent's pane has vanished.
+ *   - `NoForegroundProcessError` — pane has no foreground job, OR the
+ *     foreground is the wrapping CLI itself (refuse; use `mu agent close`).
+ *
+ * Emits an `agent kick <name> (signal=..., pgid=..., comm=...)` event
+ * on success.
+ */
+declare function kickAgent(db: Db, name: string, opts: KickAgentOptions): Promise<KickAgentResult>;
+
 interface AgentRow {
     name: string;
     /** Foreign-name reference to the owning workstream. */
@@ -1025,14 +1332,17 @@ interface FreeAgentResult {
 declare function freeAgent(db: Db, name: string, workstream: string): FreeAgentResult;
 interface CloseAgentOptions {
     /**
-     * When true, free the agent's workspace BEFORE deleting the agent
-     * (so we control the order rather than relying on FK cascade, which
-     * leaves the on-disk dir orphaned). Lossy: any pending changes in
-     * the workspace are gone unless the caller frees with `--commit`
-     * separately first.
+     * Lossy override: when true, free the agent's workspace BEFORE
+     * deleting the agent regardless of whether it's clean. (We control
+     * the order rather than relying on FK cascade, which leaves the
+     * on-disk dir orphaned.) Any pending changes / commits since fork
+     * are gone unless the caller frees with `--commit` separately first.
      *
-     * When false (default) and a workspace exists, throws
-     * WorkspacePreservedError so the caller has to decide explicitly.
+     * When false (default), behaviour depends on workspace state:
+     *   - clean (no uncommitted changes AND no commits since fork):
+     *     silently auto-free. allow_mu_agent_close_without_discard.
+     *   - dirty (uncommitted changes OR commits since fork): throw
+     *     WorkspacePreservedError so the caller decides explicitly.
      * Surfaced as a real bug in the multi-agent dogfood teardown.
      */
     discardWorkspace?: boolean;
@@ -1040,11 +1350,20 @@ interface CloseAgentOptions {
 interface CloseAgentResult {
     killedPane: boolean;
     deletedRow: boolean;
-    /** True iff the agent had an associated workspace AND the caller
-     *  passed `discardWorkspace: true` so we proactively freed it.
-     *  False on the no-workspace path (nothing to free) and on the
-     *  refused path (we threw before doing anything). */
+    /** True iff the agent had an associated workspace AND we proactively
+     *  freed it — either because the caller passed `discardWorkspace:
+     *  true` (lossy) or because the workspace was clean and we
+     *  auto-freed (allow_mu_agent_close_without_discard). False on the
+     *  no-workspace path (nothing to free) and on the refused path (we
+     *  threw before doing anything). */
     workspaceFreed: boolean;
+    /** True iff `workspaceFreed` was triggered by the clean-workspace
+     *  auto-free path (no uncommitted changes AND no commits since
+     *  fork) rather than the explicit `discardWorkspace: true` override.
+     *  Lets the CLI render an accurate message ("auto-freed (clean)"
+     *  vs "workspace discarded") and gives JSON consumers a stable
+     *  signal. False on every other path. */
+    workspaceAutoFreedClean: boolean;
 }
 /**
  * Close an agent: kill its tmux pane and remove its DB row. Idempotent:
@@ -1052,15 +1371,22 @@ interface CloseAgentResult {
  *   - if the tmux pane is already gone, killPane swallows the error
  *
  * Workspace handling: closing an agent and freeing its workspace are
- * separate concerns (agent lifecycle vs disk artifacts), so by default
- * `closeAgent` REFUSES if the agent has a workspace — you'd otherwise
- * orphan the on-disk dir (the FK cascade drops the registry row but
- * not the directory). Two ways to proceed:
- *
- *   1. `freeWorkspace(db, name)` first, then `closeAgent(db, name)`.
- *      Preserves the option to `--commit` pending changes.
- *   2. `closeAgent(db, name, { discardWorkspace: true })`. One-shot;
- *      lossy.
+ * separate concerns (agent lifecycle vs disk artifacts). Three cases:
+ *
+ *   - No workspace: close proceeds normally.
+ *   - Workspace exists AND is CLEAN (no uncommitted changes, no
+ *     commits since fork): silently auto-free (so a workspace that
+ *     contains nothing worth preserving doesn't make the operator
+ *     type --discard-workspace just to clean it up). Surfaced by
+ *     allow_mu_agent_close_without_discard — a misconfigured-spawn
+ *     teardown was needlessly forced through the lossy flag.
+ *   - Workspace exists AND has either uncommitted changes OR commits
+ *     since fork: REFUSE with WorkspacePreservedError so the operator
+ *     decides explicitly. Two resolutions:
+ *       1. `freeWorkspace(db, name)` first, then `closeAgent(db, name)`.
+ *          Preserves the option to `--commit` pending changes.
+ *       2. `closeAgent(db, name, { discardWorkspace: true })`.
+ *          One-shot; lossy.
  *
  * The CLI surfaces these as the two actionable nextSteps on the
  * `WorkspacePreservedError` thrown by the refuse path.
@@ -1435,7 +1761,7 @@ declare class TaskHasOpenDependentsError extends Error implements HasNextSteps {
  * The FK on `tasks.owner` references `agents.name`; without this guard
  * the claim attempt would fail with the unhelpful 'FOREIGN KEY constraint
  * failed' from SQLite. This typed error gives the user actionable next
- * steps (run `mu adopt <pane-id>` to register, or use --for to pick a
+ * steps (run `mu agent adopt <pane-id>` to register, or use --for to pick a
  * different agent).
  *
  * Maps to exit code 4 (conflict) via the cli.ts handler.
@@ -1449,7 +1775,7 @@ declare class ClaimerNotRegisteredError extends Error implements HasNextSteps {
      * Three actionable resolutions in expected-frequency order:
      *   1. --self  : orchestrator pattern (working directly)
      *   2. --for   : dispatcher pattern (assigning to a worker)
-     *   3. mu adopt: registration pattern (promote pane to worker)
+     *   3. mu agent adopt: registration pattern (promote pane to worker)
      */
     errorNextSteps(): NextStep[];
 }
@@ -1571,17 +1897,14 @@ interface TaskWaitTaskState {
     stuck: boolean;
 }
 interface TaskWaitResult {
-    /** Per-task state at exit time. Same length and order as the input list. */
-    tasks: TaskWaitTaskState[];
-    /** True when EVERY task reached the target (the --all condition). */
-    allReached: boolean;
-    /** True when AT LEAST ONE task reached the target (the --any condition). */
-    anyReached: boolean;
-    /** Wall-clock time spent waiting, in ms (always >= 0). */
-    elapsedMs: number;
+    /** Per-task state at exit time. Same length and order as the input
+     *  list. The caller derives all-reached / any-reached / elapsed
+     *  from this list (count `r.reachedTarget`) and from its own
+     *  startedAt clock — keeping the SDK return minimal. */
+    refs: TaskWaitTaskState[];
     /** True when we exited because of the timeout, not because the wait
-     *  condition was met. allReached / anyReached can still be true on
-     *  partial progress when timedOut is true. */
+     *  condition was met. Refs that did reach the target are still
+     *  reflected in `refs[i].reachedTarget` on partial-progress timeout. */
     timedOut: boolean;
 }
 /**
@@ -1663,6 +1986,14 @@ interface CloseTaskOptions extends EvidenceOption {
      *   When false / omitted, behaves as bare `closeTask` (closes
      *   regardless of blocker status). */
     ifReady?: boolean;
+    /** Optional actor identity attributed to the synthetic `CLOSE: …`
+     *  note auto-inserted when `evidence` is non-empty (see closeTask
+     *  body). The CLI resolves this via `resolveActorIdentity()` so the
+     *  note carries the closing worker's name; SDK callers (tests,
+     *  internal use) may omit it (the note then carries no author, same
+     *  as a bare `addNote` without `--author`). Surfaced in mufeedback
+     *  task_close_evidence_does_not_append_the. */
+    author?: string;
 }
 /** Convenience: setTaskStatus(db, id, "CLOSED"). Accepts evidence.
  *  Pre-snapshots the DB (snap_design §CAPTURE STRATEGY > WHEN). Skipped
@@ -1888,11 +2219,6 @@ declare function resolveActorIdentity(): Promise<string>;
 interface TaskRow {
     /** Per-workstream-unique TEXT name. The operator-facing identifier. */
     name: string;
-    /** Alias for `name` — the per-workstream-unique TEXT id. Emitted alongside
-     *  `name` so JSON consumers can dot-access the canonical field name without
-     *  having to know that, for tasks specifically, `name` plays the localId
-     *  role. Always equal to `name`. */
-    localId: string;
     /** Foreign-name reference to the owning workstream. */
     workstreamName: string;
     title: string;
@@ -1930,6 +2256,14 @@ declare function slugifyTitle(title: string): string;
  *                    exceeds the SLUG_SOFT_CAP the verbose form had to
  *                    cut at a word boundary (or hard-truncate); the
  *                    cut clauses are gone with no in-band signal.
+ *   originalSlug   — what the slug WOULD have been without the
+ *                    SLUG_SOFT_CAP cut: full stripped slug with the
+ *                    same `t_` digit-prefix correction and the same
+ *                    SLUG_HARD_CAP ceiling, but no word-boundary
+ *                    truncation. Equal to `slug` when nothing was
+ *                    cut. The CLI surfaces this in `mu task add
+ *                    --json` so scripted callers can detect the
+ *                    truncation without grepping stderr.
  *   truncated      — true iff `slug.length < strippedLength` AFTER the
  *                    `t_` digit-prefix correction, i.e. real bytes were
  *                    dropped. False for any title that fits under the
@@ -1937,12 +2271,14 @@ declare function slugifyTitle(title: string): string;
  *                    is the `t_` prefix.
  *
  * The CLI's `mu task add` uses `truncated` to print a one-line stderr
- * hint pointing at the `<id>` positional override
- * (slugifytitle_silently_drops_clauses).
+ * hint pointing at the `<id>` positional override and (under --json)
+ * to surface `originalSlug` alongside `truncated:true`
+ * (slugifytitle_silently_drops_clauses; task_add_slugify_silently_truncates_ids).
  */
 interface SlugifyResult {
     slug: string;
     strippedLength: number;
+    originalSlug: string;
     truncated: boolean;
 }
 /**
@@ -1965,15 +2301,29 @@ declare function idFromTitle(db: Db, workstream: string, title: string): string;
  * Result of `idFromTitleVerbose`: the unique-in-workstream id plus the
  * truncated flag from the underlying slugify pass. Used by `mu task
  * add` to decide whether to surface the stderr hint about lost clauses
- * (slugifytitle_silently_drops_clauses).
+ * (slugifytitle_silently_drops_clauses) and to surface the un-truncated
+ * slug in `--json` (task_add_slugify_silently_truncates_ids).
+ *
+ *   id            — the unique-in-workstream task id.
+ *   truncated     — true iff the underlying slugify pass cut real
+ *                   characters (collision-suffixing does NOT flip
+ *                   this).
+ *   originalSlug  — what the slug would have been without the
+ *                   SLUG_SOFT_CAP cut. Equal to `id` when nothing was
+ *                   cut AND no collision suffix was appended; for
+ *                   the truncation-detection use case the only thing
+ *                   the CLI cares about is the lossy-vs-not
+ *                   comparison surfaced via `truncated`.
  */
 interface IdFromTitleResult {
     id: string;
     truncated: boolean;
+    originalSlug: string;
 }
 /**
- * Verbose sibling of `idFromTitle`: returns both the unique id and the
- * `truncated` flag from the slugify pass. Collision-suffixing (`_2`,
+ * Verbose sibling of `idFromTitle`: returns the unique id, the
+ * `truncated` flag from the slugify pass, and the un-truncated
+ * `originalSlug` for `--json` consumers. Collision-suffixing (`_2`,
  * `_3`, …) does not flip `truncated` — the underlying slug's lossiness
  * is what the CLI hint cares about.
  */
@@ -2012,9 +2362,42 @@ declare function listInProgress(db: Db, workstream: string): TaskRow[];
  *  raw-row type that was duplicating RawTaskRow
  *  (review_code_raw_task_state_duplicate). */
 declare function listRecentClosed(db: Db, workstream: string, limit?: number): TaskRow[];
+/** Optional filter knobs for `listNotes`. Default-everything-undefined
+ *  preserves the historical "return every note, oldest-first" shape so
+ *  every existing caller (cmdTaskShow's notes block, exporting.ts's
+ *  bucket renderer, agents.test.ts) keeps working unchanged.
+ *
+ *  Filters compose multiplicatively when both apply (`since` AND
+ *  `tail`): the timestamp filter is applied first, then `tail` slices
+ *  the last N of what survived. The CLI surface (`mu task notes
+ *  --tail / --since / --since-claim`) lives in src/cli/tasks/edit.ts;
+ *  the mutex between `--since` and `--since-claim` is a CLI concern,
+ *  not enforced here — if both arrive at the SDK, `since` wins (it's
+ *  the explicit one) and `sinceClaim` is ignored. The auto-resolve
+ *  for `sinceClaim` (look up the most recent `task claim` event in
+ *  agent_logs) happens here so the SDK is self-contained for scripted
+ *  callers. */
+interface ListNotesOptions {
+    /** Print only the last N notes (after any timestamp filter). Must
+     *  be a positive integer; a value of 0 returns no rows but is not
+     *  an error here — CLI-side validation rejects `--tail 0`. */
+    tail?: number;
+    /** ISO-8601 cutoff: only notes with `created_at > since` survive.
+     *  Comparison is lexicographic on the ISO string (matches the way
+     *  the rest of the codebase compares ISO timestamps). */
+    since?: string;
+    /** When true and `since` is unset, look up the `created_at` of the
+     *  most recent `task claim` event for this task and use it as the
+     *  cutoff. Falls back to no filter when no claim event exists
+     *  (equivalent to `--since-beginning`). */
+    sinceClaim?: boolean;
+}
 /** List notes for a task. Operator-facing local_id; resolves to the
- *  surrogate task id via taskIdFor (with optional workstream scope). */
-declare function listNotes(db: Db, taskLocalId: string, workstream: string): TaskNoteRow[];
+ *  surrogate task id via taskIdFor (with optional workstream scope).
+ *
+ *  Optional filters: see {@link ListNotesOptions}. Default behaviour
+ *  (no opts) is unchanged — every note, oldest-first. */
+declare function listNotes(db: Db, taskLocalId: string, workstream: string, opts?: ListNotesOptions): TaskNoteRow[];
 /**
  * All tasks currently owned by `agent` in a given workstream
  * (v5: agents.name is per-workstream unique). Sorted by local_id.
@@ -2295,8 +2678,8 @@ interface ExportSourceManifest {
     tasks: ExportTaskEntry[];
 }
 /** Top-level bucket manifest. `bucketVersion: 2` — the v0.3 shape.
- *  v1 (bucketVersion absent + top-level `workstream` field) is the
- *  legacy single-source shape and is rejected at write time. */
+ *  Manifests without `bucketVersion: 2` fall through to the
+ *  `corrupt` lane in `readManifest`. */
 interface ExportManifest {
     /** Schema discriminator. Always 2 in this codebase. */
     bucketVersion: 2;
@@ -2345,17 +2728,6 @@ interface RenderBucketResult {
     manifestPath: string;
     manifest: ExportManifest;
 }
-/** Thrown when the operator points an export at a directory whose
- *  existing manifest predates bucket layout (v1, single-source). The
- *  fix is destructive (remove and re-export) so we refuse to touch
- *  it in-place — the legacy directory may be checked into git and
- *  the operator should choose between rebuilding it and picking a
- *  new --out. */
-declare class LegacyExportLayoutError extends Error {
-    readonly outDir: string;
-    readonly name = "LegacyExportLayoutError";
-    constructor(outDir: string);
-}
 /**
  * Render `input.sources` to disk under `input.outDir` in the v0.3
  * bucket layout. Idempotent + additive:
@@ -2364,8 +2736,6 @@ declare class LegacyExportLayoutError extends Error {
  *     `input.sources` either appends (new) or refreshes (existing)
  *     its subdirectory; sources NOT in `input.sources` are left
  *     untouched.
- *   - If it exists but with a legacy (v1) manifest, throw
- *     `LegacyExportLayoutError`.
  *
  * Per-task idempotency is sha256-keyed: a re-export of the same
  * source against an unchanged DB rewrites zero task files. Tasks
@@ -2547,9 +2917,6 @@ interface ExportResult {
  * exporting a different workstream into the same bucket appends a
  * sibling subdir.
  *
- * Throws:
- *   - `LegacyExportLayoutError` if `outDir` already contains a
- *     pre-0.3 (single-source) manifest.json.
  */
 declare function exportWorkstream(db: Db, opts: ExportWorkstreamOptions): ExportResult;
 
@@ -2560,12 +2927,6 @@ declare class ImportBucketInvalidError extends Error implements HasNextSteps {
     constructor(bucketDir: string, reason: string);
     errorNextSteps(): NextStep[];
 }
-declare class ImportLegacyLayoutError extends Error implements HasNextSteps {
-    readonly bucketDir: string;
-    readonly name = "ImportLegacyLayoutError";
-    constructor(bucketDir: string);
-    errorNextSteps(): NextStep[];
-}
 declare class WorkstreamAlreadyExistsError extends Error implements HasNextSteps {
     readonly workstream: string;
     readonly name = "WorkstreamAlreadyExistsError";
@@ -2627,8 +2988,8 @@ interface ImportBucketResult {
  * Per source-ws transactional: a failure in source A rolls back A
  * but leaves source B's import committed.
  *
- * Throws on unrecoverable bucket-level errors (no manifest, legacy
- * layout, --workstream override against multi-source). Per-source
+ * Throws on unrecoverable bucket-level errors (no manifest,
+ * --workstream override against multi-source). Per-source
  * errors (frontmatter parse, edge ref, target name collision) leave
  * the failing source's `errors` array populated and that source's
  * counts at zero; siblings still attempt their own import.
@@ -2790,6 +3151,11 @@ interface CreateWorkspaceOptions {
     backend?: VcsBackendName | VcsBackend;
     /** Optional ref to base the workspace on. Backend-specific. */
     parentRef?: string;
+    /** INTERNAL. When false, suppress the `workspace create` system
+     *  event. Used by `recreateWorkspace` so the audit trail records
+     *  ONE atomic `workspace recreate` line instead of separate
+     *  free + create entries. Defaults to true. */
+    _suppressEvent?: boolean;
 }
 /**
  * Create a fresh workspace for an agent. Allocates the on-disk
@@ -2806,6 +3172,12 @@ interface FreeWorkspaceOptions {
     /** If true, attempt to commit pending changes before tearing down.
      *  Backend-specific; see VcsBackend.freeWorkspace. */
     commit?: boolean;
+    /** INTERNAL. When false, suppress the `workspace free` system
+     *  event AND skip the pre-mutation snapshot capture. Used by
+     *  `recreateWorkspace` so the audit trail records ONE atomic
+     *  `workspace recreate` line and one snapshot for the whole
+     *  free+create cycle. Defaults to true. */
+    _suppressEvent?: boolean;
 }
 interface FreeWorkspaceResult {
     /** The committed ref, when `commit` was true and there was something
@@ -2824,6 +3196,67 @@ interface FreeWorkspaceResult {
 declare function freeWorkspace(db: Db, agent: string, opts: FreeWorkspaceOptions & {
     workstream: string;
 }): Promise<FreeWorkspaceResult>;
+interface RecreateWorkspaceOptions {
+    /** Same as createWorkspace; defaults to cwd. */
+    projectRoot?: string;
+    /** Same as createWorkspace; if undefined the previous backend is
+     *  reused (auto-detection re-runs only when --backend was passed). */
+    backend?: VcsBackendName | VcsBackend;
+    /** Same as createWorkspace; if undefined the new workspace bases on
+     *  the backend's current head (for git/jj/sl: the project's main),
+     *  which is the whole point of the verb. */
+    parentRef?: string;
+    /** When true, skip the dirty-check refusal and discard any
+     *  uncommitted changes in the existing workspace. The lossy escape
+     *  hatch — mirrors the implicit semantics of `mu workspace free`
+     *  without --commit. */
+    force?: boolean;
+}
+interface RecreateWorkspaceResult {
+    /** The freshly-created workspace row (the previous row is already
+     *  gone by the time we return). */
+    workspace: WorkspaceRow;
+    /** parent_ref of the WORKSPACE BEFORE recreate, so callers (and the
+     *  CLI's success message) can show "bumped from <old> -> <new>". */
+    previousParentRef: string | null;
+}
+/**
+ * Free + create in one atomic-ish verb. The whole point: between
+ * waves the operator wants the SAME agent name with a fresh workspace
+ * pinned to current main; doing `free` then `create` manually was the
+ * dogfood-painful pattern (mufeedback note add_mu_workspace_recreate_free_create).
+ *
+ * Behaviour:
+ *   - Refuses with WorkspaceDirtyError if the existing workspace has
+ *     uncommitted changes (git/sl), UNLESS `force: true` is passed
+ *     (lossy escape hatch). jj is always-snapshotted so dirty is never
+ *     an issue; `none` has no VCS to consult so it never refuses.
+ *   - Reuses the SAME backend the previous workspace had unless
+ *     `backend` is explicitly overridden — a between-wave refresh
+ *     should not silently swap from git to none because the operator
+ *     happened to cd into a non-VCS dir. The override path matches
+ *     `mu workspace create --backend ...` semantics.
+ *   - Emits ONE `workspace recreate <agent>` event (with both old and
+ *     new parent_ref in the payload) instead of separate free + create
+ *     events. One pre-mutation snapshot is captured under the same
+ *     label so the undo trail shows one step.
+ *
+ * Throws:
+ *   - WorkspaceNotFoundError    — no row for this (agent, workstream).
+ *   - AgentNotFoundError        — propagated from createWorkspace's
+ *                                 typed agent check (the agent row
+ *                                 was deleted between the lookup and
+ *                                 the re-INSERT; vanishingly rare).
+ *   - WorkspaceDirtyError       — dirty + !force.
+ *   - any backend-level Error   — free or create failed.
+ *
+ * On a free-side failure the row + on-disk dir are best-effort gone;
+ * on a create-side failure we surface the create error and the row is
+ * already deleted (the operator can re-run `mu workspace create`).
+ */
+declare function recreateWorkspace(db: Db, agent: string, opts: RecreateWorkspaceOptions & {
+    workstream: string;
+}): Promise<RecreateWorkspaceResult>;
 
 type LogKind = "message" | "event" | "broadcast" | string;
 interface LogRow {
@@ -3127,4 +3560,4 @@ declare function deleteSnapshot(db: Db, snapshotId: number): DeleteSnapshotResul
  *  the file is missing. Useful for `mu snapshot list --json` output. */
 declare function snapshotFileSize(snapshot: SnapshotRow): number | null;
 
-export { type AddNoteOptions, type AddTaskOptions, type AddToArchiveResult, type AdoptAgentOptions, type AdoptAgentResult, AgentDiedOnSpawnError, AgentExistsError, AgentNotFoundError, AgentNotInWorkstreamError, type AgentRow, type AgentStatus, type AppendLogOptions, type Archive, ArchiveAlreadyExistsError, ArchiveLabelInvalidError, ArchiveNotFoundError, type ArchiveSearchHit, type ArchiveSourceSummary, type ArchiveSummary, type ArchivedTaskRow, type BlockEdgeResult, CURRENT_SCHEMA_VERSION, type CaptureOptions, type CaptureSnapshotResult, type ClaimResult, type ClaimTaskOptions, ClaimerNotRegisteredError, type CloseAgentOptions, type CloseAgentResult, CrossWorkstreamEdgeError, CycleError, type Db, type DeleteSnapshotResult, type DeleteTaskResult, type DestroyResult, type DetectedStatus, EXPECTED_TABLES, type EvidenceOption, type ExportArchiveOptions, type ExportArchiveResult, type ExportManifest, type ExportResult, type ExportSource, type ExportSourceManifest, type ExportTaskEntry, type ExportWorkstreamOptions, type FreeAgentResult, HomeDirAsProjectRootError, type IdFromTitleResult, ImportBucketInvalidError, type ImportBucketOptions, type ImportBucketResult, ImportEdgeRefMissingError, ImportFrontmatterParseError, ImportLegacyLayoutError, type ImportSourceResult, type InsertAgentInput, LegacyExportLayoutError, type ListArchivedTasksOptions, type ListLiveAgentsOptions, type ListLogsOptions, type ListReadyOptions, type ListSnapshotsOptions, type ListTasksOptions, type LiveAgentsView, type LogKind, type LogRow, type NewSessionOptions, type NewWindowOptions, type OpenDbOptions, PANE_ID_RE, PaneNotFoundError, type PruneMode, type PruneOptions, PruneOptionsInvalidError, type PruneResult, type ReconcileMode, type ReconcileOptions, type ReconcileReport, type RejectDeferOptions, type RejectDeferResult, type ReleaseResult, type ReleaseTaskOptions, type RemoveBlockEdgeResult, type RemoveFromArchiveResult, type RenderBucketInput, type RenderBucketResult, type ReparentTaskResult, type RestoreSnapshotResult, STATUSES_TERMINAL_OR_PARKED, STATUS_EMOJI, SchemaTooOldError, type SearchArchivesOptions, type SearchTasksOptions, type SendOptions, type SetStatusResult, type SlugifyResult, SnapshotFileMissingError, SnapshotNotFoundError, type SnapshotRow, SnapshotVersionMismatchError, type SpawnAgentOptions, type SplitWindowOptions, type StrandedWorkspaceOrphan, TASK_STATUSES, TASK_STATUS_LIST, TaskAlreadyOwnedError, type TaskEdgeWithStatus, type TaskEdges, type TaskEdgesWithStatus, TaskExistsError, TaskHasOpenDependentsError, TaskNotFoundError, TaskNotInWorkstreamError, type TaskNoteRow, type TaskRow, type TaskStatus, type TaskWaitOptions, type TaskWaitRef, type TaskWaitResult, type TaskWaitTaskState, TmuxError, type TmuxExecResult, type TmuxExecutor, type TmuxPane, type TmuxSession, type TmuxWindow, type Track, type UpdateTaskOptions, type UpdateTaskResult, type VcsBackend, type VcsBackendName, type CreateWorkspaceOptions$1 as VcsCreateWorkspaceOptions, type CreateWorkspaceResult as VcsCreateWorkspaceResult, type FreeWorkspaceOptions$1 as VcsFreeWorkspaceOptions, type FreeWorkspaceResult$1 as VcsFreeWorkspaceResult, type CreateWorkspaceOptions as WorkspaceCreateOptions, WorkspaceExistsError, type WorkspaceFailure, type FreeWorkspaceOptions as WorkspaceFreeOptions, type FreeWorkspaceResult as WorkspaceFreeResult, WorkspaceNotFoundError, type WorkspaceOrphan, WorkspacePathNotEmptyError, WorkspacePreservedError, type WorkspaceRow, WorkstreamAlreadyExistsError, WorkstreamNameInvalidError, type WorkstreamOptions, type WorkstreamSummary, addBlockEdge, addNote, addTask, addToArchive, adoptAgent, appendLog, assertValidPaneId, backendByName, capturePane, captureSnapshot, claimTask, closeAgent, closeTask, composeAgentTitle, createArchive, createWorkspace, currentAgentName, currentPaneTitle, decorateWithStaleness, defaultDbPath, defaultSendDelayMs, defaultSpawnLivenessMs, defaultStateDir, deferTask, deleteAgent, deleteArchive, deleteSnapshot, deleteTask, destroyWorkstream, detectBackend, detectPiStatus, emitEvent, ensureWorkstream, ensureWorkstreamStateDir, exportArchive, exportSourceForWorkstream, exportSourcesForArchive, exportWorkstream, extractTail, freeAgent, freeWorkspace, gcMaxAgeDays, gcMaxCount, gcSnapshots, getAgent, getAgentByPane, getArchive, getParallelTracks, getPrerequisites, getTask, getTaskEdges, getTaskEdgesWithStatus, getWaitPollCount, getWorkspaceForAgent, gitBackend, idFromTitle, idFromTitleVerbose, importBucket, insertAgent, isStaleVersion, isTaskStatus, isValidAgentName, isValidArchiveLabel, isValidPaneId, isValidTaskId, isValidWorkstreamName, jjBackend, killPane, killSession, latestSeq, listAgents, listAllOrphanWorkspaces, listArchivedTasks, listArchives, listBlocked, listGoals, listInProgress, listLiveAgents, listLogs, listNotes, listPanes, listPanesInSession, listReady, listRecentClosed, listSessions, listSnapshots, listTasks, listTasksByOwner, listWindows, listWorkspaceOrphans, listWorkspaces, listWorkstreams, newSession, newSessionWithPane, newWindow, noneBackend, openDb, openTask, paneExists, parseAgentNameFromTitle, pruneSnapshots, readAgent, reconcile, refreshAgentTitle, rejectTask, releaseTask, removeBlockEdge, removeFromArchive, renderToBucket, reparentTask, resetSleep, resetTmuxExecutor, resetWaitPollCount, resolveActorIdentity, resolveCliCommand, restoreSnapshot, searchArchives, searchTasks, selectLayout, sendToAgent, sendToPane, sessionExists, setPaneTitle, setSleepForTests, setTaskStatus, setTmuxExecutor, setWaitSleepForTests, setWaitStuckWarnForTests, slBackend, sleep, slugifyTitle, slugifyTitleVerbose, snapshotFileSize, snapshotsDir, spawnAgent, splitWindow, summarizeWorkstream, tmux$1 as tmux, updateAgentStatus, updateTask, waitForTasks, workspacePath, workspacesRoot, workstreamStateDir };
+export { type AddNoteOptions, type AddTaskOptions, type AddToArchiveResult, type AdoptAgentOptions, type AdoptAgentResult, AgentDiedOnSpawnError, AgentExistsError, AgentNotFoundError, AgentNotInWorkstreamError, type AgentRow, AgentSpawnCliNotFoundError, AgentSpawnStartupError, type AgentStatus, type AppendLogOptions, type Archive, ArchiveAlreadyExistsError, ArchiveLabelInvalidError, ArchiveNotFoundError, type ArchiveSearchHit, type ArchiveSourceSummary, type ArchiveSummary, type ArchivedTaskRow, type BlockEdgeResult, CURRENT_SCHEMA_VERSION, type CaptureOptions, type CaptureSnapshotResult, type ClaimResult, type ClaimTaskOptions, ClaimerNotRegisteredError, type CloseAgentOptions, type CloseAgentResult, type CommandResolutionResult, type CommandResolver, CrossWorkstreamEdgeError, CycleError, type Db, type DeleteSnapshotResult, type DeleteTaskResult, type DestroyResult, type DetectedStatus, EXPECTED_TABLES, type EvidenceOption, type ExportArchiveOptions, type ExportArchiveResult, type ExportManifest, type ExportResult, type ExportSource, type ExportSourceManifest, type ExportTaskEntry, type ExportWorkstreamOptions, type FreeAgentResult, HomeDirAsProjectRootError, type IdFromTitleResult, ImportBucketInvalidError, type ImportBucketOptions, type ImportBucketResult, ImportEdgeRefMissingError, ImportFrontmatterParseError, type ImportSourceResult, type InsertAgentInput, type KickAgentOptions, type KickAgentResult, type KickProcessExecutor, type KickSignal, type ListArchivedTasksOptions, type ListLiveAgentsOptions, type ListLogsOptions, type ListNotesOptions, type ListReadyOptions, type ListSnapshotsOptions, type ListTasksOptions, type LiveAgentsView, type LogKind, type LogRow, type NewSessionOptions, type NewWindowOptions, NoForegroundProcessError, type OpenDbOptions, PANE_ID_RE, PaneNotFoundError, type PruneMode, type PruneOptions, PruneOptionsInvalidError, type PruneResult, type ReconcileMode, type ReconcileOptions, type ReconcileReport, type RejectDeferOptions, type RejectDeferResult, type ReleaseResult, type ReleaseTaskOptions, type RemoveBlockEdgeResult, type RemoveFromArchiveResult, type RenderBucketInput, type RenderBucketResult, type ReparentTaskResult, type RestoreSnapshotResult, STATUSES_TERMINAL_OR_PARKED, STATUS_EMOJI, SchemaTooOldError, type SearchArchivesOptions, type SearchTasksOptions, type SendOptions, type SetStatusResult, type SlugifyResult, SnapshotFileMissingError, SnapshotNotFoundError, type SnapshotRow, SnapshotVersionMismatchError, type SpawnAgentOptions, type SplitWindowOptions, type StrandedWorkspaceOrphan, TASK_STATUSES, TASK_STATUS_LIST, TaskAlreadyOwnedError, type TaskEdgeWithStatus, type TaskEdges, type TaskEdgesWithStatus, TaskExistsError, TaskHasOpenDependentsError, TaskNotFoundError, TaskNotInWorkstreamError, type TaskNoteRow, type TaskRow, type TaskStatus, type TaskWaitOptions, type TaskWaitRef, type TaskWaitResult, type TaskWaitTaskState, TmuxError, type TmuxExecResult, type TmuxExecutor, type TmuxPane, type TmuxSession, type TmuxWindow, type Track, type UpdateTaskOptions, type UpdateTaskResult, type VcsBackend, type VcsBackendName, type CreateWorkspaceOptions$1 as VcsCreateWorkspaceOptions, type CreateWorkspaceResult as VcsCreateWorkspaceResult, type FreeWorkspaceOptions$1 as VcsFreeWorkspaceOptions, type FreeWorkspaceResult$1 as VcsFreeWorkspaceResult, type CreateWorkspaceOptions as WorkspaceCreateOptions, WorkspaceExistsError, type WorkspaceFailure, type FreeWorkspaceOptions as WorkspaceFreeOptions, type FreeWorkspaceResult as WorkspaceFreeResult, WorkspaceNotFoundError, type WorkspaceOrphan, WorkspacePathNotEmptyError, WorkspacePreservedError, type RecreateWorkspaceOptions as WorkspaceRecreateOptions, type RecreateWorkspaceResult as WorkspaceRecreateResult, type WorkspaceRow, WorkstreamAlreadyExistsError, WorkstreamNameInvalidError, type WorkstreamOptions, type WorkstreamSummary, addBlockEdge, addNote, addTask, addToArchive, adoptAgent, appendLog, assertValidPaneId, backendByName, capturePane, captureSnapshot, checkCommandResolvable, claimTask, closeAgent, closeTask, composeAgentTitle, createArchive, createWorkspace, currentAgentName, currentPaneTitle, decorateWithStaleness, defaultDbPath, defaultSendDelayMs, defaultSpawnLivenessMs, defaultStateDir, deferTask, deleteAgent, deleteArchive, deleteSnapshot, deleteTask, destroyWorkstream, detectBackend, detectPiStatus, emitEvent, ensureWorkstream, ensureWorkstreamStateDir, envVarNameForCli, exportArchive, exportSourceForWorkstream, exportSourcesForArchive, exportWorkstream, extractTail, foregroundPgid, freeAgent, freeWorkspace, gcMaxAgeDays, gcMaxCount, gcSnapshots, getAgent, getAgentByPane, getArchive, getParallelTracks, getPrerequisites, getTask, getTaskEdges, getTaskEdgesWithStatus, getWaitPollCount, getWorkspaceForAgent, gitBackend, idFromTitle, idFromTitleVerbose, importBucket, insertAgent, isKickSignal, isStaleVersion, isTaskStatus, isValidAgentName, isValidArchiveLabel, isValidPaneId, isValidTaskId, isValidWorkstreamName, jjBackend, kickAgent, killPane, killSession, latestSeq, listAgents, listAllOrphanWorkspaces, listArchivedTasks, listArchives, listBlocked, listGoals, listInProgress, listLiveAgents, listLogs, listNotes, listPanes, listPanesInSession, listReady, listRecentClosed, listSessions, listSnapshots, listTasks, listTasksByOwner, listWindows, listWorkspaceOrphans, listWorkspaces, listWorkstreams, newSession, newSessionWithPane, newWindow, noneBackend, openDb, openTask, paneExists, paneTTY, parseAgentNameFromTitle, parsePsTtyOutput, pruneSnapshots, readAgent, reconcile, recreateWorkspace, refreshAgentTitle, rejectTask, releaseTask, removeBlockEdge, removeFromArchive, renderToBucket, reparentTask, resetCommandResolverForTests, resetKickProcessExecutor, resetSleep, resetTmuxExecutor, resetWaitPollCount, resolveActorIdentity, resolveCliCommand, resolveCliCommandWithSource, restoreSnapshot, searchArchives, searchTasks, selectLayout, sendToAgent, sendToPane, sessionExists, setCommandResolverForTests, setKickProcessExecutor, setPaneTitle, setSleepForTests, setTaskStatus, setTmuxExecutor, setWaitSleepForTests, setWaitStuckWarnForTests, slBackend, sleep, slugifyTitle, slugifyTitleVerbose, snapshotFileSize, snapshotsDir, spawnAgent, splitWindow, summarizeWorkstream, tmux$1 as tmux, updateAgentStatus, updateTask, waitForTasks, workspacePath, workspacesRoot, workstreamStateDir };