@worca/ui 0.22.0 → 0.24.0

package/server/index.js

@@ -1,11 +1,12 @@
 // server/index.js
 import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
-import { homedir, platform } from 'node:os';
+import { platform } from 'node:os';
 import { join } from 'node:path';
 import { createApp } from './app.js';
 import { parseServerArgv } from './argv-parser.js';
 import { createIntegrations } from './integrations/index.js';
+import { preferencesPath, prefsDir as resolvePrefsDir } from './paths.js';
 import { attachWsServer } from './ws.js';
 
 // Parse argv (env vars provide defaults; argv flags take precedence)
@@ -49,7 +50,7 @@ if (isGlobal) {
   settingsPath = join(projectRoot, '.claude', 'settings.json');
 }
 
-const prefsDir = join(homedir(), '.worca');
+const prefsDir = resolvePrefsDir();
 const webhookInbox = createInbox();
 const app = createApp({
   settingsPath,
@@ -94,7 +95,7 @@ const { broadcast, scheduleRefresh, resolveRunProject } = attachWsServer(
   {
     worcaDir,
     settingsPath,
-    prefsPath: join(homedir(), '.worca', 'preferences.json'),
+    prefsPath: preferencesPath(),
     prefsDir,
     webhookInbox,
     projectRoot,

package/server/integrations/commands/fleet.js

@@ -0,0 +1,266 @@
+/**
+ * Fleet-scoped chat commands.
+ *
+ *   /fleets                      list active fleets (running + paused)
+ *   /fleet [id|last]             show one fleet's status
+ *   /fleet-children <id|last>    per-child status table
+ *   /fleet-halt <id>             graceful halt (in-flight finish naturally)
+ *   /fleet-stop <id> [--force]   hard stop (SIGTERM + control file), with confirmation
+ *   /fleet-pause <id>            pause every in-flight child
+ *   /fleet-resume <id>           resume paused/interrupted children, re-dispatch failed
+ *
+ * Authz: every handler runs *after* the inbound allowlist gate in
+ * index.js — same gate that already guards /pause, /resume, /stop.
+ *
+ * Destructive actions (/fleet-stop) require a confirmation token written
+ * into chat_context with a 60s expiry. The token mechanism is local to
+ * this module so we don't bloat chat_context.js's public API for what is
+ * really a per-command UX concern.
+ *
+ * @module commands/fleet
+ */
+
+import { statusEmoji } from './global.js';
+
+const CONFIRM_TTL_MS = 60_000;
+
+/** Pick the most recent fleet from a list (created_at desc). */
+function pickLatest(fleets) {
+  if (!fleets || fleets.length === 0) return null;
+  return [...fleets].sort((a, b) => {
+    const at = a.created_at || '';
+    const bt = b.created_at || '';
+    return bt.localeCompare(at);
+  })[0];
+}
+
+async function fetchFleets(restClient) {
+  const resp = await restClient.get('/api/fleet-runs');
+  const data = resp.data;
+  if (!data || data.ok === false) return [];
+  return Array.isArray(data.fleets) ? data.fleets : [];
+}
+
+async function fetchFleetById(restClient, id) {
+  const resp = await restClient.get(
+    `/api/fleet-runs/${encodeURIComponent(id)}`,
+  );
+  const data = resp.data;
+  if (!data || data.ok === false) return null;
+  return data.fleet ?? null;
+}
+
+/**
+ * Resolve "last" / short-suffix / full-id into a fleet manifest object.
+ * Returns { fleet, disambig } — exactly one of them populated.
+ */
+async function resolveFleet(restClient, idArg, command) {
+  if (!idArg || idArg === 'last') {
+    const all = await fetchFleets(restClient);
+    const latest = pickLatest(all);
+    if (!latest) return { disambig: 'No fleets found.' };
+    return { fleet: latest };
+  }
+  if (idArg.startsWith('f_')) {
+    const fleet = await fetchFleetById(restClient, idArg);
+    if (!fleet) return { disambig: `Fleet \`${idArg}\` not found.` };
+    return { fleet };
+  }
+  // Short suffix match — `4318dbf9` matches `f_..._4318dbf9`.
+  const all = await fetchFleets(restClient);
+  const matches = all.filter((f) => f.fleet_id?.endsWith(idArg));
+  if (matches.length === 0) {
+    return { disambig: `No fleet matches \`${idArg}\`.` };
+  }
+  if (matches.length > 1) {
+    const lines = matches.map((f) => `   • \`${f.fleet_id}\` — ${f.status}`);
+    return {
+      disambig:
+        `Multiple fleets match \`${idArg}\`:\n${lines.join('\n')}\n\n` +
+        `Usage: /${command} <fleet_id>`,
+    };
+  }
+  return { fleet: matches[0] };
+}
+
+function fmtFleetSummary(fleet) {
+  const id = fleet.fleet_id;
+  const title = fleet.work_request?.title || '(no title)';
+  const status = fleet.status || 'unknown';
+  const reason = fleet.halt_reason ? ` (${fleet.halt_reason})` : '';
+  const childCount = fleet.children_count ?? fleet.children?.length ?? 0;
+  const completed = (fleet.children || []).filter(
+    (c) => c.status === 'completed',
+  ).length;
+  const failed = (fleet.children || []).filter(
+    (c) => c.status === 'failed' || c.status === 'setup_failed',
+  ).length;
+  const parts = [`${statusEmoji(status)} **Fleet:** \`${id}\``];
+  parts.push(`   **Title:** ${title}`);
+  parts.push(`   **Status:** ${status}${reason}`);
+  parts.push(
+    `   **Children:** ${completed}/${childCount} completed${failed ? `, ${failed} failed` : ''}`,
+  );
+  if (fleet.cost_usd != null) {
+    parts.push(`   **Cost:** $${Number(fleet.cost_usd).toFixed(2)}`);
+  }
+  return parts.join('\n');
+}
+
+function fmtChildrenTable(fleet) {
+  const children = fleet.children || [];
+  if (children.length === 0) return '   (no children dispatched yet)';
+  return children
+    .map((c) => {
+      const project =
+        (c.project_path || '').split('/').filter(Boolean).pop() || '(?)';
+      const st = c.status || 'unknown';
+      const rid = c.run_id ? ` \`${c.run_id}\`` : '';
+      return `   ${statusEmoji(st)} **${project}** — ${st}${rid}`;
+    })
+    .join('\n');
+}
+
+/**
+ * Creates handlers for the /fleet… commands.
+ *
+ * The chatContext is used for /fleet-stop confirmation tokens — we store
+ * a `pending_fleet_stop = { fleet_id, expires_at }` shape on the chat key
+ * and clear it after the confirming message comes in.
+ *
+ * @param {{ chatContext, restClient }} deps
+ */
+export function createFleetHandlers({ chatContext, restClient }) {
+  async function fleets() {
+    const all = await fetchFleets(restClient);
+    const active = all.filter((f) => {
+      const s = f.status;
+      return s === 'running' || s === 'paused' || s === 'resuming';
+    });
+    if (active.length === 0) return 'No active fleets.';
+    const lines = active.map((f) => {
+      const childCount = f.children_count ?? f.children?.length ?? 0;
+      const title = f.work_request?.title || '(no title)';
+      const reason = f.halt_reason ? ` (${f.halt_reason})` : '';
+      return [
+        `${statusEmoji(f.status)} **Fleet:** \`${f.fleet_id}\``,
+        `   **Title:** ${title}`,
+        `   **Status:** ${f.status}${reason} | **Children:** ${childCount}`,
+      ].join('\n');
+    });
+    return `Active fleets:\n\n${lines.join('\n')}`;
+  }
+
+  async function fleet(_chatKey, args) {
+    const resolved = await resolveFleet(restClient, args[0], 'fleet');
+    if (resolved.disambig) return resolved.disambig;
+    return fmtFleetSummary(resolved.fleet);
+  }
+
+  async function fleetChildren(_chatKey, args) {
+    const resolved = await resolveFleet(restClient, args[0], 'fleet-children');
+    if (resolved.disambig) return resolved.disambig;
+    const f = resolved.fleet;
+    return `Children of \`${f.fleet_id}\`:\n\n${fmtChildrenTable(f)}`;
+  }
+
+  async function fleetHalt(_chatKey, args) {
+    const resolved = await resolveFleet(restClient, args[0], 'fleet-halt');
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.fleet.fleet_id;
+    const resp = await restClient.delete(
+      `/api/fleet-runs/${encodeURIComponent(id)}`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to halt fleet \`${id}\` (${resp.status}).`;
+    }
+    return `\u{1F7E1} Halted fleet \`${id}\`.\nIn-flight children will finish naturally.`;
+  }
+
+  async function fleetStop(chatKey, args) {
+    const isForce = args.includes('--force') || args.includes('YES');
+    const cleanArgs = args.filter((a) => a !== '--force' && a !== 'YES');
+    const resolved = await resolveFleet(restClient, cleanArgs[0], 'fleet-stop');
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.fleet.fleet_id;
+
+    const ctx = chatContext.get(chatKey) || {};
+    const pending = ctx.pending_fleet_stop;
+
+    if (!isForce) {
+      // Issue / refresh a confirmation token.
+      chatContext.set(chatKey, {
+        pending_fleet_stop: {
+          fleet_id: id,
+          expires_at: new Date(Date.now() + CONFIRM_TTL_MS).toISOString(),
+        },
+      });
+      const child_count =
+        resolved.fleet.children_count ?? (resolved.fleet.children || []).length;
+      return (
+        `⚠ \`/fleet-stop\` will SIGTERM every in-flight child of fleet \`${id}\` (${child_count} children).\n` +
+        `Confirm with \`/fleet-stop ${id} YES\` within 60s, or pass \`--force\`.`
+      );
+    }
+
+    // --force or YES path. Either matches a fresh confirmation token, or
+    // the caller is bypassing the gate entirely with --force.
+    if (
+      args.includes('YES') &&
+      (!pending ||
+        pending.fleet_id !== id ||
+        new Date(pending.expires_at).getTime() < Date.now())
+    ) {
+      return `Confirmation expired or never issued for fleet \`${id}\`. Re-run \`/fleet-stop ${id}\` to get a fresh token.`;
+    }
+
+    chatContext.set(chatKey, { pending_fleet_stop: null });
+    const resp = await restClient.post(
+      `/api/fleet-runs/${encodeURIComponent(id)}/stop`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to stop fleet \`${id}\` (${resp.status}).`;
+    }
+    const count = resp.data.stopped_count ?? '?';
+    return `\u{1F534} Stopped fleet \`${id}\`. SIGTERM sent to ${count} child(ren).`;
+  }
+
+  async function fleetPause(_chatKey, args) {
+    const resolved = await resolveFleet(restClient, args[0], 'fleet-pause');
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.fleet.fleet_id;
+    const resp = await restClient.post(
+      `/api/fleet-runs/${encodeURIComponent(id)}/pause`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to pause fleet \`${id}\` (${resp.status}).`;
+    }
+    const count = resp.data.paused_count ?? '?';
+    return `\u{1F7E1} Paused fleet \`${id}\`. ${count} child(ren) will pause at their next iteration boundary.`;
+  }
+
+  async function fleetResume(_chatKey, args) {
+    const resolved = await resolveFleet(restClient, args[0], 'fleet-resume');
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.fleet.fleet_id;
+    const resp = await restClient.post(
+      `/api/fleet-runs/${encodeURIComponent(id)}/resume`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to resume fleet \`${id}\` (${resp.status}).`;
+    }
+    const continued = resp.data.continued_count ?? 0;
+    const redispatched = resp.data.redispatched_count ?? 0;
+    return `\u{1F7E2} Resumed fleet \`${id}\`. ${continued} continued in-place, ${redispatched} re-dispatched.`;
+  }
+
+  return {
+    fleets,
+    fleet,
+    'fleet-children': fleetChildren,
+    'fleet-halt': fleetHalt,
+    'fleet-stop': fleetStop,
+    'fleet-pause': fleetPause,
+    'fleet-resume': fleetResume,
+  };
+}

package/server/integrations/commands/global.js

@@ -115,6 +115,24 @@ const HELP_TEXT = `/start \u2014 show your chat ID
 /resume [run_id] \u2014 resume paused run
 /stop [run_id] \u2014 stop run
 
+Fleet commands (cross-project):
+/fleets \u2014 list active fleets
+/fleet [id|last] \u2014 fleet status
+/fleet-children <id|last> \u2014 per-child status
+/fleet-halt <id> \u2014 graceful halt (in-flight finish naturally)
+/fleet-stop <id> [--force] \u2014 SIGTERM every in-flight child (confirms first)
+/fleet-pause <id> \u2014 pause every in-flight child
+/fleet-resume <id> \u2014 resume paused/interrupted, re-dispatch failed
+
+Workspace commands (DAG-ordered cross-project):
+/workspaces \u2014 list active workspaces
+/workspace [id|last] \u2014 workspace status
+/workspace-projects <id|last> \u2014 per-project status
+/workspace-tiers <id|last> \u2014 tier-by-tier DAG status
+/workspace-halt <id> \u2014 graceful halt (in-flight finish naturally)
+/workspace-resume <id> \u2014 re-dispatch failed/halted projects
+/workspace-prs <id> \u2014 list child PRs + umbrella issue
+
 Commands with [run_id] auto-resolve to the active run if omitted.
 Use \`*suffix\` to match by ending, e.g. /status \`*2db5\`
 Project commands require /use first.`;

package/server/integrations/commands/parser.js

@@ -1,6 +1,9 @@
 const MENTION_RE = /^@\S+$/i;
 
-const COMMAND_RE = /^\/([a-z_]+)(?:@\S+)?$/i;
+// Allow `-` so namespaced commands like /fleet-halt and /fleet-resume parse.
+// Hyphens must appear inside the name, not lead or trail. Backwards-compatible
+// — every existing underscore-only command still matches.
+const COMMAND_RE = /^\/([a-z_][a-z0-9_-]*)(?:@\S+)?$/i;
 
 /**
  * Parses a chat message into a command name and argument list.

package/server/integrations/commands/workspace.js

@@ -0,0 +1,295 @@
+/**
+ * Workspace-scoped chat commands.
+ *
+ *   /workspaces                       list active workspaces
+ *   /workspace [id|last]              show one workspace's summary
+ *   /workspace-projects <id|last>     per-project status grid (DAG)
+ *   /workspace-tiers <id|last>        tier-by-tier DAG status
+ *   /workspace-halt <id>              graceful halt (in-flight finish naturally)
+ *   /workspace-resume <id>            re-dispatch failed/halted children
+ *   /workspace-prs <id>               list child PRs + umbrella issue
+ *
+ * Mirrors the fleet command surface, but uses workspace terminology — the
+ * unit of work is a named project entry in workspace.json, not an arbitrary
+ * project path. /workspace-pause and /workspace-stop are intentionally
+ * absent: workspaces don't yet have pause/stop infrastructure (only halt
+ * via DELETE). When the lifecycle gains those, add commands here.
+ *
+ * Authz: every handler runs *after* the inbound allowlist gate in
+ * index.js — same gate that already guards /pause, /resume, /stop.
+ *
+ * @module commands/workspace
+ */
+
+import { statusEmoji } from './global.js';
+
+function pickLatest(workspaces) {
+  if (!workspaces || workspaces.length === 0) return null;
+  return [...workspaces].sort((a, b) => {
+    const at = a.created_at || '';
+    const bt = b.created_at || '';
+    return bt.localeCompare(at);
+  })[0];
+}
+
+async function fetchWorkspaces(restClient) {
+  const resp = await restClient.get('/api/workspace-runs');
+  const data = resp.data;
+  if (!data || data.ok === false) return [];
+  return Array.isArray(data.workspace_runs) ? data.workspace_runs : [];
+}
+
+async function fetchWorkspaceById(restClient, id) {
+  const resp = await restClient.get(
+    `/api/workspace-runs/${encodeURIComponent(id)}`,
+  );
+  const data = resp.data;
+  if (!data || data.ok === false) return null;
+  // GET /:id returns { ok, manifest, cost_usd } — flatten to a single object
+  // with the shape /workspace-runs list emits, so downstream formatters can
+  // be uniform.
+  if (data.manifest) {
+    return { ...data.manifest, cost_usd: data.cost_usd };
+  }
+  return null;
+}
+
+/**
+ * Resolve "last" / short-suffix / full-id into a workspace manifest object.
+ * Returns { workspace, disambig } — exactly one of them populated.
+ */
+async function resolveWorkspace(restClient, idArg, command) {
+  if (!idArg || idArg === 'last') {
+    const all = await fetchWorkspaces(restClient);
+    const latest = pickLatest(all);
+    if (!latest) return { disambig: 'No workspaces found.' };
+    return { workspace: latest };
+  }
+  if (idArg.startsWith('ws_')) {
+    const workspace = await fetchWorkspaceById(restClient, idArg);
+    if (!workspace) return { disambig: `Workspace \`${idArg}\` not found.` };
+    return { workspace };
+  }
+  // Short suffix match — `4318dbf9` matches `ws_..._4318dbf9`.
+  const all = await fetchWorkspaces(restClient);
+  const matches = all.filter((w) => w.workspace_id?.endsWith(idArg));
+  if (matches.length === 0) {
+    return { disambig: `No workspace matches \`${idArg}\`.` };
+  }
+  if (matches.length > 1) {
+    const lines = matches.map(
+      (w) => `   • \`${w.workspace_id}\` — ${w.status}`,
+    );
+    return {
+      disambig:
+        `Multiple workspaces match \`${idArg}\`:\n${lines.join('\n')}\n\n` +
+        `Usage: /${command} <workspace_id>`,
+    };
+  }
+  return { workspace: matches[0] };
+}
+
+function fmtWorkspaceSummary(ws) {
+  const id = ws.workspace_id;
+  const name = ws.workspace_name ? ` (${ws.workspace_name})` : '';
+  const status = ws.status || 'unknown';
+  const reason = ws.halt_reason ? ` (${ws.halt_reason})` : '';
+  const children = ws.children || [];
+  const childCount = ws.children_count ?? children.length;
+  const completed = children.filter((c) => c.status === 'completed').length;
+  const failed = children.filter(
+    (c) =>
+      c.status === 'failed' ||
+      c.status === 'blocked' ||
+      c.status === 'setup_failed',
+  ).length;
+  const parts = [`${statusEmoji(status)} **Workspace:** \`${id}\`${name}`];
+  parts.push(`   **Status:** ${status}${reason}`);
+  parts.push(
+    `   **Projects:** ${completed}/${childCount} completed${failed ? `, ${failed} failed` : ''}`,
+  );
+  const tiers = ws.dag?.tiers || [];
+  if (tiers.length > 0) {
+    parts.push(`   **Tiers:** ${tiers.length}`);
+  }
+  if (ws.cost_usd != null) {
+    parts.push(`   **Cost:** $${Number(ws.cost_usd).toFixed(2)}`);
+  }
+  return parts.join('\n');
+}
+
+function fmtProjectsTable(ws) {
+  const children = ws.children || [];
+  if (children.length === 0) return '   (no projects dispatched yet)';
+  return children
+    .map((c) => {
+      const project = c.project || '(?)';
+      const st = c.status || 'unknown';
+      const rid = c.run_id ? ` \`${c.run_id}\`` : '';
+      const tier = c.tier != null ? ` [tier ${c.tier}]` : '';
+      return `   ${statusEmoji(st)} **${project}**${tier} — ${st}${rid}`;
+    })
+    .join('\n');
+}
+
+function fmtTiersTable(ws) {
+  const tiers = ws.dag?.tiers || [];
+  if (tiers.length === 0) return '   (no tiers defined)';
+  const childByProject = new Map();
+  for (const c of ws.children || []) {
+    childByProject.set(c.project, c);
+  }
+  return tiers
+    .map((t) => {
+      const projects = t.projects || [];
+      const lines = projects.map((p) => {
+        const child = childByProject.get(p);
+        const st = child?.status || 'pending';
+        return `      ${statusEmoji(st)} ${p} — ${st}`;
+      });
+      const tierStatus = t.status || 'pending';
+      return [`   **Tier ${t.tier} (${tierStatus}):**`, ...lines].join('\n');
+    })
+    .join('\n');
+}
+
+function fmtPrsTable(ws) {
+  const children = ws.children || [];
+  const withPrs = children.filter((c) => c.pr_number || c.pr_url);
+  if (withPrs.length === 0 && !ws.umbrella_issue) {
+    return '   (no PRs created yet)';
+  }
+  const lines = [];
+  for (const c of withPrs) {
+    const ref = c.nwo && c.pr_number ? `${c.nwo}#${c.pr_number}` : c.pr_url;
+    lines.push(`   • **${c.project}** — ${ref}`);
+  }
+  if (ws.umbrella_issue?.url) {
+    lines.push('');
+    lines.push(`   \u{1F517} **Umbrella issue:** ${ws.umbrella_issue.url}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Creates handlers for the /workspace… commands.
+ *
+ * The chatContext is used to remember an `active_workspace` per chat,
+ * symmetrical to the existing `active_project` mechanism — so a user can
+ * `/workspace ws_…_abc` once, then `/workspace-halt` (no arg) on the same
+ * one. Implementation left for a follow-up if/when the UX warrants it.
+ *
+ * @param {{ chatContext, restClient }} deps
+ */
+export function createWorkspaceHandlers({
+  chatContext: _chatContext,
+  restClient,
+}) {
+  async function workspaces() {
+    const all = await fetchWorkspaces(restClient);
+    const active = all.filter((w) => {
+      const s = w.status;
+      return (
+        s === 'running' ||
+        s === 'planning' ||
+        s === 'integration_testing' ||
+        s === 'resuming' ||
+        s === 'paused'
+      );
+    });
+    if (active.length === 0) return 'No active workspaces.';
+    const lines = active.map((w) => {
+      const childCount = w.children_count ?? w.children?.length ?? 0;
+      const name = w.workspace_name ? ` (${w.workspace_name})` : '';
+      const reason = w.halt_reason ? ` (${w.halt_reason})` : '';
+      return [
+        `${statusEmoji(w.status)} **Workspace:** \`${w.workspace_id}\`${name}`,
+        `   **Status:** ${w.status}${reason} | **Projects:** ${childCount}`,
+      ].join('\n');
+    });
+    return `Active workspaces:\n\n${lines.join('\n')}`;
+  }
+
+  async function workspace(_chatKey, args) {
+    const resolved = await resolveWorkspace(restClient, args[0], 'workspace');
+    if (resolved.disambig) return resolved.disambig;
+    return fmtWorkspaceSummary(resolved.workspace);
+  }
+
+  async function workspaceProjects(_chatKey, args) {
+    const resolved = await resolveWorkspace(
+      restClient,
+      args[0],
+      'workspace-projects',
+    );
+    if (resolved.disambig) return resolved.disambig;
+    const w = resolved.workspace;
+    return `Projects in \`${w.workspace_id}\`:\n\n${fmtProjectsTable(w)}`;
+  }
+
+  async function workspaceTiers(_chatKey, args) {
+    const resolved = await resolveWorkspace(
+      restClient,
+      args[0],
+      'workspace-tiers',
+    );
+    if (resolved.disambig) return resolved.disambig;
+    const w = resolved.workspace;
+    return `DAG tiers for \`${w.workspace_id}\`:\n\n${fmtTiersTable(w)}`;
+  }
+
+  async function workspaceHalt(_chatKey, args) {
+    const resolved = await resolveWorkspace(
+      restClient,
+      args[0],
+      'workspace-halt',
+    );
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.workspace.workspace_id;
+    const resp = await restClient.delete(
+      `/api/workspace-runs/${encodeURIComponent(id)}`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to halt workspace \`${id}\` (${resp.status}).`;
+    }
+    return `\u{1F7E1} Halted workspace \`${id}\`.\nIn-flight tier children will finish naturally.`;
+  }
+
+  async function workspaceResume(_chatKey, args) {
+    const resolved = await resolveWorkspace(
+      restClient,
+      args[0],
+      'workspace-resume',
+    );
+    if (resolved.disambig) return resolved.disambig;
+    const id = resolved.workspace.workspace_id;
+    const resp = await restClient.post(
+      `/api/workspace-runs/${encodeURIComponent(id)}/resume`,
+    );
+    if (!resp.data || resp.data.ok === false) {
+      return `Failed to resume workspace \`${id}\` (${resp.status}).`;
+    }
+    return `\u{1F7E2} Resumed workspace \`${id}\`. Re-dispatching pending project(s).`;
+  }
+
+  async function workspacePrs(_chatKey, args) {
+    const resolved = await resolveWorkspace(
+      restClient,
+      args[0],
+      'workspace-prs',
+    );
+    if (resolved.disambig) return resolved.disambig;
+    const w = resolved.workspace;
+    return `PRs for \`${w.workspace_id}\`:\n\n${fmtPrsTable(w)}`;
+  }
+
+  return {
+    workspaces,
+    workspace,
+    'workspace-projects': workspaceProjects,
+    'workspace-tiers': workspaceTiers,
+    'workspace-halt': workspaceHalt,
+    'workspace-resume': workspaceResume,
+    'workspace-prs': workspacePrs,
+  };
+}

package/server/integrations/index.js

@@ -12,9 +12,11 @@ import { createWebhookOutAdapter } from './adapters/webhook_out.js';
 import { createAllowlistGuard } from './allowlist.js';
 import { createChatContext } from './chat_context.js';
 import { createControlHandlers } from './commands/control.js';
+import { createFleetHandlers } from './commands/fleet.js';
 import { createGlobalHandlers } from './commands/global.js';
 import { parseCommand } from './commands/parser.js';
 import { createProjectHandlers } from './commands/project.js';
+import { createWorkspaceHandlers } from './commands/workspace.js';
 import { loadIntegrationsConfig } from './config-loader.js';
 import { createRateLimiter } from './rate_limiter.js';
 import { renderEvent } from './renderers.js';
@@ -65,10 +67,17 @@ export function createIntegrations({
   });
   const projectHandlers = createProjectHandlers({ chatContext, restClient });
   const controlHandlers = createControlHandlers({ chatContext, restClient });
+  const fleetHandlers = createFleetHandlers({ chatContext, restClient });
+  const workspaceHandlers = createWorkspaceHandlers({
+    chatContext,
+    restClient,
+  });
   const allHandlers = {
     ...globalHandlers,
     ...projectHandlers,
     ...controlHandlers,
+    ...fleetHandlers,
+    ...workspaceHandlers,
   };
 
   // Mutable adapter registry — keyed by adapter name