npm - agent-relay-server - Versions diffs - 0.17.0 → 0.18.0 - Mend

agent-relay-server 0.17.0 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/docs/openapi.json +101 -1
package/package.json +2 -2
package/public/index.html +25 -22
package/public/sw.js +51 -16
package/runner/src/adapter.ts +1 -4
package/runner/src/config.ts +1 -4
package/scripts/orchestrator-spawn-smoke.ts +2 -1
package/src/automations.ts +9 -33
package/src/bus.ts +2 -17
package/src/cli.ts +179 -3
package/src/command-events.ts +26 -0
package/src/config-store.ts +5 -22
package/src/connectors.ts +1 -4
package/src/contracts.ts +2 -8
package/src/db.ts +14 -15
package/src/index.ts +99 -4
package/src/lifecycle-manager.ts +11 -24
package/src/maintenance.ts +26 -20
package/src/managed-policy.ts +9 -28
package/src/mcp.ts +19 -43
package/src/memory-broker-smoke.ts +3 -1
package/src/memory-command-broker.ts +1 -4
package/src/memory-http-broker.ts +1 -4
package/src/memory-service.ts +1 -4
package/src/memory-sqlite-broker.ts +1 -8
package/src/provider-catalog-store.ts +3 -11
package/src/recipe-loader.ts +1 -4
package/src/recipe-validator.ts +1 -4
package/src/routes.ts +249 -142
package/src/security.ts +3 -7
package/src/spawn-command.ts +150 -0
package/src/sse.ts +1 -4
package/src/steward.ts +16 -21
package/src/upgrade.ts +3 -2
package/src/utils.ts +38 -0
package/src/validation.ts +28 -0
package/src/workspace-claim.ts +29 -0
package/src/workspace-merge.ts +21 -9

package/src/cli.ts CHANGED Viewed

