@mu-crew/mu 3.13.3 → 4.0.0

package/dist/index.js

@@ -1,17 +1,155 @@
 import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
 import {
-  NothingToUndoError,
-  UndoGroupNotFoundError,
-  UndoSupersededError,
-  listRecentGroups,
-  mostRecentGroup,
-  planUndo,
-  priorFieldValue,
-  resolveGroupId,
-  undoGroup
-} from "./chunk-G434JKV2.js";
+  STALLED_TOOL_MS,
+  loadDashboard
+} from "./chunk-AW2NONYU.js";
 import {
   AGENT_STATE_GLYPH,
+  DEFAULT_CTL_STUCK_AFTER_MS,
+  DEFAULT_NEXT_CAP,
+  DEFAULT_STUCK_AFTER_MS,
+  DRIFT_REPORT_CAP,
+  DbInsideSyncDirError,
+  DriftDetectedError,
+  GLYPH,
+  HazardFailError,
+  MAX_NEXT_CAP,
+  MU_SHIM_MARKER,
+  NextArgError,
+  RebuildTargetExistsError,
+  RebuildTargetIsSourceError,
+  RemoteCollectError,
+  RemoteCollectUnsupportedError,
+  WAIT_HEARTBEAT_CAP_MS,
+  WAIT_REGEX_MAX_LEN,
+  WAIT_TEXT_MAX,
+  WaitNothingError,
+  WaitRefError,
+  WaitRegexError,
+  WaitResumeNotFoundError,
+  WaveNotFoundError,
+  agentStateGlyph,
+  callerWorkstreams,
+  checkCaseCollisions,
+  checkCheapDriftInvariant,
+  checkDbInsideSyncDir,
+  checkDrift,
+  checkFleetHazards,
+  checkNetworkMount,
+  checkRegexGrammar,
+  classifyFsType,
+  collectRef,
+  collectRemoteAgent,
+  compileTextMatcher,
+  ctlAgentHooks,
+  driftRemediation,
+  executeNext,
+  findCaseCollisions,
+  formatDriftRecord,
+  getActionReceipt,
+  isPathInside,
+  loadResume,
+  migratePi,
+  probeFilesystem,
+  rebuildInto,
+  releaseStall,
+  releaseStallHandler,
+  reserveActionReceipt,
+  saveResume,
+  skillDirDigest,
+  stateSnapshot,
+  steerStall,
+  steerStallHandler,
+  steerText,
+  transitionActionReceipt,
+  waitForEvents,
+  waitWithActions
+} from "./chunk-5HECDBK3.js";
+import {
+  COURSE_CHECK_AGE_MS,
+  COURSE_CHECK_CLOSED,
+  DelegateCallConflictError,
+  DelegateNotFoundError,
+  DelegateStateError,
+  FRONTIER_CLOSED_PER_NODE,
+  FRONTIER_MAX_DEPTH,
+  FRONTIER_MAX_NODES,
+  HumanNeededInvalidError,
+  KNOWN_INTENTS,
+  KNOWN_VERBS,
+  OpEntityNotSyncedError,
+  OpKeyMalformedError,
+  PEER_SHORT_LEN,
+  PEER_STALE_MS,
+  SyncDirForeignError,
+  SyncPeerNotFoundError,
+  SyncPeerRefAmbiguousError,
+  SyncSourceNotFoundError,
+  SyncSourceTooNewError,
+  TaskAutoArgError,
+  TaskAutoRefusedError,
+  TaskBriefMissingError,
+  UnguardedMoveError,
+  ambientFlush,
+  ambientIngest,
+  ambientSyncPass,
+  applyIncomingOp,
+  applyOp,
+  applyOps,
+  assertSyncDirV2,
+  attemptName,
+  authorisedReady,
+  authorizeTasks,
+  autoPermitted,
+  buildTaskBrief,
+  capPlan,
+  computeNext,
+  computeNotices,
+  courseCheckHint,
+  currentCallers,
+  discoverPeers,
+  finishDelegate,
+  flushSegment,
+  getAutoConfig,
+  getDelegateCall,
+  getWatermark,
+  ingestFromDb,
+  ingestSegment,
+  listDelegates,
+  listDelegatesOf,
+  loadOpenTaskFrontier,
+  localMachineId,
+  markDelegate,
+  opSubject,
+  openBlockersClosure,
+  openHumanNeeds,
+  parseOpKey,
+  parseVerdict,
+  peerStatuses,
+  pendingAttempts,
+  planAttempt,
+  readManifest,
+  recordHumanNeeded,
+  registerDelegateCall,
+  renderArgv,
+  renderFrontierLines,
+  renderOp,
+  renderOpLine,
+  renderPlan,
+  repairPeer,
+  reserveAttempt,
+  resetWatermark,
+  resolvePeerRef,
+  segmentLineCount,
+  segmentPath,
+  setWatermark,
+  syncDir,
+  syncEnabled,
+  syncPass,
+  verdictTally,
+  verifyAgainstManifest
+} from "./chunk-GQNHIPJN.js";
+import {
   AgentAbortNeedsCtlError,
   AgentAbortTimeoutError,
   AgentBusyError,
@@ -21,319 +159,399 @@ import {
   AgentExistsError,
   AgentExtensionOutdatedError,
   AgentFreshNeedsCtlError,
+  AgentLockBusyError,
   AgentNameExhaustedError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
   AgentPaneDeadError,
+  AgentPaneStillAliveError,
+  AgentReplacedError,
+  AgentRestartedError,
   AgentSendIndeterminateError,
+  AgentSendUnsupportedError,
   AgentSlashCommandUnsupportedError,
   AgentSpawnCliNotFoundError,
   AgentSpawnStartupError,
+  CAPTURE_TRIGGER_DDL,
+  CAPTURE_VERSION,
+  CURRENT_SCHEMA_VERSION,
   ClaimerNotRegisteredError,
+  CloseNeedsEvidenceError,
   CrossWorkstreamEdgeError,
   CycleError,
-  DRIFT_REPORT_CAP,
-  DriftDetectedError,
-  GLYPH,
+  DEFAULT_SUBSTATE,
+  DELEGATE_TOKEN,
+  EXPECTED_TABLES,
   GroupIdAmbiguousError,
-  HazardFailError,
-  HomeDirAsProjectRootError,
+  GroupNotFoundError,
+  HOST_ENV_KEYS,
+  HOST_PLACEHOLDERS,
+  HlcOverflowError,
+  HlcParseError,
+  HostChannelBusyError,
+  HostCheckFailedError,
+  HostExistsError,
+  HostInUseError,
+  HostNotFoundError,
+  HostProfileError,
+  HostSpawnUnsupportedError,
+  HostTemplateError,
+  HumanTaskError,
   InvalidSubstateError,
-  KNOWN_INTENTS,
-  KNOWN_VERBS,
-  LinkConflictError,
   LogKindReservedError,
-  MU_SHIM_MARKER,
+  MACHINE_LOCAL_ENTITIES,
+  MACHINE_LOCAL_TABLES,
+  MachineIdentityMissingError,
   MuxError,
-  NoForegroundProcessError,
   NoMultiplexerError,
   PANE_ID_RE,
+  PORTABLE_TABLES,
   PaneNotFoundError,
-  PaneNotInSessionError,
-  ReaperDetectedDuringWaitError,
-  RebuildTargetExistsError,
-  RebuildTargetIsSourceError,
-  StallDetectedDuringWaitError,
+  RemoteCloseRefusedError,
+  RemotePrepareError,
+  RemoteRecoveryRefusedError,
+  RevisionMismatchError,
+  SEGMENT_FORMAT_VERSION,
+  SEGMENT_READ_VERSIONS,
+  SYNCED_ENTITIES,
+  SchemaTooNewError,
+  SchemaTooOldError,
+  SpawnAttemptBusyError,
+  SpawnAttemptFailedError,
+  SpawnAttemptGuardError,
+  SpawnReceiptConflictError,
+  SpawnTaskStateError,
+  SpawnTrustDialogError,
+  SqliteTooOldError,
   SubstateReasonRequiredError,
+  TASK_KINDS,
+  TASK_STATUSES,
+  TASK_STATUS_LIST,
+  TASK_SUBSTATES,
+  TASK_SUBSTATE_ROWS,
   TaskAlreadyOwnedError,
-  TaskClaimStaleWorkspaceError,
   TaskExistsError,
+  TaskHasOpenBlockersError,
   TaskIdInvalidError,
   TaskInTriageError,
   TaskNotFoundError,
   TaskNotInWorkstreamError,
+  TaskNoteRangeError,
   TaskParkStateError,
   TaskParkedError,
   TaskTitleSlugEmptyError,
   TmuxError,
   UNKNOWN_REASON,
-  WORKSPACE_STALE_THRESHOLD,
-  WorkspaceConflictError,
-  WorkspaceDirtyError,
-  WorkspaceExistsError,
-  WorkspaceNotFoundError,
-  WorkspaceOwnerBusyError,
-  WorkspacePathNotEmptyError,
-  WorkspacePreservedError,
-  WorkspaceVcsRequiredError,
+  WAIT_REF_KINDS,
+  WAIT_REGISTRATION_MAX_REFS,
+  WAIT_REGISTRATION_STATES,
+  WaitRegistrationError,
   WorkstreamExistsError,
+  WorkstreamHasAgentsError,
   WorkstreamNameInvalidError,
   WorkstreamNameReservedError,
+  WorkstreamNotFoundError,
+  WorkstreamPanesLiveError,
+  WorkstreamRevisionMismatchError,
+  WorkstreamSessionLiveError,
+  WorkstreamTornDownError,
+  WorktreeBranchExistsError,
+  WorktreeDirtyError,
+  WorktreeHeldError,
+  WorktreePathNotEmptyError,
+  WorktreeVcsRequiredError,
   abortAgent,
   acceptTask,
   activeMux,
   addBlockEdge,
+  addHost,
   addNote,
   addTask,
-  adoptAgent,
+  addTasks,
+  admitHostChannel,
   agentKey,
-  agentStateGlyph,
-  agentStateHistogram,
+  agentRevision,
   appendLog,
+  assertRevision,
   assertValidPaneId,
-  awaitPaneQuiescence,
-  backendByName,
-  capturePane,
-  checkCaseCollisions,
-  checkCheapDriftInvariant,
+  beginWait,
+  bindHostChannel,
+  capture,
+  captureTriggersCurrent,
   checkCommandResolvable,
-  checkDbInsideSyncDir,
-  checkDrift,
-  checkFleetHazards,
-  checkNetworkMount,
+  checkHost,
   claimTask,
-  classifyFsType,
   closeAgent,
+  closeRemoteWorktree,
   closeTask,
-  composeAgentTitle,
-  countProblems,
-  createWorkspace,
+  closedToken,
+  compareHlc,
+  compareStrings,
+  createWorktree,
   ctlRuntimeState,
-  currentAgentName,
-  currentPaneTitle,
-  decorateWithDirty,
-  decorateWithStaleness,
-  defaultSendDelayMs,
-  defaultSendReadinessMs,
+  currentOpContext,
+  cursorKey,
+  defaultDbPath,
   defaultSpawnLivenessMs,
   deleteAgent,
   deleteTask,
-  detectBackend,
   detectMux,
-  driftRemediation,
   emitEvent,
+  endWait,
   ensureWorkstream,
   envVarNameForCli,
+  expandHostTemplate,
   expectsCtl,
-  findCaseCollisions,
-  foregroundPgid,
-  formatDriftRecord,
-  freeWorkspace,
+  forgetWorktree,
+  formatHlc,
+  formatPair,
   getAgent,
   getAgentByPane,
-  getParallelTracks,
+  getHost,
   getPrerequisites,
+  getRemoteRecovery,
   getTask,
   getTaskEdges,
   getTaskEdgesWithStatus,
-  getWaitPollCount,
-  getWorkspaceForAgent,
-  getWorkspaceStaleness,
-  gitBackend,
-  hasWorkMarker,
+  getWorktreeAt,
+  getWorktreeFor,
+  hostEnvWords,
+  hostStarter,
   idFromTitle,
   idFromTitleVerbose,
   insertAgent,
-  inspectLinks,
+  installCapture,
   interruptAgent,
-  isKickSignal,
-  isPathInside,
+  isConsumed,
+  isTaskStatus,
   isValidAgentName,
+  isValidPair,
   isValidPaneId,
   isValidTaskId,
   isValidWorkstreamName,
-  isWorkspaceStale,
-  jjBackend,
-  kickAgent,
   killPane,
   killSession,
   latestSeq,
-  linkPi,
-  linkSkill,
   listAgents,
-  listAllOrphanWorkspaces,
   listBlocked,
   listGoals,
+  listHostChannels,
+  listHosts,
   listInProgress,
   listLiveAgents,
   listLogs,
   listNotes,
   listPanes,
-  listPanesInSession,
   listReady,
   listRecentClosed,
-  listSessions,
+  listRemoteRecoveries,
   listTasks,
   listTasksByOwner,
-  listWindows,
-  listWorkspaceOrphans,
-  listWorkspaces,
   listWorkstreams,
-  loadDoctorChecks,
-  loadDoctorSummary,
-  loadFullDag,
-  loadWorkstreamSnapshot,
-  loadWorkstreamSnapshotFast,
-  loadWorkstreamSnapshotSlow,
-  mergeSnapshotFastSlow,
+  listWorktrees,
+  locksDir,
+  mapLegacyStatus,
   murmurAvailable,
   muxByName,
   mux_exports,
-  newSession,
-  newSessionWithPane,
-  newWindow,
-  noneBackend,
-  opSubject,
+  nextHlc,
+  observationFromReading,
+  observeAgentStates,
+  openDb,
   openTask,
-  paneExists,
-  paneTTY,
+  paneAlive,
   parkTask,
-  parseAgentNameFromTitle,
-  parseOpKey,
-  parsePsTtyOutput,
-  probeFilesystem,
+  parseHlc,
+  previewClose,
   readAgent,
   readAgentStates,
-  rebuildInto,
+  readCursors,
+  readFileLockMeta,
+  readLiveAgents,
+  readWaitRegistration,
+  receiveHlc,
+  reclaimWorktreePath,
   reconcile,
-  refreshAgentTitle,
+  recordCursors,
+  recoveriesFor,
+  registerOwnedWait,
+  registerWorktree,
+  releaseHostChannel,
+  releaseHostChannelsForAgent,
   releaseTask,
-  remediationParagraph,
+  releaseWorktree,
   removeBlockEdge,
-  renderForest,
-  renderOp,
-  renderOpLine,
-  renderTaskTree,
+  removeHost,
+  removeWorktree,
   reparentTask,
+  reserveHostChannel,
   resetCommandResolverForTests,
-  resetKickProcessExecutor,
   resetMux,
   resetSleep,
   resetTmuxExecutor,
-  resetWaitPollCount,
   resolveActorIdentity,
   resolveCliCommand,
   resolveCliCommandWithSource,
-  roiBucket,
-  selectLayout,
+  resolvePair,
+  runHostTemplate,
+  selectRemoteRecovery,
+  selectTaskNotes,
   sendToAgent,
-  sendToPane,
   sendViaTransport,
-  sessionExists,
   setCommandResolverForTests,
-  setKickProcessExecutor,
   setMuxForTests,
-  setPaneTitle,
   setSleepForTests,
   setTaskStatus,
   setTmuxExecutor,
-  setWaitSleepForTests,
-  setWaitStuckWarnForTests,
-  slBackend,
+  settledCloseInput,
   sleep,
   slugifyTitle,
   slugifyTitleVerbose,
   spawnAgent,
-  splitWindow,
-  summarizeOwnedTasks,
+  spawnAutoAttempt,
+  spawnForTask,
   summarizeWorkstream,
+  taskRevision,
+  taskRevisions,
   teardownWorkstream,
   tmuxBackend,
   tmux_exports,
   unparkTask,
   updateTask,
-  waitForTasks,
-  workspacePath,
-  workspacesRoot,
-  yankCommandForCheck
-} from "./chunk-KUGUFBWH.js";
-import {
-  CAPTURE_TRIGGER_DDL,
-  CURRENT_SCHEMA_VERSION,
-  DEFAULT_SUBSTATE,
-  EXPECTED_TABLES,
-  HlcOverflowError,
-  HlcParseError,
-  MACHINE_LOCAL_ENTITIES,
-  MACHINE_LOCAL_TABLES,
-  MachineIdentityMissingError,
-  OP_CTX_DDL,
-  OpEntityNotSyncedError,
-  OpKeyMalformedError,
-  PEER_SHORT_LEN,
-  PEER_STALE_MS,
-  PORTABLE_TABLES,
-  SEGMENT_FORMAT_VERSION,
-  SYNCED_ENTITIES,
-  SchemaTooNewError,
-  SchemaTooOldError,
-  SyncPeerNotFoundError,
-  SyncPeerRefAmbiguousError,
-  SyncSourceNotFoundError,
-  TASK_STATUSES,
-  TASK_STATUS_LIST,
-  TASK_SUBSTATES,
-  TASK_SUBSTATE_ROWS,
-  WorkstreamNotFoundError,
-  ambientFlush,
-  ambientIngest,
-  ambientSyncPass,
-  applyIncomingOp,
-  applyOp,
-  applyOps,
-  compareHlc,
-  currentOpContext,
-  defaultDbPath,
-  discoverPeers,
-  flushSegment,
-  formatHlc,
-  formatPair,
-  getWatermark,
-  ingestFromDb,
-  ingestSegment,
-  installCapture,
-  isTaskStatus,
-  isValidPair,
-  localMachineId,
-  locksDir,
-  mapLegacyStatus,
-  nextHlc,
-  openDb,
-  parseHlc,
-  peerStatuses,
-  readFileLockMeta,
-  readManifest,
-  receiveHlc,
-  repairPeer,
-  resetWatermark,
-  resolvePair,
-  resolvePeerRef,
-  segmentLineCount,
-  segmentPath,
-  setWatermark,
-  syncDir,
-  syncEnabled,
-  syncPass,
-  transportNextSteps,
-  verifyAgainstManifest,
+  upstreamRefs,
+  validateHostTemplate,
+  watchAgentRun,
+  withAgentLock,
   withCaptureSuppressed,
   withFileLock,
-  withOpContext
-} from "./chunk-45KQLMEL.js";
+  withHostChannel,
+  withOpContext,
+  workstreamRevision,
+  worktreePath,
+  worktreeState,
+  worktreesRoot
+} from "./chunk-S424D5EP.js";
 import {
   defaultStateDir
-} from "./chunk-WI6AWCMK.js";
-import "./chunk-3BARPJLY.js";
+} from "./chunk-PZ5GOCWH.js";
+
+// src/tracks.ts
+function getParallelTracks(db, workstream) {
+  const goals = listGoals(db, workstream).filter((g) => g.status !== "CLOSED");
+  if (goals.length === 0) return [];
+  const reach = db.prepare(
+    `WITH RECURSIVE
+         active_goals(id, local_id) AS (
+           SELECT g.id, g.local_id
+             FROM goals g
+             JOIN workstreams ws ON ws.id = g.workstream_id
+            WHERE ws.name = ?
+         ),
+         reach(goal_id, node_id) AS (
+           SELECT id, id FROM active_goals
+           UNION
+           SELECT r.goal_id, e.from_task_id
+             FROM reach r
+             JOIN task_edges e ON e.to_task_id = r.node_id
+         )
+       SELECT goal.local_id AS goal_id, node.local_id AS task_id,
+              node.status AS status, node.substate AS substate
+         FROM reach r
+         JOIN tasks goal ON goal.id = r.goal_id
+         JOIN tasks node ON node.id = r.node_id`
+  ).all(workstream);
+  const subgraphs = new Map(goals.map((goal) => [goal.name, /* @__PURE__ */ new Set()]));
+  const uf = new UnionFind(goals.map((goal) => goal.name));
+  const firstGoalByTask = /* @__PURE__ */ new Map();
+  const openSubstate = /* @__PURE__ */ new Map();
+  for (const row of reach) {
+    if (row.status !== "CLOSED") openSubstate.set(row.task_id, row.substate);
+    subgraphs.get(row.goal_id)?.add(row.task_id);
+    const firstGoal = firstGoalByTask.get(row.task_id);
+    if (firstGoal === void 0) firstGoalByTask.set(row.task_id, row.goal_id);
+    else uf.union(firstGoal, row.goal_id);
+  }
+  const componentTaskIds = /* @__PURE__ */ new Map();
+  const componentRoots = /* @__PURE__ */ new Map();
+  for (const goal of goals) {
+    const root = uf.find(goal.name);
+    let bucket = componentTaskIds.get(root);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      componentTaskIds.set(root, bucket);
+      componentRoots.set(root, []);
+    }
+    componentRoots.get(root)?.push(goal);
+    const sub = subgraphs.get(goal.name);
+    if (sub) {
+      for (const id of sub) bucket.add(id);
+    }
+  }
+  const readyIds = new Set(listReady(db, workstream).map((t) => t.name));
+  const tracks = [];
+  for (const [root, taskIds] of componentTaskIds) {
+    const trackRoots = componentRoots.get(root) ?? [];
+    let readyCount = 0;
+    let openCount = 0;
+    let parkedCount = 0;
+    for (const id of taskIds) {
+      if (readyIds.has(id)) readyCount++;
+      const sub = openSubstate.get(id);
+      if (sub === void 0) continue;
+      openCount++;
+      if (sub === "parked") parkedCount++;
+    }
+    const parked = openCount > 0 && parkedCount === openCount;
+    tracks.push({ roots: trackRoots, taskIds, readyCount, parked });
+  }
+  tracks.sort((a, b) => {
+    const an = a.roots[0]?.name ?? "";
+    const bn = b.roots[0]?.name ?? "";
+    return compareStrings(an, bn);
+  });
+  return tracks;
+}
+var UnionFind = class {
+  parent = /* @__PURE__ */ new Map();
+  rank = /* @__PURE__ */ new Map();
+  constructor(items) {
+    for (const item of items) {
+      this.parent.set(item, item);
+      this.rank.set(item, 0);
+    }
+  }
+  find(x) {
+    let root = x;
+    while (true) {
+      const next = this.parent.get(root);
+      if (next === void 0 || next === root) break;
+      root = next;
+    }
+    let curr = x;
+    while (curr !== root) {
+      const next = this.parent.get(curr);
+      if (next === void 0) break;
+      this.parent.set(curr, root);
+      curr = next;
+    }
+    return root;
+  }
+  union(a, b) {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    const rankA = this.rank.get(rootA) ?? 0;
+    const rankB = this.rank.get(rootB) ?? 0;
+    if (rankA < rankB) {
+      this.parent.set(rootA, rootB);
+    } else if (rankA > rankB) {
+      this.parent.set(rootB, rootA);
+    } else {
+      this.parent.set(rootB, rootA);
+      this.rank.set(rootA, rankA + 1);
+    }
+  }
+};
 export {
   AGENT_STATE_GLYPH,
   AgentAbortNeedsCtlError,
@@ -345,43 +563,71 @@ export {
   AgentExistsError,
   AgentExtensionOutdatedError,
   AgentFreshNeedsCtlError,
+  AgentLockBusyError,
   AgentNameExhaustedError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
   AgentPaneDeadError,
+  AgentPaneStillAliveError,
+  AgentReplacedError,
+  AgentRestartedError,
   AgentSendIndeterminateError,
+  AgentSendUnsupportedError,
   AgentSlashCommandUnsupportedError,
   AgentSpawnCliNotFoundError,
   AgentSpawnStartupError,
   CAPTURE_TRIGGER_DDL,
+  CAPTURE_VERSION,
+  COURSE_CHECK_AGE_MS,
+  COURSE_CHECK_CLOSED,
   CURRENT_SCHEMA_VERSION,
   ClaimerNotRegisteredError,
+  CloseNeedsEvidenceError,
   CrossWorkstreamEdgeError,
   CycleError,
+  DEFAULT_NEXT_CAP,
   DEFAULT_SUBSTATE,
+  DELEGATE_TOKEN,
   DRIFT_REPORT_CAP,
+  DbInsideSyncDirError,
+  DelegateCallConflictError,
+  DelegateNotFoundError,
+  DelegateStateError,
   DriftDetectedError,
   EXPECTED_TABLES,
+  FRONTIER_CLOSED_PER_NODE,
+  FRONTIER_MAX_DEPTH,
+  FRONTIER_MAX_NODES,
   GLYPH,
   GroupIdAmbiguousError,
+  GroupNotFoundError,
+  HOST_ENV_KEYS,
+  HOST_PLACEHOLDERS,
   HazardFailError,
   HlcOverflowError,
   HlcParseError,
-  HomeDirAsProjectRootError,
+  HostChannelBusyError,
+  HostCheckFailedError,
+  HostExistsError,
+  HostInUseError,
+  HostNotFoundError,
+  HostProfileError,
+  HostSpawnUnsupportedError,
+  HostTemplateError,
+  HumanNeededInvalidError,
+  HumanTaskError,
   InvalidSubstateError,
   KNOWN_INTENTS,
   KNOWN_VERBS,
-  LinkConflictError,
   LogKindReservedError,
   MACHINE_LOCAL_ENTITIES,
   MACHINE_LOCAL_TABLES,
+  MAX_NEXT_CAP,
   MU_SHIM_MARKER,
   MachineIdentityMissingError,
   MuxError,
-  NoForegroundProcessError,
+  NextArgError,
   NoMultiplexerError,
-  NothingToUndoError,
-  OP_CTX_DDL,
   OpEntityNotSyncedError,
   OpKeyMalformedError,
   PANE_ID_RE,
@@ -389,60 +635,95 @@ export {
   PEER_STALE_MS,
   PORTABLE_TABLES,
   PaneNotFoundError,
-  PaneNotInSessionError,
-  ReaperDetectedDuringWaitError,
   RebuildTargetExistsError,
   RebuildTargetIsSourceError,
+  RemoteCloseRefusedError,
+  RemoteCollectError,
+  RemoteCollectUnsupportedError,
+  RemotePrepareError,
+  RemoteRecoveryRefusedError,
+  RevisionMismatchError,
   SEGMENT_FORMAT_VERSION,
+  SEGMENT_READ_VERSIONS,
+  STALLED_TOOL_MS,
   SYNCED_ENTITIES,
   SchemaTooNewError,
   SchemaTooOldError,
-  StallDetectedDuringWaitError,
+  SpawnAttemptBusyError,
+  SpawnAttemptFailedError,
+  SpawnAttemptGuardError,
+  SpawnReceiptConflictError,
+  SpawnTaskStateError,
+  SpawnTrustDialogError,
+  SqliteTooOldError,
   SubstateReasonRequiredError,
+  SyncDirForeignError,
   SyncPeerNotFoundError,
   SyncPeerRefAmbiguousError,
   SyncSourceNotFoundError,
+  SyncSourceTooNewError,
+  TASK_KINDS,
   TASK_STATUSES,
   TASK_STATUS_LIST,
   TASK_SUBSTATES,
   TASK_SUBSTATE_ROWS,
   TaskAlreadyOwnedError,
-  TaskClaimStaleWorkspaceError,
+  TaskAutoArgError,
+  TaskAutoRefusedError,
+  TaskBriefMissingError,
   TaskExistsError,
+  TaskHasOpenBlockersError,
   TaskIdInvalidError,
   TaskInTriageError,
   TaskNotFoundError,
   TaskNotInWorkstreamError,
+  TaskNoteRangeError,
   TaskParkStateError,
   TaskParkedError,
   TaskTitleSlugEmptyError,
   TmuxError,
   UNKNOWN_REASON,
-  UndoGroupNotFoundError,
-  UndoSupersededError,
-  WORKSPACE_STALE_THRESHOLD,
-  WorkspaceConflictError,
-  WorkspaceDirtyError,
-  WorkspaceExistsError,
-  WorkspaceNotFoundError,
-  WorkspaceOwnerBusyError,
-  WorkspacePathNotEmptyError,
-  WorkspacePreservedError,
-  WorkspaceVcsRequiredError,
+  UnguardedMoveError,
+  DEFAULT_CTL_STUCK_AFTER_MS as WAIT_DEFAULT_CTL_STUCK_AFTER_MS,
+  DEFAULT_STUCK_AFTER_MS as WAIT_DEFAULT_STUCK_AFTER_MS,
+  WAIT_HEARTBEAT_CAP_MS,
+  WAIT_REF_KINDS,
+  WAIT_REGEX_MAX_LEN,
+  WAIT_REGISTRATION_MAX_REFS,
+  WAIT_REGISTRATION_STATES,
+  WAIT_TEXT_MAX,
+  WaitNothingError,
+  WaitRefError,
+  WaitRegexError,
+  WaitRegistrationError,
+  WaitResumeNotFoundError,
+  WaveNotFoundError,
   WorkstreamExistsError,
+  WorkstreamHasAgentsError,
   WorkstreamNameInvalidError,
   WorkstreamNameReservedError,
   WorkstreamNotFoundError,
+  WorkstreamPanesLiveError,
+  WorkstreamRevisionMismatchError,
+  WorkstreamSessionLiveError,
+  WorkstreamTornDownError,
+  WorktreeBranchExistsError,
+  WorktreeDirtyError,
+  WorktreeHeldError,
+  WorktreePathNotEmptyError,
+  WorktreeVcsRequiredError,
   abortAgent,
   acceptTask,
   activeMux,
   addBlockEdge,
+  addHost,
   addNote,
   addTask,
-  adoptAgent,
+  addTasks,
+  admitHostChannel,
   agentKey,
+  agentRevision,
   agentStateGlyph,
-  agentStateHistogram,
   ambientFlush,
   ambientIngest,
   ambientSyncPass,
@@ -450,75 +731,95 @@ export {
   applyIncomingOp,
   applyOp,
   applyOps,
+  assertRevision,
+  assertSyncDirV2,
   assertValidPaneId,
-  awaitPaneQuiescence,
-  backendByName,
-  capturePane,
+  attemptName,
+  authorisedReady,
+  authorizeTasks,
+  autoPermitted,
+  beginWait,
+  bindHostChannel,
+  buildTaskBrief,
+  callerWorkstreams,
+  capPlan,
+  capture,
+  captureTriggersCurrent,
   checkCaseCollisions,
   checkCheapDriftInvariant,
   checkCommandResolvable,
   checkDbInsideSyncDir,
   checkDrift,
   checkFleetHazards,
+  checkHost,
   checkNetworkMount,
+  checkRegexGrammar,
   claimTask,
   classifyFsType,
   closeAgent,
+  closeRemoteWorktree,
   closeTask,
+  closedToken,
+  collectRef,
+  collectRemoteAgent,
   compareHlc,
-  composeAgentTitle,
-  countProblems,
-  createWorkspace,
+  compileTextMatcher,
+  computeNext,
+  computeNotices,
+  courseCheckHint,
+  createWorktree,
+  ctlAgentHooks,
   ctlRuntimeState,
-  currentAgentName,
+  currentCallers,
   currentOpContext,
-  currentPaneTitle,
-  decorateWithDirty,
-  decorateWithStaleness,
+  cursorKey,
   defaultDbPath,
-  defaultSendDelayMs,
-  defaultSendReadinessMs,
   defaultSpawnLivenessMs,
   defaultStateDir,
   deleteAgent,
   deleteTask,
-  detectBackend,
   detectMux,
   discoverPeers,
   driftRemediation,
   emitEvent,
+  endWait,
   ensureWorkstream,
   envVarNameForCli,
+  executeNext,
+  expandHostTemplate,
   expectsCtl,
   findCaseCollisions,
+  finishDelegate,
   flushSegment,
-  foregroundPgid,
+  forgetWorktree,
   formatDriftRecord,
   formatHlc,
   formatPair,
-  freeWorkspace,
+  getActionReceipt,
   getAgent,
   getAgentByPane,
+  getAutoConfig,
+  getDelegateCall,
+  getHost,
   getParallelTracks,
   getPrerequisites,
+  getRemoteRecovery,
   getTask,
   getTaskEdges,
   getTaskEdgesWithStatus,
-  getWaitPollCount,
   getWatermark,
-  getWorkspaceForAgent,
-  getWorkspaceStaleness,
-  gitBackend,
-  hasWorkMarker,
+  getWorktreeAt,
+  getWorktreeFor,
+  hostEnvWords,
+  hostStarter,
   idFromTitle,
   idFromTitleVerbose,
   ingestFromDb,
   ingestSegment,
   insertAgent,
-  inspectLinks,
   installCapture,
   interruptAgent,
-  isKickSignal,
+  isConsumed,
   isPathInside,
   isTaskStatus,
   isValidAgentName,
@@ -526,140 +827,156 @@ export {
   isValidPaneId,
   isValidTaskId,
   isValidWorkstreamName,
-  isWorkspaceStale,
-  jjBackend,
-  kickAgent,
   killPane,
   killSession,
   latestSeq,
-  linkPi,
-  linkSkill,
   listAgents,
-  listAllOrphanWorkspaces,
   listBlocked,
+  listDelegates,
+  listDelegatesOf,
   listGoals,
+  listHostChannels,
+  listHosts,
   listInProgress,
   listLiveAgents,
   listLogs,
   listNotes,
   listPanes,
-  listPanesInSession,
   listReady,
   listRecentClosed,
-  listRecentGroups,
-  listSessions,
+  listRemoteRecoveries,
   listTasks,
   listTasksByOwner,
-  listWindows,
-  listWorkspaceOrphans,
-  listWorkspaces,
   listWorkstreams,
-  loadDoctorChecks,
-  loadDoctorSummary,
-  loadFullDag,
-  loadWorkstreamSnapshot,
-  loadWorkstreamSnapshotFast,
-  loadWorkstreamSnapshotSlow,
+  listWorktrees,
+  loadDashboard,
+  loadOpenTaskFrontier,
+  loadResume,
   localMachineId,
   locksDir,
   mapLegacyStatus,
-  mergeSnapshotFastSlow,
-  mostRecentGroup,
+  markDelegate,
+  migratePi,
   murmurAvailable,
   mux_exports as mux,
   muxByName,
-  newSession,
-  newSessionWithPane,
-  newWindow,
   nextHlc,
-  noneBackend,
+  observationFromReading,
+  observeAgentStates,
   opSubject,
+  openBlockersClosure,
   openDb,
+  openHumanNeeds,
   openTask,
-  paneExists,
-  paneTTY,
+  paneAlive,
   parkTask,
-  parseAgentNameFromTitle,
   parseHlc,
   parseOpKey,
-  parsePsTtyOutput,
+  parseVerdict,
   peerStatuses,
-  planUndo,
-  priorFieldValue,
+  pendingAttempts,
+  planAttempt,
+  previewClose,
   probeFilesystem,
   readAgent,
   readAgentStates,
+  readCursors,
   readFileLockMeta,
+  readLiveAgents,
   readManifest,
+  readWaitRegistration,
   rebuildInto,
   receiveHlc,
+  reclaimWorktreePath,
   reconcile,
-  refreshAgentTitle,
+  recordCursors,
+  recordHumanNeeded,
+  recoveriesFor,
+  registerDelegateCall,
+  registerOwnedWait,
+  registerWorktree,
+  releaseHostChannel,
+  releaseHostChannelsForAgent,
+  releaseStall,
+  releaseStallHandler,
   releaseTask,
-  remediationParagraph,
+  releaseWorktree,
   removeBlockEdge,
-  renderForest,
+  removeHost,
+  removeWorktree,
+  renderArgv,
+  renderFrontierLines,
   renderOp,
   renderOpLine,
-  renderTaskTree,
+  renderPlan,
   repairPeer,
   reparentTask,
+  reserveActionReceipt,
+  reserveAttempt,
+  reserveHostChannel,
   resetCommandResolverForTests,
-  resetKickProcessExecutor,
   resetMux,
   resetSleep,
   resetTmuxExecutor,
-  resetWaitPollCount,
   resetWatermark,
   resolveActorIdentity,
   resolveCliCommand,
   resolveCliCommandWithSource,
-  resolveGroupId,
   resolvePair,
   resolvePeerRef,
-  roiBucket,
+  runHostTemplate,
+  saveResume,
   segmentLineCount,
   segmentPath,
-  selectLayout,
+  selectRemoteRecovery,
+  selectTaskNotes,
   sendToAgent,
-  sendToPane,
   sendViaTransport,
-  sessionExists,
   setCommandResolverForTests,
-  setKickProcessExecutor,
   setMuxForTests,
-  setPaneTitle,
   setSleepForTests,
   setTaskStatus,
   setTmuxExecutor,
-  setWaitSleepForTests,
-  setWaitStuckWarnForTests,
   setWatermark,
-  slBackend,
+  settledCloseInput,
+  skillDirDigest,
   sleep,
   slugifyTitle,
   slugifyTitleVerbose,
   spawnAgent,
-  splitWindow,
-  summarizeOwnedTasks,
+  spawnAutoAttempt,
+  spawnForTask,
+  stateSnapshot,
+  steerStall,
+  steerStallHandler,
+  steerText,
   summarizeWorkstream,
   syncDir,
   syncEnabled,
   syncPass,
+  taskRevision,
+  taskRevisions,
   teardownWorkstream,
   tmux_exports as tmux,
   tmuxBackend,
-  transportNextSteps,
-  undoGroup,
+  transitionActionReceipt,
   unparkTask,
   updateTask,
+  upstreamRefs,
+  validateHostTemplate,
+  verdictTally,
   verifyAgainstManifest,
-  waitForTasks,
+  waitForEvents,
+  waitWithActions,
+  watchAgentRun,
+  withAgentLock,
   withCaptureSuppressed,
   withFileLock,
+  withHostChannel,
   withOpContext,
-  workspacePath,
-  workspacesRoot,
-  yankCommandForCheck
+  workstreamRevision,
+  worktreePath,
+  worktreeState,
+  worktreesRoot
 };
 //# sourceMappingURL=index.js.map