@@ -44,6 +44,7 @@ import {
 import { formatMemoryBrokerSmokeResult, runMemoryBrokerSmoke } from "./memory-broker-smoke";
 import { MAX_BODY_BYTES, VERSION } from "./config";
 import { DEFAULT_CONTEXT_PROBE_STATE_DIR, runContextProbe } from "agent-relay-sdk/context-probe";
+import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 const HELP = `
 agent-relay ${VERSION}
@@ -62,6 +63,8 @@ Usage:
   agent-relay context-probe [print-status-line] [--wrap COMMAND] [--agent-id ID] [--state-dir DIR] [--standalone]
   agent-relay token <create|list|revoke|verify> [options]
   agent-relay pair <target|create|status|accept|reject|hangup|send> [options]
+  agent-relay workspace <status|diagnostics|ready|land|claim|release|list|cleanup-stale> [--id ID] [--strategy …] [--purpose TEXT] [--repo PATH] [--execute] [--json]
+  agent-relay steward <queue|inspect|checks> [WORKSPACE_ID] [--repo PATH] [--json]
   agent-relay message <target> <body> [options]
   agent-relay get-message <messageId> [--json|--body]
   agent-relay /pair <target|accept|reject|send|status> [...]
@@ -219,6 +222,16 @@ Labels and tags
   agent-relay /label [LABEL]
   agent-relay /tags [TAG ...]
+Isolated workspaces
+  If you are working in an isolated workspace (a git worktree on an agent
+  branch, not the main checkout), you do NOT rebase, merge, or push yourself —
+  Relay does. Just commit your work in the worktree, then:
+    agent-relay workspace ready    Hand off: Relay rebases onto the latest base,
+                                   lands your work, and pushes.
+    agent-relay workspace status   Show your workspace's branch, base, status.
+  The base branch will move as other agents land in parallel — that is normal,
+  let the merge handle it. Never push your branch yourself; it is local-only.
 Rules of thumb
   If you are handling relay message #123, reply with:
     agent-relay /reply 123 "<response>"
@@ -347,6 +360,14 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
     await handleTagsCommand(args.slice(1));
     return "handled";
   }
+  if (command === "workspace" || command === "workspaces") {
+    await handleWorkspaceCommand(args.slice(1));
+    return "handled";
+  }
+  if (command === "steward" || command === "stewards") {
+    await handleStewardCommand(args.slice(1));
+    return "handled";
+  }
   if (command === "/reconnect") {
     console.log("Reconnect is handled automatically by provider runners; use `agent-relay pair status` to inspect current pair state.");
     return "handled";
@@ -994,7 +1015,7 @@ async function exchangeOrchestratorBootstrapToken(relayUrl: string, bootstrapTok
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      "X-Agent-Relay-Token": bootstrapToken,
+      [RELAY_TOKEN_HEADER]: bootstrapToken,
     },
     body: JSON.stringify({ id, baseDir }),
   });
@@ -1376,6 +1397,161 @@ async function handlePairCommand(args: string[]): Promise<void> {
   }
 }
+// The agent's own isolated-workspace id, published in AGENT_RELAY_WORKSPACE_JSON
+// by the orchestrator at spawn. Undefined for shared-workspace / non-managed agents.
+function currentWorkspaceId(): string | undefined {
+  const json = process.env.AGENT_RELAY_WORKSPACE_JSON;
+  if (!json) return undefined;
+  try {
+    const parsed = JSON.parse(json) as { id?: string };
+    return typeof parsed.id === "string" && parsed.id ? parsed.id : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function formatWorkspaceStatus(ws: any): string {
+  const lines = [
+    `Workspace ${ws.id}`,
+    `  status:   ${ws.status}`,
+    `  branch:   ${ws.branch ?? "(none)"}`,
+    `  base:     ${ws.baseRef ?? "(none)"}`,
+    `  worktree: ${ws.worktreePath ?? "(none)"}`,
+  ];
+  return lines.join("\n");
+}
+// Self-service workspace lifecycle for agents in isolated worktrees (#205) plus
+// steward coordination (#208).
+//   status — read your workspace row     ready — hand off for review/landing
+//   land   — request a base merge (operator)   list — all workspaces
+//   diagnostics — joined briefing + recommended action
+//   claim/release — TTL'd steward lease auto-merge yields to
+//   cleanup-stale — guarded batch cleanup of stale worktrees (dry-run by default)
+async function handleWorkspaceCommand(args: string[]): Promise<void> {
+  const action = args[0];
+  const valid = new Set(["status", "ready", "land", "list", "diagnostics", "diag", "claim", "release", "cleanup-stale"]);
+  if (!action || !valid.has(action)) {
+    throw new Error("Usage: agent-relay workspace <status|diagnostics|ready|land|claim|release|list|cleanup-stale> [--id ID] [--strategy …] [--purpose TEXT] [--repo PATH] [--execute] [--json]");
+  }
+  let id = currentWorkspaceId();
+  let strategy: string | undefined;
+  let purpose: string | undefined;
+  let repo: string | undefined;
+  let execute = false;
+  let json = false;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--id" && i + 1 < args.length) id = args[++i];
+    else if (arg === "--strategy" && i + 1 < args.length) strategy = args[++i];
+    else if (arg === "--purpose" && i + 1 < args.length) purpose = args[++i];
+    else if (arg === "--repo" && i + 1 < args.length) repo = args[++i];
+    else if (arg === "--execute") execute = true;
+    else if (arg === "--json") json = true;
+    else throw new Error(`Unknown workspace option "${arg}".`);
+  }
+  if (action === "list") {
+    console.log(JSON.stringify(await apiRequest("GET", "/api/workspaces"), null, 2));
+    return;
+  }
+  if (action === "cleanup-stale") {
+    const result = await apiRequest("POST", "/api/workspaces/actions/cleanup-stale", { repoRoot: repo, dryRun: !execute });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!id) throw new Error("No current workspace detected (AGENT_RELAY_WORKSPACE_JSON unset). Pass --id WORKSPACE_ID — only isolated-workspace agents have one.");
+  if (action === "status") {
+    const ws = await apiRequest("GET", `/api/workspaces/${encodeURIComponent(id)}`);
+    if (json) console.log(JSON.stringify(ws, null, 2));
+    else console.log(formatWorkspaceStatus(ws));
+    return;
+  }
+  if (action === "diagnostics" || action === "diag") {
+    console.log(JSON.stringify(await apiRequest("GET", `/api/workspaces/${encodeURIComponent(id)}/diagnostics`), null, 2));
+    return;
+  }
+  const from = await detectAgentId();
+  const actionBody: Record<string, unknown> =
+    action === "ready" ? { action: "request-review", agentId: from }
+    : action === "claim" ? { action: "claim", agentId: from, purpose }
+    : action === "release" ? { action: "release-claim", agentId: from }
+    : { action: "merge", agentId: from, ...(strategy ? { strategy } : {}) };
+  const result = await apiRequest("POST", `/api/workspaces/${encodeURIComponent(id)}/actions`, actionBody);
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(
+    action === "ready" ? `Workspace ${id} marked ready — Relay will rebase onto the latest base, land, and push.`
+    : action === "claim" ? `Workspace ${id} claimed${purpose ? ` (${purpose})` : ""} — auto-merge will yield until released or the claim expires.`
+    : action === "release" ? `Workspace ${id} claim released.`
+    : `Workspace ${id} merge requested (${strategy ?? "auto"}).`,
+  );
+}
+// Steward briefing commands (#208): queue of workspaces needing attention, a
+// per-workspace diagnostics inspection, and a check-command suggestion.
+async function handleStewardCommand(args: string[]): Promise<void> {
+  const action = args[0];
+  if (!action || !["queue", "inspect", "checks"].includes(action)) {
+    throw new Error("Usage: agent-relay steward <queue|inspect|checks> [WORKSPACE_ID] [--repo PATH] [--json]");
+  }
+  let repo: string | undefined;
+  let json = false;
+  const positional: string[] = [];
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--repo" && i + 1 < args.length) repo = args[++i];
+    else if (arg === "--json") json = true;
+    else if (!arg!.startsWith("--")) positional.push(arg!);
+    else throw new Error(`Unknown steward option "${arg}".`);
+  }
+  if (action === "queue") {
+    const all = await apiRequest("GET", "/api/workspaces") as any[];
+    const attention = new Set(["conflict", "review_requested", "merge_planned"]);
+    const queue = all.filter((ws) => attention.has(ws.status) && (!repo || ws.repoRoot === repo));
+    if (json) { console.log(JSON.stringify(queue, null, 2)); return; }
+    if (!queue.length) { console.log("Steward queue empty — no workspaces awaiting review, merge, or conflict resolution."); return; }
+    for (const ws of queue) console.log(`${ws.status.padEnd(16)} ${ws.branch ?? ws.id}  (${ws.repoRoot})`);
+    return;
+  }
+  const id = positional[0];
+  if (!id) throw new Error(`Usage: agent-relay steward ${action} WORKSPACE_ID [--json]`);
+  if (action === "inspect") {
+    console.log(JSON.stringify(await apiRequest("GET", `/api/workspaces/${encodeURIComponent(id)}/diagnostics`), null, 2));
+    return;
+  }
+  // checks: suggest validation commands from the workspace's changed files.
+  const diff = await apiRequest("GET", `/api/workspaces/${encodeURIComponent(id)}/diff?patch=0`) as any;
+  const files: string[] = Array.isArray(diff?.files) ? diff.files.map((f: any) => f.path) : [];
+  const checks = suggestStewardChecks(files);
+  console.log(JSON.stringify({ workspaceId: id, changedFiles: files.length, checks }, null, 2));
+}
+// Heuristic check suggestions from changed file paths. Repo-agnostic defaults a
+// steward can refine; cheaper than re-deriving from project docs every run.
+function suggestStewardChecks(files: string[]): Array<{ command: string; reason: string }> {
+  const checks: Array<{ command: string; reason: string }> = [];
+  const has = (re: RegExp) => files.some((f) => re.test(f));
+  if (has(/\.(ts|tsx|mts|cts)$/)) checks.push({ command: "bun run typecheck", reason: "TypeScript files changed" });
+  if (has(/\.test\.|(^|\/)tests?\//)) checks.push({ command: "bun test", reason: "test files changed" });
+  else if (files.length) checks.push({ command: "bun test", reason: "repo default" });
+  if (has(/(^|\/)dashboard\//)) checks.push({ command: "bun run build:dashboard", reason: "dashboard sources changed" });
+  return checks;
+}
 async function handleMessageCommand(args: string[], defaults: { claimable?: boolean } = {}): Promise<void> {
   const target = args[0];
   if (!target || target.startsWith("--")) {
@@ -1989,7 +2165,7 @@ async function apiRequest(method: string, path: string, body?: unknown): Promise
   const baseUrl = process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850";
   const headers: Record<string, string> = {};
   const token = process.env.AGENT_RELAY_TOKEN;
-  if (token) headers["X-Agent-Relay-Token"] = token;
+  if (token) headers[RELAY_TOKEN_HEADER] = token;
   if (body !== undefined) headers["Content-Type"] = "application/json";
   const response = await fetch(new URL(path, baseUrl), {
     method,
@@ -2009,7 +2185,7 @@ async function apiRawRequest(method: string, path: string, body: BodyInit, extra
   const baseUrl = process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850";
   const headers: Record<string, string> = { ...extraHeaders };
   const token = process.env.AGENT_RELAY_TOKEN;
-  if (token) headers["X-Agent-Relay-Token"] = token;
+  if (token) headers[RELAY_TOKEN_HEADER] = token;
   const response = await fetch(new URL(path, baseUrl), { method, headers, body });
   const text = await response.text();
   const payload = text ? JSON.parse(text) : null;

package/src/command-events.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import { emitRelayEvent } from "./events";
+import type { Command } from "./types";
+/**
+ * Emit the relay event for a command. Single home — was duplicated as bus.ts's
+ * `emitCommandEvent(command, type)` and lifecycle-manager's private
+ * `emitCommand(command)` (which hardcoded "command.requested").
+ *
+ * The caller passes the exact event type: "command.requested" for a freshly
+ * created command (the relay auto-emits the follow-up "command.dispatched" — see
+ * `events.ts`), or `command.<status>` after an update.
+ *
+ * Deliberately NO `commandEventType(command)` derivation helper: a
+ * pending→"command.requested" mapping would diverge from the literal
+ * `command.<status>` used on the update path and spuriously trigger the
+ * requested→dispatched fan-out for a (valid, externally reachable) update to
+ * status "pending". Pass the type explicitly.
+ */
+export function emitCommandEvent(command: Command, type: string): void {
+  emitRelayEvent({
+    type,
+    source: command.source,
+    subject: command.id,
+    data: { command },
+  });
+}

package/src/config-store.ts CHANGED Viewed

@@ -1,5 +1,7 @@
 import { getDb, ValidationError } from "./db";
+import { cleanString } from "./validation";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
+import { isRecord, SPAWN_PROVIDERS, VALID_EFFORTS, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
 import type {
   AgentProfile,
   AgentProfileBase,
@@ -24,18 +26,15 @@ const INSIGHTS_NAMESPACE = "insights";
 const INSIGHTS_KEY = "default";
 const WORKSPACE_NAMESPACE = "workspace";
 const WORKSPACE_KEY = "default";
-const VALID_PROVIDERS = ["claude", "codex"] as const;
 const VALID_PROFILE_PROVIDERS = ["any", "claude", "codex"] as const;
 const VALID_PROFILE_BASES = ["host", "minimal", "isolated"] as const;
 const VALID_PROFILE_INSTRUCTION_POLICIES = ["allow", "ignore"] as const;
 const VALID_PROFILE_CATEGORY_MODES = ["host", "profile", "repo", "none"] as const;
 const VALID_PROFILE_ASSET_SOURCES = ["relay", "repo", "inline", "provider"] as const;
 const VALID_PROFILE_FILESYSTEM_SCOPES = ["repo", "workspace", "host"] as const;
-const VALID_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
 const VALID_PERMISSION_MODES = ["open", "guarded", "read-only"] as const;
 const VALID_POLICY_MODES = ["always-on", "on-demand"] as const;
 const VALID_MANAGED_STATUSES = ["stopped", "starting", "running", "stopping", "backoff"] as const;
-const VALID_WORKSPACE_MODES = ["isolated", "shared", "inherit"] as const;
 const BUILT_IN_AGENT_PROFILE_NAMES = new Set(["default-relay", "minimal", "isolated-research"]);
 const BUILT_IN_AGENT_PROFILES: AgentProfile[] = [
@@ -156,22 +155,6 @@ function rowToManagedAgentState(row: ManagedAgentStateRow): ManagedAgentState {
   };
 }
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function cleanString(value: unknown, field: string, opts: { required?: boolean; max?: number } = {}): string | undefined {
-  if (value === undefined || value === null) {
-    if (opts.required) throw new ValidationError(`${field} required`);
-    return undefined;
-  }
-  if (typeof value !== "string") throw new ValidationError(`${field} must be a string`);
-  const trimmed = value.trim();
-  if (opts.required && !trimmed) throw new ValidationError(`${field} required`);
-  if (opts.max && trimmed.length > opts.max) throw new ValidationError(`${field} must be ${opts.max} characters or fewer`);
-  return trimmed || undefined;
-}
 function cleanStringArray(value: unknown, field: string, opts: { required?: boolean } = {}): string[] {
   if (value === undefined || value === null) {
     if (opts.required) throw new ValidationError(`${field} required`);
@@ -343,7 +326,7 @@ function validateSpawnPolicy(key: string, value: unknown): SpawnPolicy {
     enabled: value.enabled === undefined ? true : cleanBoolean(value.enabled, "enabled"),
     orchestratorId: cleanString(value.orchestratorId, "orchestratorId", { required: true, max: 200 })!,
     cwd: cleanString(value.cwd, "cwd", { required: true, max: 1000 })!,
-    provider: cleanEnum(value.provider, "provider", VALID_PROVIDERS) as SpawnProvider,
+    provider: cleanEnum(value.provider, "provider", SPAWN_PROVIDERS) as SpawnProvider,
     workspaceMode: value.workspaceMode === undefined || value.workspaceMode === null ? "inherit" : cleanEnum(value.workspaceMode, "workspaceMode", VALID_WORKSPACE_MODES),
     rig: cleanString(value.rig, "rig", { max: 120 }),
     model: cleanString(value.model, "model", { max: 120 }),
@@ -411,7 +394,7 @@ function validateStewardConfig(value: unknown): StewardConfig {
   if (!isRecord(value)) throw new ValidationError("steward config value must be an object");
   const config: StewardConfig = {
     enabled: value.enabled === undefined ? false : cleanBoolean(value.enabled, "enabled"),
-    provider: cleanEnum(value.provider, "provider", VALID_PROVIDERS) as SpawnProvider,
+    provider: cleanEnum(value.provider, "provider", SPAWN_PROVIDERS) as SpawnProvider,
     model: cleanString(value.model, "model", { max: 120 }),
     effort: value.effort === undefined || value.effort === null ? undefined : cleanEnum(value.effort, "effort", VALID_EFFORTS) as ProviderEffort,
     permissionMode: (value.permissionMode === undefined || value.permissionMode === null
@@ -721,7 +704,7 @@ function listManagedAgentStates(): ManagedAgentState[] {
 export function upsertManagedAgentState(input: ManagedAgentStateInput): ManagedAgentState {
   if (!VALID_MANAGED_STATUSES.includes(input.status)) throw new ValidationError("status must be a managed-agent status");
-  if (!VALID_PROVIDERS.includes(input.provider)) throw new ValidationError("provider must be claude or codex");
+  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError("provider must be claude or codex");
   const now = input.updatedAt ?? Date.now();
   getDb().query(`
     INSERT INTO managed_agent_state (

package/src/connectors.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import type { ConnectorAction, ConnectorActionResult, ConnectorManifest, ConnectorSummary } from "./types";
 import { ValidationError } from "./db";
+import { isRecord } from "agent-relay-sdk";
 const CONNECTOR_SCHEMA = "agent-relay.connector.v1";
 const VALID_KINDS = new Set(["channel", "event", "provider", "orchestrator"]);
@@ -34,10 +35,6 @@ function readRecordFile(path: string): Record<string, unknown> | undefined {
   return isRecord(parsed) ? parsed : undefined;
 }
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function validateConnectorId(id: string): void {
   if (!/^[a-z0-9][a-z0-9._-]{0,79}$/.test(id)) {
     throw new ValidationError("connector id must be lowercase alphanumeric plus dot, underscore, or dash");

package/src/contracts.ts CHANGED Viewed

@@ -1,3 +1,5 @@
+import { isRecord, stringValue } from "agent-relay-sdk";
 export const CONTRACT_VERSIONS = {
   relayApi: 1,
   orchestratorProtocol: 3,
@@ -95,10 +97,6 @@ function rangeLabel(requirement: ContractRequirement): string {
   return `>=${requirement.min} <${requirement.maxExclusive}`;
 }
-function stringValue(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 function positiveInteger(value: unknown): number | undefined {
   const parsed = typeof value === "number"
     ? value
@@ -106,7 +104,3 @@ function positiveInteger(value: unknown): number | undefined {
   if (parsed === undefined || !Number.isInteger(parsed) || parsed <= 0) return undefined;
   return parsed;
 }
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/db.ts CHANGED Viewed

@@ -1,6 +1,8 @@
 import { Database } from "bun:sqlite";
 import { randomUUID } from "node:crypto";
+import { isRecord, stringValue } from "agent-relay-sdk";
 import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "./config.ts";
+import { parseJson } from "./utils";
 import {
   CONTRACT_REQUIREMENTS,
   contractCompatibility,
@@ -1173,13 +1175,6 @@ export function getDb(): Database {
 export class ValidationError extends Error {}
 class ClaimError extends Error {}
-function parseJson<T>(raw: string, fallback: T): T {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return fallback;
-  }
-}
 function parseStringArray(raw: string): string[] {
   const parsed = parseJson<unknown>(raw, []);
@@ -1191,10 +1186,6 @@ function normalizeTags(tags: string[] | undefined): string[] {
   return [...new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))];
 }
-function stringValue(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 function inferAgentKind(input: Pick<RegisterAgentInput, "id" | "kind" | "tags" | "capabilities" | "meta">): AgentKind {
   if (input.kind) return input.kind;
   if (input.id === "user") return "user";
@@ -2418,10 +2409,6 @@ function runtimeTokenJtisFromMeta(meta: Record<string, unknown>): string[] {
   return [...jtis];
 }
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 // --- Tasks ---
 const TASK_SELECT = "SELECT * FROM tasks";
@@ -5241,6 +5228,18 @@ export function updateWorkspaceStatus(id: string, status: WorkspaceStatus, metad
   return getWorkspace(id);
 }
+// Repoint a workspace row at a recycled branch after a land-and-continue merge
+// (#206): the worktree switched to a fresh branch cut from the advanced base, so
+// the row must track the new branch (else the next merge command targets a branch
+// that no longer exists) and the new base sha. No-op if the row is gone.
+export function setWorkspaceBranch(id: string, branch: string, baseSha?: string): WorkspaceRecord | null {
+  const existing = getWorkspace(id);
+  if (!existing) return null;
+  db.query(`UPDATE workspaces SET branch = ?, base_sha = coalesce(?, base_sha), updated_at = ? WHERE id = ?`)
+    .run(branch, baseSha ?? null, Date.now(), id);
+  return getWorkspace(id);
+}
 // Workspace statuses that count as "live" for stewardship — an agent owning one
 // of these is a candidate steward; the repo is worth coordinating.
 const STEWARD_LIVE_STATUSES = "'active', 'ready', 'conflict', 'review_requested', 'merge_planned'";

package/src/index.ts CHANGED Viewed

@@ -11,6 +11,7 @@ import { getCompactionWatch } from "./compaction-watch";
 import { getConfig, setConfig } from "./config-store";
 import { startConnectorStatusPoller } from "./connectors";
 import { resolve, sep } from "path";
+import { gzipSync, brotliCompressSync, constants as zlibConstants } from "node:zlib";
 import {
   VERSION,
 } from "./config";
@@ -264,8 +265,7 @@ export function createFetchHandler(
     }
     const file = Bun.file(resolved);
     if (await file.exists()) {
-      const headers = staticHeaders(requested);
-      return new Response(file, { headers });
+      return await serveStaticFile(req, resolved, requested, file);
     }
     return Response.json({ error: "not found" }, { status: 404 });
@@ -275,13 +275,108 @@ export function createFetchHandler(
   };
 }
+// In-memory compressed-variant cache, keyed by absolute path. Invalidated when
+// the file's mtime/size changes, so a rebuilt bundle is recompressed on next
+// request. The single-file dashboard bundle (~10 MB unminified) is served
+// uncompressed by Bun.serve otherwise; brotli/gzip cuts it ~6-7x on the wire,
+// which is the dominant cost over high-latency links. Further wins (minify,
+// code-split) tracked in #200 / #201.
+type CompressedVariant = { body: Uint8Array; encoding: "br" | "gzip" };
+const compressedCache = new Map<
+  string,
+  { mtimeMs: number; size: number; br?: Uint8Array; gzip?: Uint8Array }
+>();
+const COMPRESSIBLE = /\.(html|js|css|svg|json|webmanifest|map)$/;
+function isCompressible(pathname: string): boolean {
+  return pathname === "/" || pathname.endsWith("/") || COMPRESSIBLE.test(pathname);
+}
+function negotiateEncoding(req: Request): "br" | "gzip" | null {
+  const accept = req.headers.get("accept-encoding") ?? "";
+  if (/\bbr\b/.test(accept)) return "br";
+  if (/\bgzip\b/.test(accept)) return "gzip";
+  return null;
+}
+async function getCompressedVariant(
+  resolved: string,
+  mtimeMs: number,
+  size: number,
+  encoding: "br" | "gzip",
+  raw: () => Promise<Uint8Array>,
+): Promise<CompressedVariant> {
+  let entry = compressedCache.get(resolved);
+  if (!entry || entry.mtimeMs !== mtimeMs || entry.size !== size) {
+    entry = { mtimeMs, size };
+    compressedCache.set(resolved, entry);
+  }
+  const cached = entry[encoding];
+  if (cached) return { body: cached, encoding };
+  const data = await raw();
+  const body =
+    encoding === "br"
+      ? brotliCompressSync(data, {
+          params: {
+            // Quality 5 ~ near-gzip CPU, much better ratio; this runs once per
+            // file version then serves from cache, so cost is amortized away.
+            [zlibConstants.BROTLI_PARAM_QUALITY]: 5,
+            [zlibConstants.BROTLI_PARAM_SIZE_HINT]: data.byteLength,
+          },
+        })
+      : gzipSync(data, { level: 6 });
+  entry[encoding] = body;
+  return { body, encoding };
+}
+async function serveStaticFile(
+  req: Request,
+  resolved: string,
+  requested: string,
+  file: ReturnType<typeof Bun.file>,
+): Promise<Response> {
+  const stat = await file.stat();
+  const headers = staticHeaders(requested);
+  // Strong-ish validator from mtime + size; encoding-suffixed so a client never
+  // gets a 304 for a variant it didn't store.
+  const baseTag = `${stat.mtime.getTime().toString(36)}-${stat.size.toString(36)}`;
+  const encoding = isCompressible(requested) ? negotiateEncoding(req) : null;
+  const etag = `"${baseTag}${encoding ? `-${encoding}` : ""}"`;
+  headers.set("ETag", etag);
+  if (req.headers.get("if-none-match") === etag) {
+    return new Response(null, { status: 304, headers });
+  }
+  if (encoding) {
+    const { body } = await getCompressedVariant(
+      resolved,
+      stat.mtime.getTime(),
+      stat.size,
+      encoding,
+      () => file.bytes(),
+    );
+    headers.set("Content-Encoding", encoding);
+    headers.set("Vary", "Accept-Encoding");
+    headers.set("Content-Length", String(body.byteLength));
+    // Uint8Array is a valid BodyInit at runtime in Bun; the DOM lib types omit it.
+    return new Response(body as unknown as BodyInit, { headers });
+  }
+  return new Response(file, { headers });
+}
 function staticHeaders(pathname: string): Headers {
   const headers = new Headers();
   const contentType = staticContentType(pathname);
   if (contentType) headers.set("Content-Type", contentType);
-  if (pathname === "/sw.js") {
+  // The shell + PWA control files must always revalidate (ETag makes this a
+  // cheap 304 when unchanged). Hashing isn't available — viteSingleFile inlines
+  // everything into index.html — so no immutable long-cache assets exist.
+  if (pathname === "/sw.js" || pathname === "/manifest.webmanifest") {
     headers.set("Cache-Control", "no-cache");
-  } else if (pathname === "/manifest.webmanifest") {
+  } else if (pathname === "/" || pathname.endsWith("/") || pathname.endsWith(".html")) {
     headers.set("Cache-Control", "no-cache");
   }
   return headers;