bisque-cli 0.2.2

package/dist/index.js

@@ -0,0 +1,4737 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../sdk/src/client/workspaces.ts
+var init_workspaces = __esm({
+  "../sdk/src/client/workspaces.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/errors.ts
+var BisqueApiError, PlanLimitError, PickupModeDeniedError, WorkspaceContextRequiredError, RoleDeniedError, WorkspaceScopeDeniedError, InviteRedeemFailedError;
+var init_errors = __esm({
+  "../sdk/src/errors.ts"() {
+    "use strict";
+    BisqueApiError = class extends Error {
+      statusCode;
+      constructor(message, statusCode) {
+        super(message);
+        this.name = "BisqueApiError";
+        this.statusCode = statusCode;
+      }
+    };
+    PlanLimitError = class extends BisqueApiError {
+      constructor(code, plan, limit, extras) {
+        const statusCode = code === "QUOTA_EXCEEDED" ? 429 : 403;
+        super(code, statusCode);
+        this.code = code;
+        this.plan = plan;
+        this.limit = limit;
+        this.extras = extras;
+        this.name = "PlanLimitError";
+      }
+    };
+    PickupModeDeniedError = class extends BisqueApiError {
+      constructor(expected, actual, message = "Task pickup mode does not match claimant class") {
+        super(message, 403);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = "PickupModeDeniedError";
+      }
+    };
+    WorkspaceContextRequiredError = class extends BisqueApiError {
+      reason;
+      constructor(message = "X-Bisque-Workspace-Id header is required", reason) {
+        super(message, 400);
+        this.name = "WorkspaceContextRequiredError";
+        this.reason = reason;
+      }
+    };
+    RoleDeniedError = class extends BisqueApiError {
+      constructor(expected, actual, message) {
+        super(message ?? `Role '${actual}' insufficient; '${expected}' required`, 403);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = "RoleDeniedError";
+      }
+    };
+    WorkspaceScopeDeniedError = class extends BisqueApiError {
+      constructor(expected, actual, message) {
+        super(message ?? `Token scoped to workspace '${expected}'; request targets '${actual}'`, 403);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = "WorkspaceScopeDeniedError";
+      }
+    };
+    InviteRedeemFailedError = class extends BisqueApiError {
+      constructor(reason, message) {
+        super(message ?? `Invite redemption failed: ${reason}`, 409);
+        this.reason = reason;
+        this.name = "InviteRedeemFailedError";
+      }
+    };
+  }
+});
+
+// ../sdk/src/client.ts
+function normalizeApiEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+var BISQUE_PROD_API_ORIGIN;
+var init_client = __esm({
+  "../sdk/src/client.ts"() {
+    "use strict";
+    init_workspaces();
+    init_errors();
+    init_errors();
+    BISQUE_PROD_API_ORIGIN = "https://api.bisquelayer.com";
+  }
+});
+
+// ../sdk/src/metadata-kv.ts
+function parseMetadataPair(raw) {
+  if (raw === void 0 || raw === null) {
+    return { ok: false, error: "Metadata flag value is required (expected k=v)" };
+  }
+  const eqIdx = raw.indexOf("=");
+  if (eqIdx === -1) {
+    return {
+      ok: false,
+      error: `Invalid --metadata-set value "${raw}": expected k=v (first '=' splits key from value).`
+    };
+  }
+  const key = raw.slice(0, eqIdx);
+  if (key.length === 0) {
+    return {
+      ok: false,
+      error: `Invalid --metadata-set value "${raw}": key cannot be empty.`
+    };
+  }
+  return { ok: true, parsed: { key, value: raw.slice(eqIdx + 1) } };
+}
+function collectMetadataPair(raw, previous) {
+  const result = parseMetadataPair(raw);
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return { ...previous, [result.parsed.key]: result.parsed.value };
+}
+function collectUnsetKey(raw, previous) {
+  if (raw.length === 0) {
+    throw new Error("--metadata-unset key cannot be empty");
+  }
+  return [...previous, raw];
+}
+var init_metadata_kv = __esm({
+  "../sdk/src/metadata-kv.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/attribution.ts
+var init_attribution = __esm({
+  "../sdk/src/swarm/attribution.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/branch-names.ts
+var init_branch_names = __esm({
+  "../sdk/src/swarm/branch-names.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/classifier.ts
+var init_classifier = __esm({
+  "../sdk/src/swarm/classifier.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/content-shape.ts
+function escapeLiteral(s) {
+  return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+function handleDoubleStar(regexSoFar, glob, i) {
+  const prevSlash = i > 0 && glob.charAt(i - 1) === "/";
+  const nextIsSlash = glob.charAt(i + 2) === "/";
+  if (prevSlash && nextIsSlash) {
+    return { regex: `${regexSoFar.slice(0, -1)}(?:/.*)?/`, advance: 3 };
+  }
+  if (nextIsSlash) {
+    return { regex: `${regexSoFar}(?:.*/)?`, advance: 3 };
+  }
+  if (prevSlash) {
+    return { regex: `${regexSoFar.slice(0, -1)}(?:/.*)?`, advance: 2 };
+  }
+  return { regex: `${regexSoFar}.*`, advance: 2 };
+}
+function globToRegex(glob) {
+  let regex = "^";
+  let i = 0;
+  while (i < glob.length) {
+    const c = glob.charAt(i);
+    if (c !== "*") {
+      regex += escapeLiteral(c);
+      i += 1;
+      continue;
+    }
+    const isDouble = glob.charAt(i + 1) === "*";
+    if (isDouble) {
+      const result = handleDoubleStar(regex, glob, i);
+      regex = result.regex;
+      i += result.advance;
+      continue;
+    }
+    regex += "[^/]*";
+    i += 1;
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+var FORCING_GLOBS, FORCING_REGEXES;
+var init_content_shape = __esm({
+  "../sdk/src/swarm/content-shape.ts"() {
+    "use strict";
+    FORCING_GLOBS = ["packages/skills/**/*.md", "**/AGENTS.md", "docs/**/*.md", "*/CLAUDE.md"];
+    FORCING_REGEXES = FORCING_GLOBS.map((glob) => ({
+      glob,
+      regex: globToRegex(glob)
+    }));
+  }
+});
+
+// ../sdk/src/swarm/kill-switch.ts
+var init_kill_switch = __esm({
+  "../sdk/src/swarm/kill-switch.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/parallel-cap.ts
+var init_parallel_cap = __esm({
+  "../sdk/src/swarm/parallel-cap.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/verify-cmd.ts
+var init_verify_cmd = __esm({
+  "../sdk/src/swarm/verify-cmd.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/wave-planner.ts
+var init_wave_planner = __esm({
+  "../sdk/src/swarm/wave-planner.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/swarm/index.ts
+var init_swarm = __esm({
+  "../sdk/src/swarm/index.ts"() {
+    "use strict";
+    init_attribution();
+    init_branch_names();
+    init_classifier();
+    init_content_shape();
+    init_kill_switch();
+    init_parallel_cap();
+    init_verify_cmd();
+    init_wave_planner();
+  }
+});
+
+// ../sdk/src/util/retry.ts
+var DEFAULT_OCC_RETRY_DENYLIST, DEFAULT_OCC_BACKOFF;
+var init_retry = __esm({
+  "../sdk/src/util/retry.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_OCC_RETRY_DENYLIST = Object.freeze([
+      /^POST \/v1\/workspaces\/join$/,
+      /^PATCH \/v1\/workspaces\/[^/]+\/members\/[^/]+$/,
+      /^DELETE \/v1\/workspaces\/[^/]+\/members\/[^/]+$/,
+      /^POST \/v1\/workspaces\/[^/]+\/ownership-transfer$/,
+      /^DELETE \/v1\/workspaces\/[^/]+$/
+    ]);
+    DEFAULT_OCC_BACKOFF = Object.freeze({
+      initial: 250,
+      multiplier: 4,
+      jitter: 0.5
+    });
+  }
+});
+
+// ../sdk/src/util/workspace-header.ts
+function formatWorkspaceHeader(input) {
+  const annotation = input.type === "personal" ? `${input.role}, personal` : input.role;
+  return `[workspace: ${input.name} (${annotation})]`;
+}
+var init_workspace_header = __esm({
+  "../sdk/src/util/workspace-header.ts"() {
+    "use strict";
+  }
+});
+
+// ../sdk/src/index.ts
+var init_src = __esm({
+  "../sdk/src/index.ts"() {
+    "use strict";
+    init_workspaces();
+    init_client();
+    init_errors();
+    init_metadata_kv();
+    init_swarm();
+    init_retry();
+    init_workspace_header();
+  }
+});
+
+// src/config.ts
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_CONFIG, WORKSPACES_CACHE_TTL_MS, Config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_src();
+    DEFAULT_CONFIG = {
+      apiEndpoint: BISQUE_PROD_API_ORIGIN,
+      webAppUrl: "https://bisquelayer.com",
+      environment: "prod"
+    };
+    WORKSPACES_CACHE_TTL_MS = 5 * 60 * 1e3;
+    Config = class {
+      configDir;
+      configPath;
+      constructor(configDir) {
+        this.configDir = configDir ?? join(homedir(), ".bisque");
+        this.configPath = join(this.configDir, "config.json");
+      }
+      async get(key) {
+        if (key === "apiEndpoint" && process.env["BISQUE_API_ENDPOINT"]) {
+          return normalizeApiEndpoint(process.env["BISQUE_API_ENDPOINT"]);
+        }
+        if (key === "webAppUrl" && process.env["BISQUE_WEB_APP_URL"]) {
+          return process.env["BISQUE_WEB_APP_URL"];
+        }
+        if (key === "authToken" && process.env["BISQUE_AUTH_TOKEN"]) {
+          return process.env["BISQUE_AUTH_TOKEN"];
+        }
+        const config = await this.load();
+        if (key === "apiEndpoint") {
+          return normalizeApiEndpoint(config.apiEndpoint);
+        }
+        return config[key];
+      }
+      async set(key, value) {
+        const config = await this.load();
+        if (key === "apiEndpoint" && typeof value === "string") {
+          config[key] = normalizeApiEndpoint(value);
+        } else {
+          config[key] = value;
+        }
+        await this.save(config);
+      }
+      async getAll() {
+        return this.load();
+      }
+      async load() {
+        try {
+          const raw = await readFile(this.configPath, "utf-8");
+          return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+        } catch {
+          return { ...DEFAULT_CONFIG };
+        }
+      }
+      async save(config) {
+        await mkdir(this.configDir, { recursive: true, mode: 448 });
+        await writeFile(this.configPath, JSON.stringify(config, null, 2), {
+          encoding: "utf-8",
+          mode: 384
+        });
+        if (process.platform !== "win32") {
+          await chmod(this.configPath, 384);
+        }
+      }
+    };
+  }
+});
+
+// src/utils/runtime-context.ts
+function setRuntimeContext(ctx) {
+  runtime = ctx;
+}
+function getCurrentWorkspaceContext() {
+  return runtime.workspaceContext;
+}
+function getCurrentWorkspaceId() {
+  return runtime.workspaceContext?.workspaceId;
+}
+function getHeaderPreferences() {
+  return { enabled: runtime.headerEnabled, quiet: runtime.quiet };
+}
+function getRuntimeConfig() {
+  return runtime.config;
+}
+var runtime;
+var init_runtime_context = __esm({
+  "src/utils/runtime-context.ts"() {
+    "use strict";
+    runtime = { headerEnabled: true, quiet: false };
+  }
+});
+
+// src/utils/workspace-context.ts
+var workspace_context_exports = {};
+__export(workspace_context_exports, {
+  __resetStorageAttributionForTests: () => __resetStorageAttributionForTests,
+  formatWorkspaceHeader: () => formatWorkspaceHeader,
+  getSelfUserId: () => getSelfUserId,
+  getWorkspacesCache: () => getWorkspacesCache,
+  maybeEmitFirstWriteNote: () => maybeEmitFirstWriteNote,
+  printWorkspaceHeader: () => printWorkspaceHeader,
+  refreshWorkspacesCache: () => refreshWorkspacesCache,
+  resolveWorkspaceContext: () => resolveWorkspaceContext,
+  resolveWorkspaceId: () => resolveWorkspaceId
+});
+function __resetStorageAttributionForTests() {
+  storageAttributionFiredThisProcess = false;
+}
+function resolveWorkspaceId(flagValue) {
+  if (flagValue !== void 0 && flagValue !== "") {
+    return { workspaceId: flagValue, source: "flag" };
+  }
+  const env = process.env["BISQUE_WORKSPACE_ID"];
+  if (env !== void 0 && env !== "") {
+    return { workspaceId: env, source: "env" };
+  }
+  return { workspaceId: void 0, source: "default" };
+}
+function findInCache(cache, workspaceId) {
+  if (!cache) return void 0;
+  return cache.workspaces.find((w) => w.workspaceId === workspaceId);
+}
+function isCacheFresh(cachedAt) {
+  if (!cachedAt) return false;
+  const cachedMs = Date.parse(cachedAt);
+  if (Number.isNaN(cachedMs)) return false;
+  return Date.now() - cachedMs < WORKSPACES_CACHE_TTL_MS;
+}
+async function refreshWorkspacesCache(config) {
+  const client = new ApiClient(config);
+  const response = await client.get("/v1/me/workspaces");
+  await config.set("workspacesCache", response);
+  await config.set("activeWorkspaceCachedAt", (/* @__PURE__ */ new Date()).toISOString());
+  return response;
+}
+async function getWorkspacesCache(config) {
+  const token = await config.get("authToken");
+  if (!token) return void 0;
+  const all = await config.getAll();
+  if (all.workspacesCache && isCacheFresh(all.activeWorkspaceCachedAt)) {
+    return all.workspacesCache;
+  }
+  try {
+    return await refreshWorkspacesCache(config);
+  } catch {
+    return all.workspacesCache;
+  }
+}
+function findPersonalDefault(cache) {
+  if (!cache) return void 0;
+  return cache.workspaces.find((w) => w.isPersonal);
+}
+async function resolveWorkspaceContext(config, flagValue) {
+  const { workspaceId: explicit, source: explicitSource } = resolveWorkspaceId(flagValue);
+  const cache = await getWorkspacesCache(config);
+  if (explicit) {
+    const item = findInCache(cache, explicit);
+    if (item) {
+      return {
+        workspaceId: item.workspaceId,
+        name: item.name,
+        role: item.role,
+        type: item.isPersonal ? "personal" : "shared",
+        source: explicitSource
+      };
+    }
+    return {
+      workspaceId: explicit,
+      name: explicit,
+      role: "viewer",
+      type: "shared",
+      source: explicitSource
+    };
+  }
+  const configActive = await config.get("activeWorkspaceId");
+  if (configActive) {
+    const item = findInCache(cache, configActive);
+    if (item) {
+      return {
+        workspaceId: item.workspaceId,
+        name: item.name,
+        role: item.role,
+        type: item.isPersonal ? "personal" : "shared",
+        source: "config"
+      };
+    }
+  }
+  const personal = findPersonalDefault(cache);
+  if (personal) {
+    return {
+      workspaceId: personal.workspaceId,
+      name: personal.name,
+      role: personal.role,
+      type: "personal",
+      source: "default"
+    };
+  }
+  return void 0;
+}
+function printWorkspaceHeader(ctx, options = {}) {
+  if (!ctx) return;
+  if (options.quiet) return;
+  const header = formatWorkspaceHeader({ name: ctx.name, role: ctx.role, type: ctx.type });
+  if (options.enabled === false) {
+    process.stderr.write(`${header}
+`);
+    return;
+  }
+  console.log(header);
+}
+async function fetchStorageUsage(config) {
+  try {
+    const client = new ApiClient(config);
+    const me = await client.get("/v1/auth/me");
+    const used = me.usage?.storageMb;
+    const limit = me.limits?.storageMb;
+    if (typeof used !== "number" || typeof limit !== "number") return void 0;
+    return { used, limit };
+  } catch {
+    return void 0;
+  }
+}
+async function maybeEmitFirstWriteNote(ctx, options, config) {
+  if (storageAttributionFiredThisProcess) return;
+  if (!ctx) return;
+  if (ctx.type !== "shared") return;
+  if (options.quiet) return;
+  if (options.json) return;
+  storageAttributionFiredThisProcess = true;
+  const header = formatWorkspaceHeader({ name: ctx.name, role: ctx.role, type: ctx.type });
+  const usage = await fetchStorageUsage(config);
+  const usageClause = usage ? ` (${usage.used} / ${usage.limit} MB used)` : "";
+  process.stderr.write(
+    `${header} Writing to shared workspace "${ctx.name}" \u2014 counts against your personal storage quota${usageClause}.
+`
+  );
+}
+async function getSelfUserId(config) {
+  try {
+    const client = new ApiClient(config);
+    const me = await client.get("/v1/auth/me");
+    return me.userId;
+  } catch {
+    return void 0;
+  }
+}
+var storageAttributionFiredThisProcess;
+var init_workspace_context = __esm({
+  "src/utils/workspace-context.ts"() {
+    "use strict";
+    init_src();
+    init_config();
+    init_api_client();
+    init_src();
+    storageAttributionFiredThisProcess = false;
+  }
+});
+
+// src/utils/api-client.ts
+var api_client_exports = {};
+__export(api_client_exports, {
+  ApiClient: () => ApiClient,
+  __resetMembershipMutationFlagForTests: () => __resetMembershipMutationFlagForTests,
+  consumeMembershipMutationFlag: () => consumeMembershipMutationFlag
+});
+function consumeMembershipMutationFlag() {
+  const flagged = membershipMutatedThisProcess;
+  membershipMutatedThisProcess = false;
+  return flagged;
+}
+function __resetMembershipMutationFlagForTests() {
+  membershipMutatedThisProcess = false;
+}
+var membershipMutatedThisProcess, ApiClient;
+var init_api_client = __esm({
+  "src/utils/api-client.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_context();
+    membershipMutatedThisProcess = false;
+    ApiClient = class {
+      config;
+      maxRetries = 3;
+      retryDelays = [100, 200, 400];
+      // Exponential backoff in ms
+      workspaceId;
+      constructor(config, options) {
+        this.config = config ?? new Config();
+        this.workspaceId = options?.workspaceId ?? getCurrentWorkspaceId();
+      }
+      /**
+       * Build the per-request header bag. Extracted from `fetch()` to keep
+       * the request loop body under Biome's cognitive-complexity ceiling.
+       */
+      buildHeaders(options, authToken) {
+        const hasBody = options?.body !== void 0 && options.body !== null;
+        const headers = {};
+        if (hasBody) headers["Content-Type"] = "application/json";
+        if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+        if (this.workspaceId !== void 0 && this.workspaceId !== "") {
+          headers["X-Bisque-Workspace-Id"] = this.workspaceId;
+        }
+        return headers;
+      }
+      /**
+       * Inspect the response headers for the `X-Workspace-Membership-Mutated`
+       * signal and trip the per-process flag. Defensive on `response.headers`
+       * because test mocks may not surface a Headers-shaped object.
+       */
+      observeMembershipMutationHeader(response) {
+        if (!response.headers || typeof response.headers.get !== "function") return;
+        const mutatedHeader = response.headers.get("x-workspace-membership-mutated");
+        if (mutatedHeader === "true") {
+          membershipMutatedThisProcess = true;
+        }
+      }
+      async fetch(path2, options) {
+        const apiEndpoint = await this.config.get("apiEndpoint");
+        const authToken = await this.config.get("authToken");
+        const url = `${apiEndpoint}${path2}`;
+        const headers = this.buildHeaders(options, authToken);
+        let lastError = null;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+          try {
+            const response = await globalThis.fetch(url, {
+              ...options,
+              headers: {
+                ...headers,
+                ...options?.headers
+              }
+            });
+            this.observeMembershipMutationHeader(response);
+            if (response.status === 401) {
+              throw new Error(
+                "Authentication failed. Your session may have expired. Please login again."
+              );
+            }
+            if (response.status === 500 || response.status === 503) {
+              if (attempt < this.maxRetries - 1) {
+                console.error(
+                  `Server error (${response.status}), retrying... (attempt ${attempt + 1}/${this.maxRetries})`
+                );
+                await this.delay(this.retryDelays[attempt] ?? 400);
+                continue;
+              }
+              const errorBody = await response.text();
+              throw new Error(`Server error after ${this.maxRetries} attempts: ${errorBody}`);
+            }
+            if (!response.ok) {
+              const errorBody = await response.text();
+              throw new Error(`API request failed (${response.status}): ${errorBody}`);
+            }
+            return response;
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (lastError.message.includes("Authentication failed")) {
+              throw lastError;
+            }
+            if (this.isNetworkError(error)) {
+              if (attempt < this.maxRetries - 1) {
+                console.error(`Network error, retrying... (attempt ${attempt + 1}/${this.maxRetries})`);
+                await this.delay(this.retryDelays[attempt] ?? 400);
+                continue;
+              }
+              const message = this.getNetworkErrorMessage(apiEndpoint, error);
+              throw new Error(message);
+            }
+            throw lastError;
+          }
+        }
+        throw lastError ?? new Error("Request failed after all retries");
+      }
+      isNetworkError(error) {
+        if (!(error instanceof Error)) return false;
+        const message = error.message.toLowerCase();
+        return message.includes("fetch failed") || message.includes("network") || message.includes("econnrefused") || message.includes("timeout") || message.includes("enotfound");
+      }
+      getNetworkErrorMessage(apiEndpoint, error) {
+        if (!(error instanceof Error)) return `Network error: ${String(error)}`;
+        const message = error.message.toLowerCase();
+        if (message.includes("econnrefused")) {
+          return `Cannot connect to API server at ${apiEndpoint}`;
+        }
+        if (message.includes("timeout")) {
+          return `Request timed out after 30 seconds`;
+        }
+        if (message.includes("enotfound")) {
+          return `Cannot resolve hostname: ${apiEndpoint}`;
+        }
+        return `Network error: ${error.message}`;
+      }
+      delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      async get(path2) {
+        const response = await this.fetch(path2, { method: "GET" });
+        return response.json();
+      }
+      async post(path2, body) {
+        await this.maybeEmitFirstWriteNote();
+        const response = await this.fetch(path2, {
+          method: "POST",
+          body: JSON.stringify(body)
+        });
+        if (response.status === 204) {
+          return void 0;
+        }
+        return response.json();
+      }
+      async put(path2, body) {
+        await this.maybeEmitFirstWriteNote();
+        const response = await this.fetch(path2, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        return response.json();
+      }
+      async patch(path2, body) {
+        await this.maybeEmitFirstWriteNote();
+        const response = await this.fetch(path2, {
+          method: "PATCH",
+          body: JSON.stringify(body)
+        });
+        return response.json();
+      }
+      async delete(path2) {
+        await this.maybeEmitFirstWriteNote();
+        const response = await this.fetch(path2, { method: "DELETE" });
+        if (response.status === 204) {
+          return void 0;
+        }
+        try {
+          return await response.json();
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * Fire the per-process first-write storage-attribution note when the
+       * resolved workspace is shared. Idempotent across all `ApiClient`
+       * instances within a process. Lazily imported to avoid an early
+       * circular dependency (workspace-context.ts imports ApiClient too).
+       *
+       * Suppressed when:
+       *   - The resolved workspace is personal (writes don't cross quotas).
+       *   - `--quiet` is set (caller wants pristine output).
+       *   - The caller is in JSON mode (the note would corrupt JSON parsing
+       *     — detected via the `--json` heuristic on the header preference;
+       *     the runtime-context singleton doesn't surface json-mode today,
+       *     so callers that pipe `--json` should also pass `--quiet`).
+       *
+       * Per-process flag is owned by `workspace-context.ts`'s
+       * `maybeEmitFirstWriteNote`.
+       */
+      async maybeEmitFirstWriteNote() {
+        const ctx = getCurrentWorkspaceContext();
+        if (!ctx) return;
+        if (ctx.type !== "shared") return;
+        const { quiet } = getHeaderPreferences();
+        const config = getRuntimeConfig() ?? this.config;
+        const { maybeEmitFirstWriteNote: maybeEmitFirstWriteNote2 } = await Promise.resolve().then(() => (init_workspace_context(), workspace_context_exports));
+        await maybeEmitFirstWriteNote2(ctx, { quiet }, config);
+      }
+    };
+  }
+});
+
+// src/index.ts
+import { createRequire } from "node:module";
+import { Command, Option as Option3 } from "commander";
+
+// src/commands/add.ts
+init_api_client();
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename } from "node:path";
+function slugify(name) {
+  return name.trim().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
+}
+function deriveFilepath(filename, options) {
+  if (options.project) {
+    return `1-Projects/${slugify(options.project)}/${filename}`;
+  }
+  if (options.area) {
+    return `2-Areas/${slugify(options.area)}/${filename}`;
+  }
+  if (options.resource) {
+    return `3-Resources/${slugify(options.resource)}/${filename}`;
+  }
+  return `0-Inbox/${filename}`;
+}
+function categoryFromPath(filepath) {
+  if (filepath.startsWith("0-Inbox/")) return "inbox";
+  if (filepath.startsWith("1-Projects/")) return "project";
+  if (filepath.startsWith("2-Areas/")) return "area";
+  if (filepath.startsWith("3-Resources/")) return "resource";
+  if (filepath.startsWith("4-Archive/")) return "archive";
+  return "inbox";
+}
+function parseMetadataJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { error: "Error: --metadata must be a JSON object" };
+    }
+    return { value: parsed };
+  } catch {
+    return { error: "Error: --metadata must be valid JSON" };
+  }
+}
+async function resolveContent(file, options) {
+  if (options.content) {
+    if (!options.title) {
+      return { error: "Error: --title is required when using --content" };
+    }
+    return { title: options.title, content: options.content };
+  }
+  if (file) {
+    const content = await readFile2(file, "utf-8");
+    return { title: options.title ?? basename(file), content };
+  }
+  return { error: "Error: provide a file path or use --content with --title" };
+}
+function parseDocIdList(val) {
+  return val.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function buildCreateBody(resolved, filepath, category, options, metadata) {
+  return {
+    title: resolved.title,
+    filepath,
+    category,
+    tags: options.tags ?? [],
+    content: resolved.content,
+    ...metadata && { metadata },
+    // Freshness & Staleness v1 (T3). Pass through verbatim; backend
+    // enum gates `status`, supersedes array is accepted on create.
+    ...options.status !== void 0 && { status: options.status },
+    ...options.supersedes !== void 0 && { supersedes: options.supersedes }
+  };
+}
+function registerAddCommand(program2) {
+  program2.command("add [file]").description("Add a document from a local file or inline content").option("-p, --project <name>", "Place document under a PARA project").option("-a, --area <name>", "Place document under a PARA area").option("-r, --resource <name>", "Place document under a PARA resource").option(
+    "-t, --tags <tags>",
+    "Comma-separated tags",
+    (val) => val.split(",").map((t) => t.trim())
+  ).option("--filepath <path>", "Explicit PARA filepath (overrides --project/--area/--resource)").option("--content <text>", "Inline content (skip file reading)").option("--title <name>", "Document title (required with --content)").option("--metadata <json>", "JSON metadata object").option("--status <status>", "Lifecycle state: live | superseded | archived. Defaults to live.").option(
+    "--supersedes <docIds>",
+    "Comma-separated doc UUIDs this doc supersedes. Optional on create.",
+    parseDocIdList
+  ).action(async (file, options) => {
+    try {
+      const resolved = await resolveContent(file, options);
+      if ("error" in resolved) {
+        console.error(resolved.error);
+        process.exitCode = 1;
+        return;
+      }
+      let metadata;
+      if (options.metadata) {
+        const result = parseMetadataJson(options.metadata);
+        if ("error" in result) {
+          console.error(result.error);
+          process.exitCode = 1;
+          return;
+        }
+        metadata = result.value;
+      }
+      const filepath = options.filepath ?? deriveFilepath(resolved.title, options);
+      const category = categoryFromPath(filepath);
+      const client = new ApiClient();
+      const createResult = await client.post(
+        "/v1/documents",
+        buildCreateBody(resolved, filepath, category, options, metadata)
+      );
+      console.log(`Document created: ${createResult.documentId}`);
+      console.log(`  Path: ${filepath}`);
+      console.log(`  Category: ${category}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/agents-md/sections.ts
+var KEYWORDS_SENTINEL = "<!-- bisque-keywords:mechanical -->";
+var CONTENT_EXTRACT_TARGET = 280;
+var CONTENT_EXTRACT_HARD_MAX = 400;
+function normalizeDir(dirPath) {
+  return dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+}
+function basename2(filepath) {
+  const parts = filepath.split("/");
+  return parts[parts.length - 1] ?? filepath;
+}
+function stripFrontmatter(body) {
+  if (!body.startsWith("---\n")) return body;
+  const end = body.indexOf("\n---", 4);
+  return end === -1 ? body : body.slice(end + 4);
+}
+function findFirstParagraphLines(body) {
+  const paragraph = [];
+  let inCodeBlock = false;
+  let started = false;
+  for (const rawLine of body.split("\n")) {
+    const line = rawLine.trimEnd();
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    if (line.startsWith("#")) {
+      if (started) break;
+      continue;
+    }
+    if (line.trim() === "") {
+      if (started) break;
+      continue;
+    }
+    paragraph.push(line.trim());
+    started = true;
+  }
+  return paragraph;
+}
+function truncateAtSentenceBoundary(text) {
+  if (text.length <= CONTENT_EXTRACT_TARGET) return text;
+  const window = text.slice(0, CONTENT_EXTRACT_HARD_MAX);
+  let bestIdx = -1;
+  for (const ch of [".", "!", "?"]) {
+    const idx = window.lastIndexOf(`${ch} `, CONTENT_EXTRACT_TARGET);
+    if (idx > bestIdx) bestIdx = idx;
+  }
+  if (bestIdx > CONTENT_EXTRACT_TARGET / 2) {
+    return `${text.slice(0, bestIdx + 1)} \u2026`;
+  }
+  return `${text.slice(0, CONTENT_EXTRACT_TARGET).trim()}\u2026`;
+}
+function extractFirstParagraph(content) {
+  if (!content) return void 0;
+  const body = stripFrontmatter(content);
+  const lines = findFirstParagraphLines(body);
+  if (lines.length === 0) return void 0;
+  const text = lines.join(" ").replace(/\s+/g, " ").trim();
+  if (text.length === 0) return void 0;
+  return truncateAtSentenceBoundary(text);
+}
+function extractPurposeLine(content) {
+  if (!content) return void 0;
+  const match = content.match(/^\*\*Purpose:\*\*\s+(.+)$/m);
+  if (!match) return void 0;
+  const purpose = match[1]?.trim();
+  if (!purpose) return void 0;
+  if (purpose === "_(describe this directory)_") return void 0;
+  return purpose;
+}
+function renderFileOutline(name, doc) {
+  const summary = doc.summary?.trim();
+  const body = summary && summary.length > 0 ? summary : extractFirstParagraph(doc.content) ?? "_(no description)_";
+  return `### ${name}
+${body}`;
+}
+function renderSubdirOutline(dir, subdirName, docs) {
+  const subdir = `${dir}${subdirName}/`;
+  const childAgents = docs.find((d) => d.filepath === `${subdir}AGENTS.md`);
+  const purpose = extractPurposeLine(childAgents?.content);
+  const childFiles = [];
+  for (const d of docs) {
+    if (!d.filepath.startsWith(subdir)) continue;
+    const rest = d.filepath.slice(subdir.length);
+    if (rest.includes("/")) continue;
+    if (rest === "AGENTS.md") continue;
+    childFiles.push(rest);
+  }
+  childFiles.sort();
+  const headLine = `### ${subdirName}/`;
+  const purposeLine = purpose ?? "_(no purpose set)_";
+  const contentsBlock = childFiles.length === 0 ? "Contents: _(none)_" : `Contents:
+${childFiles.map((f) => `- ${f}`).join("\n")}`;
+  return `${headLine}
+${purposeLine}
+
+${contentsBlock}`;
+}
+function generateWhatsHereSection(dirPath, docs) {
+  const dir = normalizeDir(dirPath);
+  const inDir = docs.filter((d) => {
+    if (!d.filepath.startsWith(dir)) return false;
+    const rest = d.filepath.slice(dir.length);
+    if (rest.includes("/")) return false;
+    if (rest === "AGENTS.md") return false;
+    return true;
+  });
+  if (inDir.length === 0) {
+    return "## What's here\n_(empty)_";
+  }
+  inDir.sort((a, b) => basename2(a.filepath).localeCompare(basename2(b.filepath)));
+  const blocks = inDir.map((d) => renderFileOutline(basename2(d.filepath), d));
+  return `## What's here
+${blocks.join("\n\n")}`;
+}
+function generateHeader(dirPath) {
+  const trimmed = dirPath.endsWith("/") ? dirPath.slice(0, -1) : dirPath;
+  const parts = trimmed.split("/").filter(Boolean);
+  const title = parts[parts.length - 1] ?? trimmed;
+  const parent = parts.length <= 1 ? "_(workspace root)_" : `${parts.slice(0, -1).join("/")}/`;
+  return `# ${title}
+
+**Purpose:** _(describe this directory)_
+**Parent:** ${parent}`;
+}
+function generateSubdirectoriesSection(dirPath, docs) {
+  const dir = normalizeDir(dirPath);
+  const subdirs = /* @__PURE__ */ new Set();
+  for (const d of docs) {
+    if (!d.filepath.startsWith(dir)) continue;
+    const rest = d.filepath.slice(dir.length);
+    const slashIdx = rest.indexOf("/");
+    if (slashIdx === -1) continue;
+    subdirs.add(rest.slice(0, slashIdx));
+  }
+  if (subdirs.size === 0) {
+    return "## Subdirectories\n_(none)_";
+  }
+  const sorted = [...subdirs].sort();
+  const blocks = sorted.map((s) => renderSubdirOutline(dir, s, docs));
+  return `## Subdirectories
+${blocks.join("\n\n")}`;
+}
+function generateKeywordsSection(docs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const d of docs) {
+    const all = [...d.keywords ?? [], ...d.tags ?? []];
+    const fileName = basename2(d.filepath);
+    for (const term of all) {
+      if (typeof term !== "string" || term.length === 0) continue;
+      const key = term.toLowerCase();
+      let entry = groups.get(key);
+      if (!entry) {
+        entry = { variants: [], files: /* @__PURE__ */ new Set() };
+        groups.set(key, entry);
+      }
+      entry.variants.push(term);
+      entry.files.add(fileName);
+    }
+  }
+  const rows = [];
+  for (const entry of groups.values()) {
+    const sortedVariants = [...entry.variants].sort();
+    const display = sortedVariants[0];
+    const files = [...entry.files].sort();
+    rows.push({ display, files });
+  }
+  rows.sort((a, b) => {
+    const la = a.display.toLowerCase();
+    const lb = b.display.toLowerCase();
+    if (la < lb) return -1;
+    if (la > lb) return 1;
+    return 0;
+  });
+  if (rows.length === 0) {
+    return `## Keywords
+${KEYWORDS_SENTINEL}
+_(no keywords)_`;
+  }
+  const bullets = rows.map((r) => `- ${r.display} \u2014 ${r.files.join(", ")}`).join("\n");
+  return `## Keywords
+${KEYWORDS_SENTINEL}
+${bullets}`;
+}
+
+// src/agents-md/merge.ts
+var IF_WORKING_HERE_TITLE = "If you're working here";
+var KEYWORDS_TITLE = "Keywords";
+var NOTES_FOR_AGENTS_TITLE = "Notes for agents";
+var PRESERVE_OPEN = "<!-- bisque-preserve -->";
+var PRESERVE_CLOSE = "<!-- /bisque-preserve -->";
+var PRESERVE_FENCE_REGEX = /<!-- bisque-preserve -->[\s\S]*?<!-- \/bisque-preserve -->/g;
+function mergeAgentsMd(existing, header, mechanicals) {
+  if (!existing) {
+    return `${header}
+
+${mechanicals}
+`;
+  }
+  const sections = scanSections(existing);
+  const keywordsSection = findSection(sections, KEYWORDS_TITLE);
+  const userKeywords = keywordsSection && !isMechanicalKeywords(keywordsSection) ? trimTrailingBlank(keywordsSection.text) : null;
+  const composedMechanicals = userKeywords ? stripMechanicalKeywordsBlock(mechanicals) : mechanicals;
+  const notesSection = findSection(sections, NOTES_FOR_AGENTS_TITLE);
+  const notesBlock = notesSection ? buildWrappedNotesBlock(notesSection.text) : null;
+  const ifWorkingHereSection = findSection(sections, IF_WORKING_HERE_TITLE);
+  const ifWorkingHereBlock = ifWorkingHereSection ? trimTrailingBlank(ifWorkingHereSection.text) : null;
+  const allFenceRanges = findAllPreserveFenceRanges(existing);
+  const coveredRanges = [];
+  if (notesSection) coveredRanges.push({ start: notesSection.start, end: notesSection.end });
+  if (keywordsSection && userKeywords) {
+    coveredRanges.push({ start: keywordsSection.start, end: keywordsSection.end });
+  }
+  if (ifWorkingHereSection) {
+    coveredRanges.push({ start: ifWorkingHereSection.start, end: ifWorkingHereSection.end });
+  }
+  const otherFences = allFenceRanges.filter((r) => !coveredRanges.some((c) => r.start >= c.start && r.end <= c.end)).map((r) => existing.slice(r.start, r.end));
+  const parts = [];
+  parts.push(header);
+  parts.push(composedMechanicals);
+  if (userKeywords) parts.push(userKeywords);
+  if (notesBlock) parts.push(notesBlock);
+  for (const fence of otherFences) parts.push(fence);
+  if (ifWorkingHereBlock) parts.push(ifWorkingHereBlock);
+  return `${parts.join("\n\n")}
+`;
+}
+function updateFenceState(line, state) {
+  const trimmedLeading = line.replace(/^[ \t]+/, "");
+  const isBacktick = trimmedLeading.startsWith("```");
+  const isTilde = trimmedLeading.startsWith("~~~");
+  if (!isBacktick && !isTilde) {
+    return { state, isFenceLine: false };
+  }
+  const marker = isBacktick ? "```" : "~~~";
+  if (!state.inFence) {
+    return { state: { inFence: true, marker }, isFenceLine: true };
+  }
+  if (state.marker === marker) {
+    return { state: { inFence: false, marker: null }, isFenceLine: true };
+  }
+  return { state, isFenceLine: true };
+}
+function tryParseHeading(line) {
+  if (/^[ \t]*>/.test(line)) return null;
+  const m = /^[ \t]*##[ \t]+(.+?)[ \t]*$/.exec(line);
+  return m ? m[1] ?? "" : null;
+}
+function computeLineStarts(lines) {
+  const starts = [];
+  let offset = 0;
+  for (const line of lines) {
+    starts.push(offset);
+    offset += line.length + 1;
+  }
+  return starts;
+}
+function scanSections(text) {
+  const lines = text.split("\n");
+  const lineStarts = computeLineStarts(lines);
+  const headings = [];
+  let fenceState = { inFence: false, marker: null };
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    const fence = updateFenceState(raw, fenceState);
+    fenceState = fence.state;
+    if (fence.isFenceLine || fenceState.inFence) continue;
+    const title = tryParseHeading(raw);
+    if (title === null) continue;
+    headings.push({ title, byteStart: lineStarts[i] ?? 0 });
+  }
+  const sections = [];
+  for (let h = 0; h < headings.length; h++) {
+    const current = headings[h];
+    const next = headings[h + 1];
+    const end = next ? next.byteStart : text.length;
+    sections.push({
+      title: current.title,
+      start: current.byteStart,
+      end,
+      text: text.slice(current.byteStart, end)
+    });
+  }
+  return sections;
+}
+function findSection(sections, title) {
+  for (const s of sections) {
+    if (s.title === title) return s;
+  }
+  return null;
+}
+function isMechanicalKeywords(section) {
+  const lines = section.text.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") continue;
+    return line === KEYWORDS_SENTINEL;
+  }
+  return true;
+}
+function stripMechanicalKeywordsBlock(mechanicals) {
+  const sections = scanSections(mechanicals);
+  const kw = findSection(sections, KEYWORDS_TITLE);
+  if (!kw) return mechanicals;
+  if (!isMechanicalKeywords(kw)) return mechanicals;
+  let removeStart = kw.start;
+  let removeEnd = kw.end;
+  if (removeStart >= 2 && mechanicals.slice(removeStart - 2, removeStart) === "\n\n") {
+    removeStart -= 1;
+  }
+  if (removeEnd < mechanicals.length && mechanicals[removeEnd] === "\n") {
+    removeEnd += 1;
+  }
+  const out = mechanicals.slice(0, removeStart) + mechanicals.slice(removeEnd);
+  return out.replace(/\n+$/, "");
+}
+function buildWrappedNotesBlock(sectionText) {
+  const trimmed = trimTrailingBlank(sectionText);
+  const lines = trimmed.split("\n");
+  const heading = lines[0] ?? `## ${NOTES_FOR_AGENTS_TITLE}`;
+  const body = lines.slice(1).join("\n");
+  if (body.includes(PRESERVE_OPEN) && body.includes(PRESERVE_CLOSE)) {
+    return trimmed;
+  }
+  const bodyTrimmedLeading = body.replace(/^\n+/, "");
+  if (bodyTrimmedLeading.length === 0) {
+    return `${heading}
+${PRESERVE_OPEN}
+${PRESERVE_CLOSE}`;
+  }
+  return `${heading}
+${PRESERVE_OPEN}
+${bodyTrimmedLeading}
+${PRESERVE_CLOSE}`;
+}
+function findAllPreserveFenceRanges(text) {
+  const ranges = [];
+  const re = new RegExp(PRESERVE_FENCE_REGEX.source, PRESERVE_FENCE_REGEX.flags);
+  let m = re.exec(text);
+  while (m) {
+    ranges.push({ start: m.index, end: m.index + m[0].length });
+    m = re.exec(text);
+  }
+  return ranges;
+}
+function trimTrailingBlank(s) {
+  return s.replace(/\n+$/, "");
+}
+
+// src/commands/agents.ts
+init_api_client();
+
+// src/utils/exit-codes.ts
+init_src();
+function exitWithPickupModeDeniedError(expected, actual) {
+  console.error(`Error: Task requires claimant class ${expected} but claim asserted ${actual}.`);
+  process.exit(4 /* POLICY_DENIED */);
+}
+function exitWithRoleDeniedError(err) {
+  console.error(
+    `Error: Insufficient workspace role \u2014 '${err.expected}' required, you have '${err.actual}'.`
+  );
+  process.exit(4 /* POLICY_DENIED */);
+}
+function exitWithWorkspaceScopeDeniedError(err) {
+  console.error(
+    `Error: OAuth token is scoped to workspace '${err.expected}', but the request targets '${err.actual}'. Switch workspaces in the host app or re-issue the token.`
+  );
+  process.exit(4 /* POLICY_DENIED */);
+}
+function exitWithWorkspaceContextRequiredError(err) {
+  const detail = err.message ? `: ${err.message}` : "";
+  console.error(
+    `Error: Workspace context required${detail}. Re-run with --workspace <id>, set BISQUE_WORKSPACE_ID, or use 'bisque workspace switch <id>'.`
+  );
+  process.exit(5 /* WORKSPACE_CONTEXT_REQUIRED */);
+}
+function exitWithInviteRedeemFailedError(err) {
+  const reasonText = {
+    "not-found": "Invite code not found \u2014 check for typos.",
+    expired: "Invite code has expired.",
+    revoked: "Invite code has been revoked.",
+    exhausted: "Invite code has no remaining redemptions.",
+    "transaction-conflict": "Transient race redeeming invite \u2014 retry shortly."
+  };
+  const human = reasonText[err.reason] ?? `Invite redemption failed: ${err.reason}`;
+  console.error(`Error: ${human}`);
+  process.exit(6 /* INVITE_REDEEM_FAILED */);
+}
+function parsePickupModeDeniedFromMessage(message) {
+  if (!message.includes("403") || !message.includes("pickup-mode-denied")) return null;
+  const jsonStart = message.indexOf("{");
+  if (jsonStart === -1) return null;
+  try {
+    const body = JSON.parse(message.slice(jsonStart));
+    if (body["error"] !== "pickup-mode-denied") return null;
+    if (typeof body["expected"] !== "string" || typeof body["actual"] !== "string") return null;
+    return {
+      expected: body["expected"],
+      actual: body["actual"]
+    };
+  } catch {
+    return null;
+  }
+}
+function parseEnvelopeFromMessage(message, expectedStatus, expectedError) {
+  if (!message.includes(`${expectedStatus}`) || !message.includes(expectedError)) return null;
+  const jsonStart = message.indexOf("{");
+  if (jsonStart === -1) return null;
+  try {
+    const body = JSON.parse(message.slice(jsonStart));
+    if (body["error"] !== expectedError) return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+function exitWithPlanLimitError(err) {
+  if (err.code === "QUOTA_EXCEEDED") {
+    const used = err.extras["used"] ?? "?";
+    const limit = err.extras["limit"] ?? err.limit;
+    const resetsAt = err.extras["resetsAt"] ?? "next month";
+    console.error(`Bisque: monthly API quota exceeded (${used}/${limit}).`);
+    console.error(`        Reads still work; writes resume at ${resetsAt}.`);
+    console.error(`        Pro access is invite-only \u2014 request: mailto:beta@bisque.app`);
+  } else {
+    const gate = err.extras["gate"] ?? "plan";
+    console.error(`Bisque: ${err.code} (${gate} limit on ${err.plan}).`);
+    console.error(`        Pro access is invite-only \u2014 request: mailto:beta@bisque.app`);
+  }
+  process.exit(1 /* GENERAL_ERROR */);
+}
+function tryTypedInstanceBranches(error) {
+  if (error instanceof PickupModeDeniedError) {
+    exitWithPickupModeDeniedError(error.expected, error.actual);
+  }
+  if (error instanceof RoleDeniedError) {
+    exitWithRoleDeniedError(error);
+  }
+  if (error instanceof WorkspaceScopeDeniedError) {
+    exitWithWorkspaceScopeDeniedError(error);
+  }
+  if (error instanceof WorkspaceContextRequiredError) {
+    exitWithWorkspaceContextRequiredError(error);
+  }
+  if (error instanceof InviteRedeemFailedError) {
+    exitWithInviteRedeemFailedError(error);
+  }
+  if (error instanceof PlanLimitError) {
+    exitWithPlanLimitError(error);
+  }
+  return false;
+}
+function tryRoleDeniedDecoder(message) {
+  const parsed = parseEnvelopeFromMessage(message, 403, "role-denied");
+  if (!parsed) return;
+  if (typeof parsed["expected"] !== "string" || typeof parsed["actual"] !== "string") return;
+  exitWithRoleDeniedError(
+    new RoleDeniedError(
+      parsed["expected"],
+      parsed["actual"],
+      typeof parsed["message"] === "string" ? parsed["message"] : void 0
+    )
+  );
+}
+function tryWorkspaceScopeDeniedDecoder(message) {
+  const parsed = parseEnvelopeFromMessage(message, 403, "workspace-scope-denied");
+  if (!parsed) return;
+  if (typeof parsed["expected"] !== "string" || typeof parsed["actual"] !== "string") return;
+  exitWithWorkspaceScopeDeniedError(
+    new WorkspaceScopeDeniedError(
+      parsed["expected"],
+      parsed["actual"],
+      typeof parsed["message"] === "string" ? parsed["message"] : void 0
+    )
+  );
+}
+function tryWorkspaceContextRequiredDecoder(message) {
+  const parsed = parseEnvelopeFromMessage(message, 400, "workspace-context-required");
+  if (!parsed) return;
+  const ctxMessage = typeof parsed["message"] === "string" ? parsed["message"] : void 0;
+  exitWithWorkspaceContextRequiredError(new WorkspaceContextRequiredError(ctxMessage));
+}
+function tryInviteRedeemFailedDecoder(message) {
+  const parsed = parseEnvelopeFromMessage(message, 409, "invite-redeem-failed");
+  if (!parsed) return;
+  if (typeof parsed["reason"] !== "string") return;
+  exitWithInviteRedeemFailedError(
+    new InviteRedeemFailedError(
+      parsed["reason"],
+      typeof parsed["message"] === "string" ? parsed["message"] : void 0
+    )
+  );
+}
+function tryEnvelopeMessageDecoders(message) {
+  const parsedPickup = parsePickupModeDeniedFromMessage(message);
+  if (parsedPickup) {
+    exitWithPickupModeDeniedError(parsedPickup.expected, parsedPickup.actual);
+  }
+  tryRoleDeniedDecoder(message);
+  tryWorkspaceScopeDeniedDecoder(message);
+  tryWorkspaceContextRequiredDecoder(message);
+  tryInviteRedeemFailedDecoder(message);
+  return false;
+}
+function exitWithError(error) {
+  tryTypedInstanceBranches(error);
+  const message = error instanceof Error ? error.message : String(error);
+  tryEnvelopeMessageDecoders(message);
+  if (message.includes("Authentication failed") || message.includes("Unauthorized")) {
+    console.error(`Error: ${message}`);
+    process.exit(2 /* AUTH_ERROR */);
+  }
+  if (message.includes("not found") || message.includes("Not found")) {
+    console.error(`Error: ${message}`);
+    process.exit(3 /* NOT_FOUND */);
+  }
+  console.error(`Error: ${message}`);
+  process.exit(1 /* GENERAL_ERROR */);
+}
+
+// src/commands/agents.ts
+function normalizeDir2(p) {
+  return p.endsWith("/") ? p : `${p}/`;
+}
+async function listAllDocsUnderPrefix(client, dir) {
+  const all = [];
+  let cursor;
+  const encodedPrefix = encodeURIComponent(dir);
+  do {
+    const qs = cursor ? `?pathPrefix=${encodedPrefix}&limit=200&cursor=${encodeURIComponent(cursor)}` : `?pathPrefix=${encodedPrefix}&limit=200`;
+    const page = await client.get(`/v1/documents${qs}`);
+    all.push(...page.items ?? []);
+    cursor = page.cursor;
+  } while (cursor);
+  return all;
+}
+function isVersionConflictError(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message;
+  return msg.includes("409") && msg.includes("version-conflict");
+}
+function composeAgentsContent(dir, items) {
+  const docs = items.map((d) => ({
+    filepath: d.filepath,
+    title: d.title,
+    summary: d.summary,
+    // Pass through content so the renderer can fall back to a
+    // first-paragraph extract when `summary` is empty, and so the
+    // `## Subdirectories` outline can read each child AGENTS.md's
+    // `**Purpose:**` line.
+    content: d.content,
+    keywords: d.keywords,
+    tags: d.tags
+  }));
+  const inDirDocs = docs.filter((d) => {
+    if (!d.filepath.startsWith(dir)) return false;
+    const rest = d.filepath.slice(dir.length);
+    if (rest.includes("/")) return false;
+    if (rest === "AGENTS.md") return false;
+    return true;
+  });
+  const existingDoc = items.find((d) => d.filepath === `${dir}AGENTS.md`);
+  const header = generateHeader(dir);
+  const mechanicals = `${generateWhatsHereSection(dir, docs)}
+
+${generateSubdirectoriesSection(dir, docs)}
+
+${generateKeywordsSection(inDirDocs)}`;
+  const nextContent = mergeAgentsMd(existingDoc?.content ?? null, header, mechanicals);
+  return nextContent;
+}
+async function postAgentsMd(client, dir, items) {
+  const content = composeAgentsContent(dir, items);
+  await client.post("/v1/documents", {
+    title: "AGENTS.md",
+    content,
+    filepath: `${dir}AGENTS.md`
+  });
+}
+async function retryAfterVersionConflict(client, dir) {
+  const refreshedItems = await listAllDocsUnderPrefix(client, dir);
+  const refreshedExisting = refreshedItems.find((d) => d.filepath === `${dir}AGENTS.md`);
+  if (!refreshedExisting) {
+    await postAgentsMd(client, dir, refreshedItems);
+    return;
+  }
+  const freshContent = composeAgentsContent(dir, refreshedItems);
+  await client.put(`/v1/documents/${refreshedExisting.documentId}`, {
+    content: freshContent,
+    expectedVersion: refreshedExisting.version
+  });
+}
+async function refreshOneDirectory(client, dirPath) {
+  const dir = normalizeDir2(dirPath);
+  try {
+    const items = await listAllDocsUnderPrefix(client, dir);
+    const existingDoc = items.find((d) => d.filepath === `${dir}AGENTS.md`);
+    const nextContent = composeAgentsContent(dir, items);
+    if (existingDoc) {
+      let retried = false;
+      try {
+        await client.put(`/v1/documents/${existingDoc.documentId}`, {
+          content: nextContent,
+          expectedVersion: existingDoc.version
+        });
+      } catch (err) {
+        if (!isVersionConflictError(err)) throw err;
+        retried = true;
+        await retryAfterVersionConflict(client, dir);
+      }
+      return {
+        status: "refreshed",
+        path: dir,
+        mode: retried ? "updated-after-retry" : "updated"
+      };
+    }
+    await postAgentsMd(client, dir, items);
+    return { status: "refreshed", path: dir, mode: "created" };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { status: "failed", path: dir, reason };
+  }
+}
+async function refreshAgentsMd(dirPath, json) {
+  const client = new ApiClient();
+  const outcome = await refreshOneDirectory(client, dirPath);
+  if (outcome.status === "failed") {
+    exitWithError(new Error(outcome.reason ?? "refresh failed"));
+    return;
+  }
+  const mode = outcome.mode === "created" ? "created" : "updated";
+  if (json) {
+    console.log(JSON.stringify({ path: outcome.path, mode }));
+  } else {
+    console.log(`AGENTS.md ${mode} at ${outcome.path}`);
+  }
+}
+function discoverDirectories(root, items) {
+  const dirs = /* @__PURE__ */ new Set();
+  dirs.add(root);
+  for (const doc of items) {
+    const fp = doc.filepath;
+    const lastSlash = fp.lastIndexOf("/");
+    if (lastSlash < 0) continue;
+    const parent = `${fp.slice(0, lastSlash)}/`;
+    if (!parent.startsWith(root)) continue;
+    dirs.add(parent);
+  }
+  return Array.from(dirs).sort((a, b) => a.localeCompare(b));
+}
+async function refreshAgentsTree(rootPath, json) {
+  const summary = { refreshed: [], skipped: [], failed: [] };
+  try {
+    const client = new ApiClient();
+    const root = normalizeDir2(rootPath);
+    let allDocs;
+    try {
+      allDocs = await listAllDocsUnderPrefix(client, root);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      summary.failed.push({ path: root, reason });
+      emitTreeSummary(summary, json);
+      process.exitCode = 1;
+      return;
+    }
+    const directories = discoverDirectories(root, allDocs);
+    for (const dir of directories) {
+      const outcome = await refreshOneDirectory(client, dir);
+      if (outcome.status === "refreshed") {
+        summary.refreshed.push(outcome.path);
+      } else if (outcome.status === "skipped") {
+        summary.skipped.push(outcome.path);
+      } else {
+        summary.failed.push({
+          path: outcome.path,
+          reason: outcome.reason ?? "unknown"
+        });
+      }
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    summary.failed.push({ path: rootPath, reason });
+  }
+  emitTreeSummary(summary, json);
+  if (summary.failed.length > 0) {
+    process.exitCode = 1;
+  }
+}
+function emitTreeSummary(summary, json) {
+  if (json) {
+    console.log(JSON.stringify(summary));
+  } else {
+    console.log(JSON.stringify(summary, null, 2));
+  }
+}
+function registerAgentsCommand(program2) {
+  const agents = program2.command("agents").description("Maintain per-directory AGENTS.md files");
+  agents.command("refresh <path>").description("Regenerate the mechanical sections of AGENTS.md at <path>").option("--json", "Output raw JSON result").action(async (path2, options) => {
+    await refreshAgentsMd(path2, options.json ?? false);
+  });
+  agents.command("refresh-tree <root>").description("Recursively refresh AGENTS.md across every directory under <root>").option("--no-json", "Pretty-print the summary instead of emitting a single-line JSON object").action(async (root, options) => {
+    await refreshAgentsTree(root, options.json !== false);
+  });
+}
+
+// src/commands/auth.ts
+init_config();
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+function registerAuthCommand(program2) {
+  const authCmd = program2.command("auth").description("Manage authentication");
+  authCmd.command("login").description("Authenticate with Bisque via browser OAuth").option("-f, --force", "Force re-authentication even if already logged in").action(async (options) => {
+    const config = new Config();
+    const existingToken = await config.get("authToken");
+    if (existingToken && !options.force) {
+      console.log("Already authenticated. Use --force to re-authenticate.");
+      return;
+    }
+    console.log("Starting authentication flow...");
+    const state = randomBytes(32).toString("base64url");
+    const { server, portReady, codePromise } = startCallbackServer(state);
+    const port = await portReady;
+    const redirectUri = `http://127.0.0.1:${port}/callback`;
+    const webAppUrl = await config.get("webAppUrl");
+    const loginUrl = `${webAppUrl}/cli-link?redirect_uri=${encodeURIComponent(redirectUri)}&state=${encodeURIComponent(state)}`;
+    console.log("Opening browser for authentication...");
+    console.log(`If the browser doesn't open, visit: ${loginUrl}
+`);
+    const { default: open } = await import("open");
+    await open(loginUrl);
+    let code;
+    try {
+      code = await codePromise;
+    } finally {
+      server.close();
+    }
+    const apiEndpoint = await config.get("apiEndpoint");
+    const exchangeUrl = `${apiEndpoint}/v1/auth/exchange`;
+    const res = await fetch(exchangeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      console.error(`Exchange failed (${res.status}): ${body}`);
+      process.exitCode = 1;
+      return;
+    }
+    const parsed = await res.json();
+    await config.set("authToken", parsed.key);
+    console.log("Authentication successful! API key stored.");
+  });
+  authCmd.command("logout").description("Clear stored authentication token").action(async () => {
+    const config = new Config();
+    const token = await config.get("authToken");
+    if (!token) {
+      console.log("Not currently authenticated.");
+      return;
+    }
+    await config.set("authToken", void 0);
+    console.log("Logged out successfully. Token cleared.");
+  });
+  authCmd.command("status").description("Show current authentication status").action(async () => {
+    const config = new Config();
+    const token = await config.get("authToken");
+    const endpoint = await config.get("apiEndpoint");
+    if (!token) {
+      console.log("Status: Not authenticated");
+      console.log("Run `bisque auth login` to authenticate.");
+      return;
+    }
+    const masked = `${token.slice(0, 8)}...${"*".repeat(8)}`;
+    console.log(`Token:  ${masked}`);
+    console.log(`API:    ${endpoint}`);
+    try {
+      const { ApiClient: ApiClient2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+      const client = new ApiClient2(config);
+      const me = await client.get("/v1/auth/me");
+      console.log(`User:   ${me.userId}`);
+      console.log("Status: Authenticated");
+    } catch {
+      console.log("Status: Token stored but could not verify (server may be unreachable)");
+    }
+  });
+}
+function startCallbackServer(expectedState) {
+  let resolveCode;
+  let rejectCode;
+  const codePromise = new Promise((resolve, reject) => {
+    resolveCode = resolve;
+    rejectCode = reject;
+  });
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== "/callback") {
+      res.writeHead(404);
+      res.end("Not found");
+      return;
+    }
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (!code || !state) {
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h1>Authentication failed</h1><p>Missing code or state in callback.</p></body></html>"
+      );
+      rejectCode(new Error("Missing code or state in callback"));
+      return;
+    }
+    if (state !== expectedState) {
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h1>Authentication failed</h1><p>CSRF state mismatch.</p></body></html>"
+      );
+      rejectCode(new Error("CSRF state mismatch \u2014 aborting for safety"));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end("<html><body><h1>Signed in.</h1><p>You can close this tab.</p></body></html>");
+    resolveCode(code);
+  });
+  const portReady = new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(addr.port);
+    });
+  });
+  const timeout = setTimeout(() => {
+    rejectCode(new Error("Authentication timed out after 2 minutes"));
+    server.close();
+  }, 12e4);
+  server.on("close", () => {
+    clearTimeout(timeout);
+  });
+  return { server, portReady, codePromise };
+}
+
+// src/commands/batch.ts
+init_api_client();
+import chalk from "chalk";
+function printDocuments(docs) {
+  if (!docs || docs.length === 0) return;
+  for (const doc of docs) {
+    console.log(chalk.blue(`--- ${doc.filepath} ---`));
+    console.log(chalk.dim(`Title: ${doc.title}`));
+    console.log(doc.content);
+    console.log();
+  }
+}
+function printList(items, label, color) {
+  if (!items || items.length === 0) return;
+  console.log(color(`${label}:`));
+  for (const item of items) {
+    console.log(color(`  ${item}`));
+  }
+}
+function registerBatchCommand(program2) {
+  program2.command("batch <filepaths...>").description("Fetch multiple documents by filepath in a single call").option("--workspace <id>", "Workspace ID", "default").option("--json", "Output as JSON").action(
+    async (filepaths, options) => {
+      try {
+        const client = new ApiClient();
+        const result = await client.post("/v1/documents/batch", {
+          filepaths,
+          workspace: options.workspace
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        printDocuments(result.documents);
+        printList(result.missing, "Missing", chalk.yellow);
+        printList(result.failed, "Failed", chalk.red);
+      } catch (err) {
+        exitWithError(err);
+      }
+    }
+  );
+}
+
+// src/commands/bulk-add.ts
+init_api_client();
+import { readdir, readFile as readFile3, stat } from "node:fs/promises";
+import { basename as basename3, join as join2, relative } from "node:path";
+function slugify2(name) {
+  return name.trim().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
+}
+async function findFiles(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await findFiles(fullPath);
+      results.push(...nested);
+    } else if (entry.isFile() && /\.(md|txt)$/i.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function buildDocument(file, directory, content, options) {
+  const filename = basename3(file);
+  const relativePath = relative(directory, file);
+  const prefix = options.project ? `1-Projects/${slugify2(options.project)}` : "4-Archive";
+  const filepath = `${prefix}/${relativePath}`;
+  const category = options.project ? "project" : "archive";
+  return { title: filename, filepath, category, tags: options.tags ?? [], content };
+}
+async function buildBatch(files, directory, options) {
+  const documents = [];
+  for (const file of files) {
+    const content = await readFile3(file, "utf-8");
+    documents.push(buildDocument(file, directory, content, options));
+  }
+  return documents;
+}
+var BATCH_SIZE = 25;
+async function executeBulkAdd(directory, options) {
+  const dirStat = await stat(directory);
+  if (!dirStat.isDirectory()) {
+    console.error(`Error: ${directory} is not a directory`);
+    process.exitCode = 1;
+    return;
+  }
+  const files = await findFiles(directory);
+  if (files.length === 0) {
+    console.log("No .md or .txt files found.");
+    return;
+  }
+  const client = new ApiClient();
+  let uploaded = 0;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const documents = await buildBatch(batch, directory, options);
+    await client.post("/v1/documents/bulk", { documents });
+    uploaded += documents.length;
+    console.log(`Progress: ${uploaded}/${files.length}`);
+  }
+  console.log(`Done. Added ${uploaded} documents.`);
+}
+function registerBulkAddCommand(program2) {
+  program2.command("bulk-add <directory>").description("Recursively add .md and .txt files from a directory").option("-p, --project <name>", "Place all documents under a PARA project").option(
+    "-t, --tags <tags>",
+    "Comma-separated tags",
+    (val) => val.split(",").map((t) => t.trim())
+  ).action(async (directory, options) => {
+    try {
+      await executeBulkAdd(directory, options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/chain.ts
+init_api_client();
+import chalk2 from "chalk";
+import Table from "cli-table3";
+
+// src/utils/metadata-kv.ts
+init_src();
+
+// src/commands/chain.ts
+function formatMetadataInline(metadata) {
+  const inline = JSON.stringify(metadata);
+  if (inline.length <= 80) {
+    return inline;
+  }
+  return `
+${JSON.stringify(metadata, null, 2).split("\n").map((line) => `  ${line}`).join("\n")}`;
+}
+function buildOtherFieldBody(options) {
+  const body = {};
+  if (options.status) body["status"] = options.status;
+  if (options.name) body["name"] = options.name;
+  if (options.content) body["content"] = options.content;
+  if (options.projectPath) body["projectPath"] = options.projectPath;
+  if (options.referenceDocs) {
+    body["referenceDocs"] = options.referenceDocs.split(",").map((s) => s.trim());
+  }
+  return body;
+}
+function printChainDetails(chain) {
+  console.log(chalk2.bold("\nChain Details\n"));
+  console.log(`${chalk2.cyan("Name:")}          ${chain.name}`);
+  console.log(`${chalk2.cyan("Status:")}        ${chain.status}`);
+  console.log(`${chalk2.cyan("ID:")}            ${chain.documentId}`);
+  if (chain.projectPath) {
+    console.log(`${chalk2.cyan("Project Path:")} ${chain.projectPath}`);
+  }
+  if (chain.content) {
+    console.log(`${chalk2.cyan("Content:")}       ${chain.content}`);
+  }
+  if (chain.referenceDocs && chain.referenceDocs.length > 0) {
+    console.log(`${chalk2.cyan("Reference Docs:")} ${chain.referenceDocs.join(", ")}`);
+  }
+  if (chain.dependencyChainIds && chain.dependencyChainIds.length > 0) {
+    console.log(`${chalk2.cyan("Dependencies:")}  ${chain.dependencyChainIds.join(", ")}`);
+  }
+  if (chain.metadata && Object.keys(chain.metadata).length > 0) {
+    console.log(`${chalk2.cyan("Metadata:")}      ${formatMetadataInline(chain.metadata)}`);
+  }
+  if (chain.createdAt) {
+    console.log(`${chalk2.cyan("Created:")}       ${new Date(chain.createdAt).toLocaleString()}`);
+  }
+  if (chain.updatedAt) {
+    console.log(`${chalk2.cyan("Updated:")}       ${new Date(chain.updatedAt).toLocaleString()}`);
+  }
+}
+function printChainTasks(tasks) {
+  if (!tasks || tasks.length === 0) return;
+  console.log(chalk2.bold("\nTasks\n"));
+  const taskTable = new Table({
+    head: [chalk2.cyan("Order"), chalk2.cyan("Title"), chalk2.cyan("Status"), chalk2.cyan("ID")],
+    style: {
+      head: [],
+      border: ["gray"]
+    }
+  });
+  for (const task of tasks) {
+    taskTable.push([
+      task.chainOrder != null ? String(task.chainOrder) : "-",
+      task.title,
+      task.status,
+      task.documentId
+    ]);
+  }
+  console.log(taskTable.toString());
+}
+var VALID_CHAIN_STATUSES = ["active", "completed", "cancelled"];
+function validateChainUpdateInputs(options) {
+  if (options.status && !VALID_CHAIN_STATUSES.includes(options.status)) {
+    return `Error: --status must be one of: ${VALID_CHAIN_STATUSES.join(", ")} (got "${options.status}").`;
+  }
+  const hasSet = Object.keys(options.metadataSet ?? {}).length > 0;
+  const hasUnset = (options.metadataUnset ?? []).length > 0;
+  const hasMetadataMutation = hasSet || hasUnset;
+  const hasOtherFields = Object.keys(buildOtherFieldBody(options)).length > 0;
+  if (!hasOtherFields && !hasMetadataMutation) {
+    return "Error: Provide at least one field to update (--status, --name, --content, --project-path, --reference-docs, --metadata-set, --metadata-unset).";
+  }
+  if (hasMetadataMutation && hasOtherFields) {
+    return "Error: --metadata-set / --metadata-unset cannot be combined with other field updates. Issue two separate updates.";
+  }
+  return null;
+}
+async function putChainMetadataMutation(client, chainId, options) {
+  const body = {};
+  const setEntries = options.metadataSet ?? {};
+  const unsetKeys = options.metadataUnset ?? [];
+  if (Object.keys(setEntries).length > 0) body["metadataSet"] = setEntries;
+  if (unsetKeys.length > 0) body["metadataUnset"] = unsetKeys;
+  const result = await client.put(`/v1/task-chains/${chainId}`, body);
+  console.log(`Chain ${result.documentId} updated.`);
+  if (result.metadata) {
+    console.log(`Metadata: ${formatMetadataInline(result.metadata)}`);
+  }
+}
+async function putChainOtherFields(client, chainId, options) {
+  const result = await client.put(
+    `/v1/task-chains/${chainId}`,
+    buildOtherFieldBody(options)
+  );
+  console.log(`Chain ${result.documentId} updated.`);
+  if (result.status) {
+    console.log(`Status: ${result.status}`);
+  }
+}
+function isMetadataMutationRequest(options) {
+  const hasSet = Object.keys(options.metadataSet ?? {}).length > 0;
+  const hasUnset = (options.metadataUnset ?? []).length > 0;
+  return hasSet || hasUnset;
+}
+function registerChainCommand(program2) {
+  const chain = program2.command("chain").description("Manage task chains");
+  chain.command("create").description("Create a task chain").requiredOption("--name <name>", "Chain name").requiredOption("--content <content>", "Workstream description").option("--project-path <path>", "PARA project path").option("--reference-docs <docIds>", "Comma-separated doc UUIDs").option("--dependency-chain-ids <ids>", "Comma-separated prerequisite chain UUIDs").option(
+    "--metadata <k=v>",
+    "Repeatable. Free-form metadata pair. First '=' splits key from value; quote the value to preserve embedded '='.",
+    collectMetadataPair,
+    {}
+  ).addHelpText(
+    "after",
+    `
+Examples:
+  $ bisque chain create --name "Build API" --content "Description"
+  $ bisque chain create --name "Swarm chain" --content "..." \\
+      --metadata contentShape=mechanical \\
+      --metadata verifyCmd=./scripts/ci-check.sh
+`
+  ).action(
+    async (options) => {
+      try {
+        const client = new ApiClient();
+        const body = {
+          name: options.name,
+          content: options.content
+        };
+        if (options.projectPath) {
+          body["projectPath"] = options.projectPath;
+        }
+        if (options.referenceDocs) {
+          body["referenceDocs"] = options.referenceDocs.split(",").map((s) => s.trim());
+        }
+        if (options.dependencyChainIds) {
+          body["dependencyChainIds"] = options.dependencyChainIds.split(",").map((s) => s.trim());
+        }
+        if (options.metadata && Object.keys(options.metadata).length > 0) {
+          body["metadata"] = options.metadata;
+        }
+        const result = await client.post("/v1/task-chains", body);
+        console.log(`Chain created: ${result.documentId}`);
+        console.log(`Name: ${result.name}`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  chain.command("list").description("List task chains").option("--status <status>", "Filter: active, completed, cancelled").option("--project-path <path>", "Filter by project path").option("--limit <n>", "Max results", "50").action(async (options) => {
+    try {
+      const client = new ApiClient();
+      const params = new URLSearchParams();
+      if (options.status) {
+        params.set("status", options.status);
+      }
+      if (options.projectPath) {
+        params.set("projectPath", options.projectPath);
+      }
+      params.set("limit", options.limit);
+      const queryString = params.toString();
+      const path2 = queryString ? `/v1/task-chains?${queryString}` : "/v1/task-chains";
+      const chains = await client.get(path2);
+      if (chains.length === 0) {
+        console.log(chalk2.yellow("No chains found"));
+        return;
+      }
+      const table = new Table({
+        head: [
+          chalk2.cyan("Name"),
+          chalk2.cyan("Status"),
+          chalk2.cyan("ID"),
+          chalk2.cyan("Project Path")
+        ],
+        style: {
+          head: [],
+          border: ["gray"]
+        }
+      });
+      for (const c of chains) {
+        table.push([c.name, c.status, c.documentId, c.projectPath || "-"]);
+      }
+      console.log(table.toString());
+      console.log(chalk2.gray(`
+Total: ${chains.length} chain(s)`));
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  chain.command("update <chainId>").description("Update a task chain").option("--status <status>", "New status (active|completed|cancelled)").option("--name <name>", "New name").option("--content <content>", "New content / workstream description").option("--project-path <path>", "PARA project path").option("--reference-docs <docIds>", "Comma-separated doc UUIDs").option(
+    "--metadata-set <k=v>",
+    "Repeatable. Additive metadata set (sibling keys preserved). First '=' splits key from value; quote the value to preserve embedded '='.",
+    collectMetadataPair,
+    {}
+  ).option(
+    "--metadata-unset <key>",
+    "Repeatable. Remove a single metadata key (sibling keys preserved).",
+    collectUnsetKey,
+    []
+  ).addHelpText(
+    "after",
+    `
+Examples:
+  $ bisque chain update abc12345-... --status completed
+  $ bisque chain update abc12345-... --name "New chain name"
+  $ bisque chain update abc12345-... --reference-docs doc-1,doc-2
+  $ bisque chain update abc12345-... \\
+      --metadata-set verifyCmd="./scripts/ci-check.sh --flag=x" \\
+      --metadata-unset oldKey
+
+Notes:
+  --metadata-set / --metadata-unset are additive (sibling keys preserved).
+  They cannot be combined with other field updates in the same call \u2014
+  issue a separate update for non-metadata fields.
+`
+  ).action(async (chainId, options) => {
+    try {
+      const validationError = validateChainUpdateInputs(options);
+      if (validationError) {
+        console.error(validationError);
+        process.exitCode = 1;
+        return;
+      }
+      const client = new ApiClient();
+      if (isMetadataMutationRequest(options)) {
+        await putChainMetadataMutation(client, chainId, options);
+      } else {
+        await putChainOtherFields(client, chainId, options);
+      }
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  chain.command("get <chainId>").description("Get task chain details").action(async (chainId) => {
+    try {
+      const client = new ApiClient();
+      const { chain: chain2, tasks } = await client.get(
+        `/v1/task-chains/${chainId}`
+      );
+      printChainDetails(chain2);
+      printChainTasks(tasks);
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/config.ts
+init_config();
+var VALID_KEYS = [
+  "apiEndpoint",
+  "webAppUrl",
+  "authToken",
+  "environment"
+];
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set(["authToken"]);
+function isValidKey(key) {
+  return VALID_KEYS.includes(key);
+}
+function maskSensitive(value) {
+  if (value.length < 8) return "*".repeat(8);
+  return `${value.slice(0, 8)}...${"*".repeat(8)}`;
+}
+function validateHttpUrl(key, value) {
+  try {
+    const url = new URL(value);
+    if (!url.protocol.startsWith("http")) {
+      return `Invalid ${key}. Must use HTTP or HTTPS protocol.`;
+    }
+    return null;
+  } catch {
+    return `Invalid ${key} format.`;
+  }
+}
+function registerConfigCommand(program2) {
+  const configCmd = program2.command("config").description("Manage CLI configuration");
+  configCmd.command("get <key>").description(
+    "Print a config value (sensitive values are masked; pass --reveal to print plaintext)"
+  ).option("--reveal", "Print the raw value of sensitive keys (use with care)").action(async (key, options) => {
+    if (!isValidKey(key)) {
+      console.error(`Invalid config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const config = new Config();
+    const value = await config.get(key);
+    if (value === void 0) {
+      console.log("(not set)");
+      return;
+    }
+    if (SENSITIVE_KEYS.has(key) && !options.reveal && typeof value === "string") {
+      console.log(maskSensitive(value));
+      return;
+    }
+    console.log(value);
+  });
+  configCmd.command("set <key> <value>").description("Set a config value").action(async (key, value) => {
+    if (!isValidKey(key)) {
+      console.error(`Invalid config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (key === "apiEndpoint" || key === "webAppUrl") {
+      const urlError = validateHttpUrl(key, value);
+      if (urlError) {
+        console.error(urlError);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (key === "environment") {
+      const validEnvs = ["dev", "staging", "prod"];
+      if (!validEnvs.includes(value)) {
+        console.error(`Invalid environment: ${value}. Valid values: ${validEnvs.join(", ")}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const config = new Config();
+    await config.set(key, value);
+    console.log(`Set ${key} = ${value}`);
+  });
+}
+
+// src/commands/delete.ts
+init_api_client();
+import { createInterface } from "node:readline";
+function confirm(prompt) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function registerDeleteCommand(program2) {
+  program2.command("delete <docId>").description("Delete a document by ID").option("-f, --force", "Skip confirmation prompt").action(async (docId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirm(`Delete document ${docId}? (y/N) `);
+        if (!confirmed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const client = new ApiClient();
+      await client.delete(`/v1/documents/${docId}`);
+      console.log(`Document ${docId} deleted.`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/get.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { Option } from "commander";
+
+// src/measure.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } from "node:path";
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "status",
+  "priority",
+  "chainId",
+  "chainOrder",
+  "assignedAgent",
+  "assignedAgentIds",
+  "projectPath",
+  "pathPrefix",
+  "filepath",
+  "path",
+  "limit",
+  "offset",
+  "cursor",
+  "since",
+  "by",
+  "tags",
+  "keywords",
+  "category",
+  "workspaceId",
+  "id",
+  "documentId",
+  "taskId",
+  "personaId",
+  "title",
+  "format",
+  "json",
+  "dryRun",
+  "force",
+  "recursive",
+  "verbose",
+  "query",
+  "context",
+  "slashCommand",
+  "preambleChars",
+  "references"
+]);
+var STRING_CAP = 200;
+function measurementsPath() {
+  return join3(homedir2(), ".bisque", "measurements.jsonl");
+}
+function capString(s) {
+  return s.length > STRING_CAP ? s.slice(0, STRING_CAP) : s;
+}
+function isAllowedKey(key) {
+  if (ALLOWED_KEYS.has(key)) return true;
+  return key.endsWith("Id") || key.endsWith("Ids");
+}
+function redactReference(v) {
+  if (!v || typeof v !== "object") return { path: "", chars: 0 };
+  const ref = v;
+  const path2 = typeof ref["path"] === "string" ? capString(ref["path"]) : "";
+  const chars = typeof ref["chars"] === "number" ? ref["chars"] : 0;
+  return { path: path2, chars };
+}
+function redactArrayValue(key, value) {
+  if (key === "references") return value.map(redactReference);
+  return value.map((v) => typeof v === "string" ? capString(v) : v);
+}
+function redactValue(key, value) {
+  if (typeof value === "string") return capString(value);
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (Array.isArray(value)) return redactArrayValue(key, value);
+  return "[redacted]";
+}
+function redactArgs(args) {
+  if (!args || typeof args !== "object") return {};
+  const out = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (value === void 0) continue;
+    if (!isAllowedKey(key)) {
+      out[key] = "[redacted]";
+      continue;
+    }
+    out[key] = redactValue(key, value);
+  }
+  return out;
+}
+function recordMeasurement(command, args, charsReturned) {
+  if (process.env["BISQUE_MEASURE"] !== "1") return;
+  try {
+    const path2 = measurementsPath();
+    mkdirSync(dirname(path2), { recursive: true });
+    const tokensEstimate = Math.ceil(charsReturned / 4);
+    const line = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      command,
+      args: redactArgs(args),
+      charsReturned,
+      tokensEstimate
+    });
+    appendFileSync(path2, `${line}
+`);
+  } catch {
+  }
+}
+
+// src/commands/get.ts
+init_api_client();
+function registerGetCommand(program2) {
+  program2.command("get <docId>").description("Retrieve a document by ID").option("-o, --output <file>", "Save content to a file instead of stdout").addOption(
+    new Option("--level <projection>", "Projection: outline | summary | full (default: full)").choices(["outline", "summary", "full"]).conflicts("section")
+  ).addOption(
+    new Option(
+      "--section <heading>",
+      "Slice one section by heading slug (mutually exclusive with --level)"
+    ).conflicts("level")
+  ).option(
+    "--expected-version <n>",
+    "Optional debounce hint for --section; returns 409 if the doc has been modified"
+  ).action(
+    async (docId, options) => {
+      try {
+        const client = new ApiClient();
+        const path2 = buildPath(docId, options);
+        const doc = await client.get(path2);
+        recordMeasurement(
+          "get",
+          { documentId: docId, ...options.level ? { level: options.level } : {} },
+          JSON.stringify(doc).length
+        );
+        if (options.output) {
+          const text = pickWritableText(doc);
+          await writeFile2(options.output, text, "utf-8");
+          console.log(`Document written to ${options.output}`);
+          return;
+        }
+        renderDoc(doc);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+function buildPath(docId, options) {
+  if (options.section !== void 0) {
+    const params = new URLSearchParams({ heading: options.section });
+    if (options.expectedVersion !== void 0) {
+      params.set("expectedVersion", options.expectedVersion);
+    }
+    return `/v1/documents/${docId}/section?${params.toString()}`;
+  }
+  if (options.level) {
+    return `/v1/documents/${docId}?level=${options.level}`;
+  }
+  return `/v1/documents/${docId}`;
+}
+function pickWritableText(doc) {
+  if ("view" in doc) {
+    if (doc.view === "summary") return doc.summary ?? "";
+    if (doc.view === "outline") return doc.summary ?? "";
+    if (doc.view === "section") return doc.content ?? "";
+  }
+  return doc.content ?? "";
+}
+function renderDoc(doc) {
+  if ("view" in doc && doc.view === "summary") {
+    renderSummary(doc);
+    return;
+  }
+  if ("view" in doc && doc.view === "outline") {
+    renderOutline(doc);
+    return;
+  }
+  if ("view" in doc && doc.view === "section") {
+    renderSection(doc);
+    return;
+  }
+  renderFull(doc);
+}
+function renderSummary(doc) {
+  console.log(`Title:    ${doc.title}`);
+  console.log(`Path:     ${doc.filepath}`);
+  console.log(`Category: ${doc.category}`);
+  console.log(`Tags:     ${doc.tags.length > 0 ? doc.tags.join(", ") : "(none)"}`);
+  console.log(`Version:  ${doc.version}`);
+  if (doc.createdAt) console.log(`Created:  ${doc.createdAt}`);
+  if (doc.updatedAt) console.log(`Updated:  ${doc.updatedAt}`);
+  if (doc.summary) {
+    console.log("---");
+    console.log(doc.summary);
+  }
+}
+function renderOutline(doc) {
+  console.log(`Title:    ${doc.title}`);
+  console.log(`Path:     ${doc.filepath}`);
+  console.log(`Category: ${doc.category}`);
+  console.log(`Tags:     ${doc.tags.length > 0 ? doc.tags.join(", ") : "(none)"}`);
+  console.log(`Version:  ${doc.version}`);
+  if (doc.createdAt) console.log(`Created:  ${doc.createdAt}`);
+  if (doc.updatedAt) console.log(`Updated:  ${doc.updatedAt}`);
+  console.log("---");
+  if (doc.headings.length === 0) {
+    console.log("(no headings)");
+  } else {
+    console.log("Headings:");
+    for (const h of doc.headings) {
+      const indent = "  ".repeat(Math.max(0, h.level - 1));
+      console.log(`  ${indent}${h.text}  [${h.slug}]`);
+    }
+  }
+  if (doc.links.length > 0) {
+    console.log();
+    console.log("Links:");
+    for (const link of doc.links) {
+      console.log(`  ${link}`);
+    }
+  }
+}
+function renderSection(doc) {
+  console.log(`Path:     ${doc.filepath}`);
+  console.log(`Version:  ${doc.version}`);
+  console.log(`Heading:  ${doc.heading.text}  [${doc.heading.slug}]  (H${doc.heading.level})`);
+  if (doc.prevSlug) console.log(`Prev:     ${doc.prevSlug}`);
+  if (doc.nextSlug) console.log(`Next:     ${doc.nextSlug}`);
+  console.log("---");
+  console.log(doc.content);
+}
+function renderFull(doc) {
+  console.log(`Title:    ${doc.title}`);
+  console.log(`Path:     ${doc.filepath}`);
+  console.log(`Category: ${doc.category}`);
+  console.log(`Tags:     ${doc.tags.length > 0 ? doc.tags.join(", ") : "(none)"}`);
+  if (doc.createdAt) console.log(`Created:  ${doc.createdAt}`);
+  if (doc.updatedAt) console.log(`Updated:  ${doc.updatedAt}`);
+  if (doc.metadata && Object.keys(doc.metadata).length > 0) {
+    console.log("Metadata:");
+    for (const [key, value] of Object.entries(doc.metadata)) {
+      const rendered = value !== null && typeof value === "object" ? JSON.stringify(value) : String(value);
+      console.log(`  ${key}: ${rendered}`);
+    }
+  }
+  console.log("---");
+  console.log(doc.content);
+}
+
+// src/commands/inbox.ts
+init_api_client();
+function formatItem(item) {
+  const date = item.createdAt ? new Date(item.createdAt).toLocaleDateString() : "unknown";
+  const tags = item.tags && item.tags.length > 0 ? item.tags.join(", ") : "(none)";
+  return `  ${item.title}
+    ID: ${item.documentId}
+    Date: ${date}
+    Tags: ${tags}`;
+}
+function registerInboxCommand(program2) {
+  const inbox = program2.command("inbox").description("Manage inbox items");
+  inbox.command("list").description("List all items in the Inbox").option("-l, --limit <number>", "Max items to show", "20").action(async (options) => {
+    try {
+      const client = new ApiClient();
+      const params = new URLSearchParams({
+        pathPrefix: "0-Inbox/",
+        limit: options.limit
+      });
+      const data = await client.get(`/v1/documents?${params.toString()}`);
+      if (data.items.length === 0) {
+        console.log("Inbox is empty.");
+        return;
+      }
+      for (const item of data.items) {
+        console.log(formatItem(item));
+        console.log();
+      }
+      console.log(`Total: ${data.items.length} item${data.items.length === 1 ? "" : "s"}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/link.ts
+init_api_client();
+function registerLinkCommand(program2) {
+  program2.command("link <docId> <relatedDocIds...>").description("Link a document to one or more related documents").action(async (docId, relatedDocIds) => {
+    try {
+      const client = new ApiClient();
+      await client.post(`/v1/documents/${docId}/link`, { linkedDocIds: relatedDocIds });
+      console.log(`Linked ${docId} to ${relatedDocIds.join(", ")}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/list.ts
+import chalk3 from "chalk";
+import Table2 from "cli-table3";
+init_api_client();
+function registerListCommand(program2) {
+  program2.command("list").description("List documents with optional filters").option("--path-prefix <prefix>", "Filter by path prefix").option("--filepath <path>", "Filter by exact filepath").option("--workspace <id>", "Workspace ID").option("--limit <n>", "Max results", "20").action(
+    async (options) => {
+      try {
+        const params = new URLSearchParams();
+        params.set("limit", options.limit);
+        if (options.pathPrefix) {
+          params.set("pathPrefix", options.pathPrefix);
+        }
+        if (options.filepath) {
+          params.set("filepath", options.filepath);
+        }
+        if (options.workspace) {
+          params.set("workspace", options.workspace);
+        }
+        const client = new ApiClient();
+        const response = await client.get(
+          `/v1/documents?${params.toString()}`
+        );
+        const docs = response.items ?? [];
+        recordMeasurement(
+          "list",
+          {
+            pathPrefix: options.pathPrefix,
+            filepath: options.filepath,
+            workspaceId: options.workspace,
+            limit: options.limit
+          },
+          JSON.stringify(docs).length
+        );
+        if (docs.length === 0) {
+          console.log(chalk3.yellow("No documents found."));
+          return;
+        }
+        const table = new Table2({
+          head: [chalk3.cyan("Title"), chalk3.cyan("Filepath"), chalk3.cyan("Document ID")],
+          style: { head: [], border: ["gray"] }
+        });
+        for (const doc of docs) {
+          table.push([doc.title, doc.filepath, doc.documentId]);
+        }
+        console.log(table.toString());
+        console.log(chalk3.gray(`
+Total: ${docs.length} document(s)`));
+        if (response.cursor) {
+          console.log(chalk3.gray("More results available \u2014 re-run with a larger --limit."));
+        }
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+}
+
+// src/commands/load.ts
+import chalk4 from "chalk";
+init_api_client();
+function normalize(s) {
+  return s.toLowerCase().replace(/[-_\s]/g, "");
+}
+function resolveProjectName(input, projectNames) {
+  let name = input;
+  if (name.startsWith("1-Projects/")) {
+    name = name.slice("1-Projects/".length);
+  }
+  name = name.replace(/\/+$/, "");
+  if (projectNames.includes(name)) return name;
+  const normalizedInput = normalize(name);
+  for (const projectName of projectNames) {
+    if (normalize(projectName) === normalizedInput) return projectName;
+  }
+  return null;
+}
+function registerLoadCommand(program2) {
+  program2.command("load <project>").description("Load project context (AGENTS.md + frontmind + backmind listing)").option("--workspace <id>", "Workspace ID").option("--json", "Output raw JSON").action(async (project, options) => {
+    try {
+      const client = new ApiClient();
+      const wsParam = options.workspace ? `?workspaceId=${options.workspace}` : "";
+      const structure = await client.get(
+        `/v1/workspace/structure${wsParam}`
+      );
+      const projectNames = structure.structure.projects;
+      const matchedName = resolveProjectName(project, projectNames);
+      if (!matchedName) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                projectPath: null,
+                match: "not_found",
+                input: project,
+                availableProjects: projectNames
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.error(chalk4.red(`Project not found: "${project}"`));
+          console.log(chalk4.yellow(`Available projects: ${projectNames.join(", ") || "(none)"}`));
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const projectPath = `1-Projects/${matchedName}/`;
+      const wsQuery = options.workspace ? `&workspace=${options.workspace}` : "";
+      const [agentsMdRes, frontmindRes, backmindRes] = await Promise.allSettled([
+        client.get(
+          `/v1/documents?filepath=${encodeURIComponent(`${projectPath}AGENTS.md`)}${wsQuery}`
+        ),
+        client.get(
+          `/v1/documents?pathPrefix=${encodeURIComponent(`${projectPath}frontmind/`)}${wsQuery}&limit=200`
+        ),
+        client.get(
+          `/v1/documents?pathPrefix=${encodeURIComponent(`${projectPath}backmind/`)}${wsQuery}&limit=200`
+        )
+      ]);
+      const agentsMd = agentsMdRes.status === "fulfilled" && agentsMdRes.value.items?.length > 0 ? agentsMdRes.value.items[0] : null;
+      const frontmind = frontmindRes.status === "fulfilled" ? frontmindRes.value.items ?? [] : [];
+      const backmind = backmindRes.status === "fulfilled" ? (backmindRes.value.items ?? []).map((d) => ({
+        documentId: d.documentId,
+        filepath: d.filepath,
+        title: d.title
+      })) : [];
+      const charsReturned = (agentsMd?.content?.length ?? 0) + frontmind.reduce((s, d) => s + (d.content?.length ?? 0), 0) + JSON.stringify(backmind).length;
+      recordMeasurement(
+        "load",
+        {
+          projectPath,
+          workspaceId: options.workspace,
+          json: options.json ?? false
+        },
+        charsReturned
+      );
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              projectPath,
+              agentsMd,
+              frontmind,
+              backmind,
+              availableProjects: projectNames
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(chalk4.bold.cyan(`
+=== ${matchedName} ===
+`));
+      if (agentsMd) {
+        console.log(chalk4.bold("AGENTS.md:"));
+        console.log(agentsMd.content);
+        console.log();
+      } else {
+        console.log(chalk4.yellow("No AGENTS.md found for this project.\n"));
+      }
+      if (frontmind.length > 0) {
+        console.log(chalk4.bold(`Frontmind (${frontmind.length} files):`));
+        for (const doc of frontmind) {
+          console.log(chalk4.cyan(`
+--- ${doc.filepath} ---`));
+          console.log(doc.content);
+        }
+        console.log();
+      } else {
+        console.log(chalk4.gray("No frontmind files.\n"));
+      }
+      if (backmind.length > 0) {
+        console.log(chalk4.bold(`Backmind (${backmind.length} files available):`));
+        for (const entry of backmind) {
+          console.log(chalk4.gray(`  ${entry.filepath} \u2014 ${entry.title}`));
+        }
+        console.log(chalk4.gray("\n  Use: bisque get <documentId> to load any backmind file."));
+      } else {
+        console.log(chalk4.gray("No backmind files."));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/ls.ts
+init_api_client();
+import chalk5 from "chalk";
+function formatFolder(entry) {
+  const countInfo = entry.childCount != null ? `(${entry.childCount} files)` : entry.hasChildren ? "(has children)" : "";
+  return `  ${chalk5.blue(`${entry.name}/`)}  ${chalk5.dim(countInfo)}`;
+}
+function formatFile(entry) {
+  const date = entry.updatedAt ? new Date(entry.updatedAt).toISOString().split("T")[0] : "";
+  return `  ${entry.name}  ${chalk5.dim(`"${entry.title}"`)}  ${chalk5.dim(date)}`;
+}
+function buildParams(path2, options) {
+  const params = new URLSearchParams();
+  if (path2) params.set("path", path2);
+  params.set("workspace", options.workspace);
+  params.set("limit", options.limit);
+  if (options.counts) params.set("counts", "true");
+  return params;
+}
+function displayEntries(entries) {
+  for (const entry of entries) {
+    console.log(entry.type === "folder" ? formatFolder(entry) : formatFile(entry));
+  }
+}
+function registerLsCommand(program2) {
+  program2.command("ls [path]").description("List contents of a directory in Bisque workspace").option("--workspace <id>", "Workspace ID", "default").option("--counts", "Show exact child counts for folders").option("--json", "Output as JSON").option("--limit <n>", "Max entries", "50").action(async (path2, options) => {
+    try {
+      const client = new ApiClient();
+      const params = buildParams(path2, options);
+      const result = await client.get(`/v1/documents/ls?${params.toString()}`);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const data = result;
+      if (!data.entries || data.entries.length === 0) {
+        console.log(chalk5.dim("  (empty)"));
+        return;
+      }
+      displayEntries(data.entries);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+}
+
+// src/commands/maintenance.ts
+init_api_client();
+import chalk6 from "chalk";
+function healthColor(health) {
+  switch (health) {
+    case "healthy":
+      return chalk6.green(health);
+    case "needs-attention":
+      return chalk6.yellow(health);
+    case "needs-maintenance":
+      return chalk6.red(health);
+    default:
+      return health;
+  }
+}
+function scopeLabel(scope) {
+  if (scope.filter) {
+    return `${scope.type}: ${scope.filter}`;
+  }
+  return scope.type;
+}
+function printRecommendationLine(label, count) {
+  if (count > 0) {
+    console.log(`  ${chalk6.yellow("*")} ${label}: ${count}`);
+  }
+}
+function registerMaintenanceCommand(program2) {
+  program2.command("maintenance").description("Run workspace maintenance and get health report").option("--project <path>", "Scope to a specific project path").option("--category <category>", "Scope to a PARA category").action(async (options) => {
+    try {
+      const client = new ApiClient();
+      const body = {};
+      if (options.project) {
+        body["scope"] = "project";
+        body["filter"] = options.project;
+      } else if (options.category) {
+        body["scope"] = "category";
+        body["filter"] = options.category;
+      } else {
+        body["scope"] = "workspace";
+      }
+      const report = await client.post("/v1/maintenance", body);
+      console.log();
+      console.log(chalk6.bold("Workspace Maintenance Report"));
+      console.log(`Scope: ${scopeLabel(report.scope)}  |  ${report.timestamp}`);
+      console.log();
+      const { mechanical } = report;
+      const hasMechanical = mechanical.taskLocksReleased.length > 0 || mechanical.chainsCompleted.length > 0 || mechanical.errors.length > 0;
+      if (hasMechanical) {
+        console.log(chalk6.bold("Mechanical Fixes"));
+        for (const lock of mechanical.taskLocksReleased) {
+          console.log(
+            `  ${chalk6.green("\u2713")} Released expired lock: ${lock.title} (${lock.taskId.substring(0, 8)})`
+          );
+        }
+        for (const chain of mechanical.chainsCompleted) {
+          console.log(
+            `  ${chalk6.green("\u2713")} Completed chain: ${chain.name} (${chain.chainId.substring(0, 8)})`
+          );
+        }
+        for (const err of mechanical.errors) {
+          console.log(
+            `  ${chalk6.red("\u2717")} ${err.operation} failed on ${err.entityId.substring(0, 8)}: ${err.error}`
+          );
+        }
+        console.log();
+      }
+      const { recommendations: rec } = report;
+      const hasRecommendations = report.summary.recommendations > 0;
+      if (hasRecommendations) {
+        console.log(chalk6.bold("Recommendations"));
+        printRecommendationLine("Inbox items pending triage", rec.inboxItems.length);
+        printRecommendationLine("Stale documents", rec.staleDocs.length);
+        printRecommendationLine("AGENTS.md refresh needed", rec.agentsMdRefreshNeeded.length);
+        printRecommendationLine("Frontmind stale", rec.frontmindStale.length);
+        printRecommendationLine("Frontmind missing", rec.frontmindMissing.length);
+        printRecommendationLine(
+          "Archive distillation candidates",
+          rec.archiveDistillation.length
+        );
+        printRecommendationLine("Ready tasks", rec.readyTasks.length);
+        printRecommendationLine("Orphaned tasks", rec.orphanedTasks.length);
+        printRecommendationLine("Broken links", rec.brokenLinks.length);
+        printRecommendationLine("Misplaced documents", rec.misplacedDocs.length);
+        console.log();
+      }
+      console.log(chalk6.bold("Summary"));
+      console.log(`  Mechanical fixes: ${report.summary.mechanicalFixes}`);
+      console.log(`  Recommendations:  ${report.summary.recommendations}`);
+      console.log(`  Health:           ${healthColor(report.summary.workspaceHealth)}`);
+      console.log();
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/manifest.ts
+init_api_client();
+function registerManifestCommand(program2) {
+  program2.command("manifest").description("Get workspace summary data for manifest generation (BISQUE.md)").action(async () => {
+    try {
+      const client = new ApiClient();
+      const summary = await client.get("/v1/workspace/summary");
+      console.log(JSON.stringify(summary, null, 2));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/measure.ts
+import { existsSync, readFileSync } from "node:fs";
+function parseReferencesFlag(input) {
+  const refs = [];
+  for (const part of input.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const idx = trimmed.lastIndexOf(":");
+    if (idx < 0) continue;
+    const path2 = trimmed.slice(0, idx).trim();
+    const chars = Number.parseInt(trimmed.slice(idx + 1).trim(), 10);
+    if (!path2 || Number.isNaN(chars)) continue;
+    refs.push({ path: path2, chars });
+  }
+  return refs;
+}
+function pct(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * p));
+  return sorted[idx] ?? 0;
+}
+function summarize(rows, opts = {}) {
+  const sinceMs = opts.since ? Date.parse(opts.since) : Number.NaN;
+  const filtered = rows.filter((r) => {
+    if (opts.by && r.command !== opts.by) return false;
+    if (!Number.isNaN(sinceMs) && Date.parse(r.ts) < sinceMs) return false;
+    return true;
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const arr = groups.get(r.command) ?? [];
+    arr.push(r.tokensEstimate);
+    groups.set(r.command, arr);
+  }
+  const stats = [];
+  for (const [command, tokens] of groups) {
+    const sorted = [...tokens].sort((a, b) => a - b);
+    const total = sorted.reduce((s, n) => s + n, 0);
+    stats.push({
+      command,
+      n: sorted.length,
+      avg: Math.round(total / sorted.length),
+      p50: pct(sorted, 0.5),
+      p95: pct(sorted, 0.95),
+      total
+    });
+  }
+  stats.sort((a, b) => b.total - a.total);
+  return { stats, filteredCount: filtered.length };
+}
+function summarizeReferences(rows, opts = {}) {
+  const sinceMs = opts.since ? Date.parse(opts.since) : Number.NaN;
+  const filtered = rows.filter((r) => {
+    if (r.command !== "references") return false;
+    if (!Number.isNaN(sinceMs) && Date.parse(r.ts) < sinceMs) return false;
+    return true;
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const refs = r.args?.["references"] ?? [];
+    for (const ref of refs) {
+      if (!ref || typeof ref.path !== "string") continue;
+      const tokens = Math.ceil((ref.chars ?? 0) / 4);
+      const g = groups.get(ref.path) ?? { tokens: [], lastLoaded: r.ts };
+      g.tokens.push(tokens);
+      if (r.ts > g.lastLoaded) g.lastLoaded = r.ts;
+      groups.set(ref.path, g);
+    }
+  }
+  const stats = [];
+  for (const [path2, g] of groups) {
+    const sorted = [...g.tokens].sort((a, b) => a - b);
+    const total = sorted.reduce((s, n) => s + n, 0);
+    stats.push({
+      path: path2,
+      n: sorted.length,
+      avg: Math.round(total / sorted.length),
+      p50: pct(sorted, 0.5),
+      p95: pct(sorted, 0.95),
+      total,
+      lastLoaded: g.lastLoaded
+    });
+  }
+  stats.sort((a, b) => b.total - a.total);
+  return { stats, filteredCount: filtered.length };
+}
+function renderReferenceTable(stats) {
+  const header = "| path | n loads | avg tokens | p50 | p95 | total tokens | last loaded |";
+  const sep = "|---|---|---|---|---|---|---|";
+  const body = stats.map(
+    (s) => `| ${s.path} | ${s.n} | ${s.avg} | ${s.p50} | ${s.p95} | ${s.total} | ${s.lastLoaded} |`
+  );
+  return [header, sep, ...body].join("\n");
+}
+function renderTable(stats) {
+  const header = "| command | n calls | avg tokens | p50 | p95 | total tokens |";
+  const sep = "|---|---|---|---|---|---|";
+  const body = stats.map(
+    (s) => `| ${s.command} | ${s.n} | ${s.avg} | ${s.p50} | ${s.p95} | ${s.total} |`
+  );
+  return [header, sep, ...body].join("\n");
+}
+function loadRows() {
+  const path2 = measurementsPath();
+  if (!existsSync(path2)) return null;
+  const raw = readFileSync(path2, "utf-8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return rows;
+}
+function runSummarize(opts) {
+  const rows = loadRows();
+  if (rows === null) {
+    console.log("No measurements yet. Set BISQUE_MEASURE=1 and run some commands first.");
+    return;
+  }
+  if (opts.references) {
+    const { stats: stats2, filteredCount: filteredCount2 } = summarizeReferences(rows, { since: opts.since });
+    if (filteredCount2 === 0) {
+      console.log("No `references` measurements match your filters.");
+      return;
+    }
+    console.log(renderReferenceTable(stats2));
+    return;
+  }
+  const { stats, filteredCount } = summarize(rows, opts);
+  if (filteredCount === 0) {
+    console.log("No measurements match your filters.");
+    return;
+  }
+  console.log(renderTable(stats));
+}
+function registerMeasureCommand(program2) {
+  const measure = program2.command("measure").description("Inspect measurement data captured by BISQUE_MEASURE=1");
+  measure.command("summarize").description("Summarize measurements.jsonl as a markdown table").option("--since <iso>", "Filter rows with ts >= this ISO date").option("--by <command>", "Filter to a single command name").option("--references", "Roll up per-reference-doc load stats from `references` events").action(runSummarize);
+  measure.command("references").description("Record a subagent reference-doc load event (chain-runner telemetry)").requiredOption("--task-id <id>", "Task ID being dispatched").requiredOption(
+    "--slash-command <name>",
+    "Slash command building the envelope (e.g. run-chain)"
+  ).requiredOption(
+    "--references <list>",
+    "Comma-separated path:chars pairs (e.g. 'references/chain-runner.md:12000,references/task-workflow.md:8000')"
+  ).option(
+    "--preamble-chars <n>",
+    "Total envelope char count, including preamble",
+    (v) => Number.parseInt(v, 10)
+  ).action(
+    (opts) => {
+      const refs = parseReferencesFlag(opts.references);
+      const totalChars = refs.reduce((s, r) => s + r.chars, 0);
+      recordMeasurement(
+        "references",
+        {
+          taskId: opts.taskId,
+          slashCommand: opts.slashCommand,
+          references: refs,
+          preambleChars: opts.preambleChars
+        },
+        totalChars
+      );
+    }
+  );
+}
+
+// src/commands/move.ts
+init_api_client();
+function registerMoveCommand(program2) {
+  program2.command("move <docId>").description("Move a document to a new path").requiredOption("--to <path>", "Destination path").action(async (docId, options) => {
+    try {
+      const client = new ApiClient();
+      await client.put(`/v1/documents/${docId}/move`, { newPath: options.to });
+      console.log(`Moved ${docId} \u2192 ${options.to}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/persona.ts
+init_api_client();
+import { createInterface as createInterface2 } from "node:readline";
+import chalk7 from "chalk";
+import Table3 from "cli-table3";
+function confirm2(prompt) {
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function registerPersonaCommand(program2) {
+  const persona = program2.command("persona").description("Manage agent personas");
+  persona.command("list").description("List all personas").option("--json", "Output raw JSON").action(async (options) => {
+    try {
+      const client = new ApiClient();
+      const data = await client.get("/v1/agent-personas");
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (data.agentPersonas.length === 0) {
+        console.log(chalk7.yellow("No personas found."));
+        return;
+      }
+      const table = new Table3({
+        head: [
+          chalk7.cyan("ID"),
+          chalk7.cyan("Name"),
+          chalk7.cyan("Specialization"),
+          chalk7.cyan("Tasks"),
+          chalk7.cyan("Last Active")
+        ],
+        style: {
+          head: [],
+          border: ["gray"]
+        }
+      });
+      for (const item of data.agentPersonas) {
+        const spec = item.specialization.length > 30 ? `${item.specialization.slice(0, 29)}...` : item.specialization;
+        table.push([
+          item.agentPersonaId,
+          item.name,
+          spec,
+          String(item.tasksCompleted ?? 0),
+          item.lastActive ? item.lastActive.split("T")[0] : "-"
+        ]);
+      }
+      console.log(table.toString());
+      console.log(chalk7.gray(`
+Total: ${data.agentPersonas.length} persona(s)`));
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  persona.command("get <id>").description("Get a persona by ID").action(async (id) => {
+    try {
+      const client = new ApiClient();
+      const p = await client.get(`/v1/agent-personas/${id}`);
+      console.log(`Name:           ${p.name}`);
+      console.log(`ID:             ${p.agentPersonaId}`);
+      console.log(`Specialization: ${p.specialization}`);
+      if (p.personality) console.log(`Personality:    ${p.personality}`);
+      if (p.coreValues) console.log(`Core Values:    ${p.coreValues}`);
+      if (p.reviewCriteria) console.log(`Review Criteria:${p.reviewCriteria}`);
+      console.log(`Tasks Done:     ${p.tasksCompleted}`);
+      if (p.lastActive) console.log(`Last Active:    ${p.lastActive}`);
+      console.log(`Created:        ${p.createdAt}`);
+      console.log(`Updated:        ${p.updatedAt}`);
+      if (p.learnings && p.learnings.length > 0) {
+        console.log(chalk7.cyan("\nLearnings:"));
+        for (const l of p.learnings) {
+          console.log(`  - ${l}`);
+        }
+      }
+      if (p.feedback && p.feedback.length > 0) {
+        console.log(chalk7.cyan("\nFeedback:"));
+        for (const f of p.feedback) {
+          console.log(`  - ${f}`);
+        }
+      }
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  persona.command("create").description("Create a new persona").requiredOption("--name <name>", "Persona name").requiredOption("--specialization <spec>", "Specialization description").option("--personality <text>", "Personality description").option("--core-values <text>", "Core values").option("--review-criteria <text>", "Review criteria").action(
+    async (options) => {
+      try {
+        const client = new ApiClient();
+        const body = Object.assign(
+          {
+            name: options.name,
+            specialization: options.specialization
+          },
+          options.personality ? { personality: options.personality } : {},
+          options.coreValues ? { coreValues: options.coreValues } : {},
+          options.reviewCriteria ? { reviewCriteria: options.reviewCriteria } : {}
+        );
+        const result = await client.post("/v1/agent-personas", body);
+        console.log(`Persona created: ${result.agentPersonaId}`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  persona.command("update <id>").description("Update a persona").option("--name <name>", "New name").option("--specialization <spec>", "New specialization").option("--personality <text>", "New personality").option("--core-values <text>", "New core values").option("--review-criteria <text>", "New review criteria").action(
+    async (id, options) => {
+      try {
+        const body = Object.assign(
+          {},
+          options.name ? { name: options.name } : {},
+          options.specialization ? { specialization: options.specialization } : {},
+          options.personality ? { personality: options.personality } : {},
+          options.coreValues ? { coreValues: options.coreValues } : {},
+          options.reviewCriteria ? { reviewCriteria: options.reviewCriteria } : {}
+        );
+        if (Object.keys(body).length === 0) {
+          console.error("Error: Provide at least one field to update.");
+          process.exitCode = 1;
+          return;
+        }
+        const client = new ApiClient();
+        const result = await client.put(`/v1/agent-personas/${id}`, body);
+        console.log(`Persona ${result.agentPersonaId} updated.`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  persona.command("delete <id>").description("Delete a persona").option("-f, --force", "Skip confirmation prompt").action(async (id, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirm2(`Delete persona ${id}? (y/N) `);
+        if (!confirmed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const client = new ApiClient();
+      await client.delete(`/v1/agent-personas/${id}`);
+      console.log(`Persona ${id} deleted.`);
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  persona.command("add-learning <id> <text>").description("Add a learning to a persona").action(async (id, text) => {
+    try {
+      const client = new ApiClient();
+      await client.post(`/v1/agent-personas/${id}/learnings`, { learning: text });
+      console.log("Learning added.");
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  persona.command("add-feedback <id> <text>").description("Add feedback to a persona").action(async (id, text) => {
+    try {
+      const client = new ApiClient();
+      await client.post(`/v1/agent-personas/${id}/feedback`, { feedback: text });
+      console.log("Feedback added.");
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/plugin.ts
+import { spawn } from "node:child_process";
+var BISQUE_MARKETPLACE_SOURCE = "Kokonaut/bisque";
+var BISQUE_MARKETPLACE_NAME = "bisque-marketplace";
+var BISQUE_PLUGIN_NAME = "bisque";
+var BISQUE_PLUGIN_QUALIFIED = `${BISQUE_PLUGIN_NAME}@${BISQUE_MARKETPLACE_NAME}`;
+var CLAUDE_INSTALL_DOCS_URL = "https://docs.anthropic.com/en/docs/claude-code/setup";
+var defaultRunner = {
+  run(command, args) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", (err) => reject(err));
+      child.on("close", (code) => {
+        resolve({ exitCode: code ?? 0, stdout, stderr });
+      });
+    });
+  }
+};
+function entryMatchesBisque(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  if (entry.id === BISQUE_PLUGIN_QUALIFIED) return true;
+  if (entry.name === BISQUE_PLUGIN_QUALIFIED) return true;
+  if (entry.name === BISQUE_PLUGIN_NAME) {
+    if (entry.marketplaceName === BISQUE_MARKETPLACE_NAME) return true;
+    if (entry.source?.name === BISQUE_MARKETPLACE_NAME) return true;
+  }
+  return false;
+}
+async function isBisquePluginInstalled(runner) {
+  try {
+    const result = await runner.run("claude", ["plugin", "list", "--json"]);
+    if (result.exitCode !== 0) return false;
+    const trimmed = result.stdout.trim();
+    if (!trimmed) return false;
+    const parsed = JSON.parse(trimmed);
+    const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed.installed) ? parsed.installed ?? [] : [];
+    return entries.some(entryMatchesBisque);
+  } catch {
+    return false;
+  }
+}
+async function ensureClaudeOnPath(runner) {
+  try {
+    const result = await runner.run("claude", ["--version"]);
+    return result.exitCode === 0;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function runPluginInstall(options = {}, deps = {}) {
+  const runner = deps.runner ?? defaultRunner;
+  const logger = deps.logger ?? console;
+  const claudeAvailable = await ensureClaudeOnPath(runner);
+  if (!claudeAvailable) {
+    logger.error(
+      `Error: Claude Code CLI ('claude') was not found on PATH.
+  The Bisque plugin requires Claude Code to be installed first.
+  Install Claude Code: ${CLAUDE_INSTALL_DOCS_URL}
+  After installing, re-run \`bisque plugin install\`.`
+    );
+    return 1;
+  }
+  const alreadyInstalled = await isBisquePluginInstalled(runner);
+  if (alreadyInstalled && !options.force) {
+    logger.log(
+      `Bisque plugin already installed as '${BISQUE_PLUGIN_QUALIFIED}'.
+Use --force to reinstall.`
+    );
+    return 0;
+  }
+  if (alreadyInstalled && options.force) {
+    logger.log(`Reinstalling \u2014 removing existing '${BISQUE_PLUGIN_QUALIFIED}'...`);
+    const uninstall = await runner.run("claude", ["plugin", "uninstall", BISQUE_PLUGIN_QUALIFIED]);
+    if (uninstall.exitCode !== 0) {
+      logger.error(
+        `Error: 'claude plugin uninstall' failed (exit ${uninstall.exitCode}).
+  stderr: ${uninstall.stderr.trim()}`
+      );
+      return 1;
+    }
+  }
+  logger.log(`Adding marketplace '${BISQUE_MARKETPLACE_SOURCE}'...`);
+  const addMarketplace = await runner.run("claude", [
+    "plugin",
+    "marketplace",
+    "add",
+    BISQUE_MARKETPLACE_SOURCE
+  ]);
+  if (addMarketplace.exitCode !== 0) {
+    const combined = `${addMarketplace.stdout}
+${addMarketplace.stderr}`.toLowerCase();
+    const isAlreadyRegistered = combined.includes("already");
+    if (!isAlreadyRegistered) {
+      logger.error(
+        `Error: 'claude plugin marketplace add ${BISQUE_MARKETPLACE_SOURCE}' failed (exit ${addMarketplace.exitCode}).
+  stderr: ${addMarketplace.stderr.trim()}`
+      );
+      return 1;
+    }
+  }
+  logger.log(`Installing plugin '${BISQUE_PLUGIN_QUALIFIED}'...`);
+  const install = await runner.run("claude", ["plugin", "install", BISQUE_PLUGIN_QUALIFIED]);
+  if (install.exitCode !== 0) {
+    logger.error(
+      `Error: 'claude plugin install ${BISQUE_PLUGIN_QUALIFIED}' failed (exit ${install.exitCode}).
+  stderr: ${install.stderr.trim()}`
+    );
+    return 1;
+  }
+  logger.log(
+    "\nBisque plugin installed successfully.\nRestart Claude Code (or run /reload-plugins inside an active session) to activate it.\nTry /bisque:run-chain or use the bisque skill once active."
+  );
+  return 0;
+}
+function registerPluginCommand(program2, deps = {}) {
+  const pluginCmd = program2.command("plugin").description("Manage the Bisque Claude Code plugin");
+  pluginCmd.command("install").description("Register the Bisque plugin with Claude Code").option("-f, --force", "Force reinstall if already installed", false).action(async (options) => {
+    const exitCode = await runPluginInstall({ force: options.force }, deps);
+    if (exitCode !== 0) {
+      process.exitCode = exitCode;
+    }
+  });
+}
+
+// src/commands/recall.ts
+init_api_client();
+function parseLimit(raw) {
+  const limit = Number.parseInt(raw, 10);
+  if (!Number.isFinite(limit) || limit < 1 || limit > 100) {
+    console.error("Error: --limit must be a positive integer between 1 and 100");
+    return void 0;
+  }
+  return limit;
+}
+function parseBudget(raw) {
+  if (raw === void 0) return void 0;
+  const budget = Number.parseInt(raw, 10);
+  if (!Number.isFinite(budget) || budget < 500 || budget > 32e3) {
+    console.error("Error: --budget must be an integer between 500 and 32000");
+    return "error";
+  }
+  return budget;
+}
+function renderPackedSummary(result, budget) {
+  if (!result.packed) return;
+  const used = result.used_chars ?? 0;
+  const dropped = result.dropped_count ?? 0;
+  const budgetLabel = budget !== void 0 ? `/${budget}` : "";
+  console.log(`packed ${used}${budgetLabel} chars, ${dropped} dropped`);
+}
+function renderItems(result) {
+  if (result.items.length === 0) {
+    console.log("No relevant documents found.");
+    if (result.recall_id !== void 0) {
+      console.log(`recall_id: ${result.recall_id}`);
+    }
+    return;
+  }
+  console.log(`Found ${result.total} relevant document(s):
+`);
+  for (const item of result.items) {
+    console.log(`  ${item.documentId}  ${item.title}`);
+    if (item.excerpt) {
+      console.log(`    ${item.excerpt.slice(0, 100)}${item.excerpt.length > 100 ? "..." : ""}`);
+    }
+    console.log();
+  }
+  if (result.recall_id !== void 0) {
+    console.log(`recall_id: ${result.recall_id}`);
+  }
+}
+function registerRecallCommand(program2) {
+  program2.command("recall <context>").description("Retrieve documents relevant to a topic or question").option("-l, --limit <number>", "Max results (1-100)", "20").option(
+    "-b, --budget <chars>",
+    "Optional char budget; server packs the highest-scoring subset that fits (500-32000)"
+  ).action(async (context, options) => {
+    const limit = parseLimit(options.limit);
+    if (limit === void 0) {
+      process.exitCode = 1;
+      return;
+    }
+    const budget = parseBudget(options.budget);
+    if (budget === "error") {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const client = new ApiClient();
+      const requestBody = { context, limit };
+      if (budget !== void 0) requestBody["budget_chars"] = budget;
+      const result = await client.post("/v1/recall", requestBody);
+      recordMeasurement(
+        "recall",
+        budget !== void 0 ? { context, limit, budget_chars: budget } : { context, limit },
+        JSON.stringify(result).length
+      );
+      renderPackedSummary(result, budget);
+      renderItems(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/recall-annotate.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2, statSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join4 } from "node:path";
+var ANNOTATION_FILE = join4(homedir3(), ".bisque", "dogfood-incidents-2026-05-25.jsonl");
+function isPlausibleUuid(id) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+var MIN_KEY_BYTES = 32;
+var MIN_HEX_CHARS = MIN_KEY_BYTES * 2;
+function getHmacKey() {
+  const k = process.env["BISQUE_DOGFOOD_HMAC_KEY"];
+  if (k === void 0 || k.length === 0) return null;
+  const isHex = /^[0-9a-fA-F]+$/.test(k);
+  if (isHex && k.length >= MIN_HEX_CHARS) return k;
+  if (!isHex && Buffer.byteLength(k, "utf8") >= MIN_KEY_BYTES) return k;
+  return null;
+}
+var FILE_MODE = 384;
+var DIR_MODE = 448;
+function assertSafeFileMode(path2) {
+  try {
+    const mode = statSync(path2).mode & 511;
+    if (mode & 63) {
+      throw new Error(
+        `Annotation file at ${path2} has mode 0${mode.toString(8)} which is wider than 0600 \u2014 refusing to write. chmod 600 to fix.`
+      );
+    }
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return;
+    throw err;
+  }
+}
+function resolveJudgment(options) {
+  const flags = [];
+  if (options.incident) flags.push("incident");
+  if (options.nonIncident) flags.push("non-incident");
+  if (options.unclear) flags.push("unclear");
+  if (flags.length !== 1) return null;
+  return flags[0];
+}
+function registerRecallAnnotateCommand(program2) {
+  program2.command("recall-annotate <recallId>").description(
+    "Annotate a recall response for the T6 dogfood stale-recall log. Local-only \u2014 appends to ~/.bisque/dogfood-incidents-2026-05-25.jsonl. Exactly one of --incident / --non-incident / --unclear is required."
+  ).option(
+    "--incident",
+    "Founder judges this recall a stale-promotion incident (counts toward the gate)"
+  ).option(
+    "--non-incident",
+    "Founder eyeballed the recall and judged it correctly-ranked (denominator credit; does not count as an incident)"
+  ).option(
+    "--unclear",
+    "Founder cannot judge \u2014 the proxy (lastAccessedAt) may be diverging from decision recency. Excluded from incident count; preserved for reviewer audit."
+  ).option("--note <text>", "Optional free-text founder context").action(
+    async (recallId, options) => {
+      if (!isPlausibleUuid(recallId)) {
+        console.error(
+          `Error: '${recallId}' does not look like a recall_id (expected UUID 8-4-4-4-12 hex shape).`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const judgment = resolveJudgment(options);
+      if (judgment === null) {
+        console.error(
+          "Error: exactly one of --incident, --non-incident, or --unclear is required."
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (getHmacKey() === null) {
+        console.error(
+          "Error: annotation requires BISQUE_DOGFOOD_HMAC_KEY in env (\u226532 bytes utf8 OR \u226564 hex chars, per NIST SP 800-107 \xA75.3.4 for HMAC-SHA256). This is the same HMAC key the backend Lambda uses for queryHash/filepathHash. Source it from your shell profile (or aws ssm get-parameter --name /bisque/dogfood-hmac-key --with-decryption). Without it, this annotation cannot be cross-correlated with CloudWatch EMF emissions. Bootstrap: openssl rand -hex 32"
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const line = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        recallId,
+        founderJudgment: judgment
+      };
+      if (options.note !== void 0 && options.note.length > 0) {
+        line.note = options.note;
+      }
+      try {
+        mkdirSync2(dirname2(ANNOTATION_FILE), { recursive: true, mode: DIR_MODE });
+        assertSafeFileMode(ANNOTATION_FILE);
+        appendFileSync2(ANNOTATION_FILE, `${JSON.stringify(line)}
+`, {
+          flag: "a",
+          mode: FILE_MODE
+        });
+        console.log(
+          `Annotated recall ${recallId} as ${judgment}. Appended to ${ANNOTATION_FILE}.`
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: failed to write annotation: ${message}`);
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+
+// src/commands/search.ts
+init_api_client();
+function buildSearchParams(query, options) {
+  const params = new URLSearchParams({ q: query, limit: options.limit });
+  if (options.category) {
+    params.set("category", options.category);
+  }
+  if (options.tags) {
+    params.set("tags", options.tags);
+  }
+  if (options.path) {
+    params.set("pathPrefix", options.path);
+  }
+  if (options.cursor) {
+    params.set("cursor", options.cursor);
+  }
+  return params;
+}
+function formatResult(result) {
+  const tags = result.tags.length > 0 ? result.tags.join(", ") : "(none)";
+  return `  ${result.title}
+    Path: ${result.filepath}
+    Tags: ${tags}`;
+}
+async function executeSearch(query, options) {
+  const client = new ApiClient();
+  const params = buildSearchParams(query, options);
+  const data = await client.get(`/v1/search?${params.toString()}`);
+  if (data.items.length === 0) {
+    console.log("No results found.");
+    return;
+  }
+  for (const result of data.items) {
+    console.log(formatResult(result));
+    console.log();
+  }
+  console.log(`Total: ${data.total} result${data.total === 1 ? "" : "s"}`);
+  if (data.cursor) {
+    console.log(`More results available. Use --cursor ${data.cursor}`);
+  }
+}
+function registerSearchCommand(program2) {
+  program2.command("search <query>").description("Search documents").option("-c, --category <category>", "Filter by PARA category").option("-t, --tags <tags>", "Comma-separated tags to filter by").option("--path <prefix>", "Scope search to a path prefix").option("-l, --limit <number>", "Maximum results to return", "20").option("--cursor <value>", "Pagination cursor from previous search").action(async (query, options) => {
+    try {
+      await executeSearch(query, options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill.ts
+import { cp, mkdir as mkdir2, readdir as readdir2, rm, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import path from "node:path";
+var DEFAULT_OPENCLAW_SKILLS_DIR = path.join(homedir4(), ".openclaw", "workspace", "skills");
+function defaultSourceForTarget(_target) {
+  const here = path.dirname(new URL(import.meta.url).pathname);
+  return path.resolve(here, "..", "..", "..", "plugin-openclaw");
+}
+async function exists(p) {
+  try {
+    await stat2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runSkillInstall(options, deps = {}) {
+  const logger = deps.logger ?? console;
+  if (options.target !== "openclaw") {
+    logger.error(`Unknown target '${options.target}'. Supported: openclaw.`);
+    return 1;
+  }
+  const source = options.source ?? defaultSourceForTarget(options.target);
+  const sourceSkills = path.join(source, "skills");
+  if (!await exists(sourceSkills)) {
+    logger.error(
+      `Source plugin tree not found at ${sourceSkills}. Run 'pnpm --filter @bisque/plugin-openclaw build' first, or pass --source <path>.`
+    );
+    return 1;
+  }
+  const targetDir = deps.openclawSkillsDir ?? DEFAULT_OPENCLAW_SKILLS_DIR;
+  await mkdir2(targetDir, { recursive: true });
+  const entries = await readdir2(sourceSkills, { withFileTypes: true });
+  const skillDirs = entries.filter((e) => e.isDirectory());
+  if (skillDirs.length === 0) {
+    logger.error(`No skill folders found under ${sourceSkills}.`);
+    return 1;
+  }
+  for (const entry of skillDirs) {
+    const dest = path.join(targetDir, entry.name);
+    if (await exists(dest)) {
+      if (!options.force) {
+        logger.error(`Skill '${entry.name}' already exists at ${dest}. Use --force to reinstall.`);
+        return 1;
+      }
+      await rm(dest, { recursive: true, force: true });
+    }
+    await cp(path.join(sourceSkills, entry.name), dest, { recursive: true });
+    logger.log(`Installed skill: ${entry.name}`);
+  }
+  logger.log(`
+${skillDirs.length} skill(s) installed to ${targetDir}.`);
+  logger.log("Restart your OpenClaw session to pick up the new skills.");
+  return 0;
+}
+function registerSkillCommand(program2, deps = {}) {
+  const cmd = program2.command("skill").description("Manage Bisque skill packs for non-Claude-Code platforms");
+  cmd.command("install").description("Install Bisque skills into a target platform").requiredOption("--target <platform>", "Target platform (openclaw)").option("--source <path>", "Source plugin tree (defaults to bundled plugin-openclaw)").option("-f, --force", "Force reinstall, overwriting existing skill folders", false).action(async (options) => {
+    if (options.target !== "openclaw") {
+      console.error(`Unknown target '${options.target}'. Supported: openclaw.`);
+      process.exitCode = 1;
+      return;
+    }
+    const exitCode = await runSkillInstall(
+      { target: "openclaw", source: options.source, force: options.force },
+      deps
+    );
+    if (exitCode !== 0) process.exitCode = exitCode;
+  });
+}
+
+// src/commands/tag.ts
+init_api_client();
+function registerTagCommand(program2) {
+  program2.command("tag <docId>").description("Add tags to a document").requiredOption("--tags <tags>", "Comma-separated list of tags").action(async (docId, options) => {
+    try {
+      const tags = options.tags.split(",").map((t) => t.trim());
+      const client = new ApiClient();
+      await client.put(`/v1/documents/${docId}/categorize`, { tags });
+      console.log(`Tagged ${docId}: ${tags.join(", ")}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/task.ts
+init_api_client();
+import { createInterface as createInterface3 } from "node:readline";
+import chalk8 from "chalk";
+import Table4 from "cli-table3";
+import { Option as Option2 } from "commander";
+var PICKUP_MODES = ["interactive", "autonomous"];
+function splitCsv(value) {
+  return value.split(",").map((s) => s.trim());
+}
+function confirm3(prompt) {
+  const rl = createInterface3({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function registerTaskCommand(program2) {
+  const task = program2.command("task").description("Manage tasks");
+  task.command("create").description("Create a task").requiredOption("--title <title>", "Task title").option("--content <content>", "Full task context").option("--project-path <path>", "PARA project path").option("--chain-id <id>", "Parent chain UUID").option("--chain-order <n>", "Position in chain").option("--assigned-agent-ids <ids>", "Comma-separated agent IDs").option("--reference-docs <docIds>", "Comma-separated doc UUIDs").option("--dependency-task-ids <ids>", "Comma-separated prerequisite task UUIDs").option("--tags <tags>", "Comma-separated tags").addOption(
+    new Option2(
+      "--pickup-mode <mode>",
+      "Restrict who may claim this task (unrestricted when omitted on task)"
+    ).choices(PICKUP_MODES)
+  ).action(
+    async (options) => {
+      try {
+        let chainOrderValue;
+        if (options.chainOrder) {
+          chainOrderValue = Number.parseFloat(options.chainOrder);
+          if (!Number.isFinite(chainOrderValue) || chainOrderValue < 0) {
+            console.error("Error: --chain-order must be a non-negative number.");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const client = new ApiClient();
+        const body = Object.assign(
+          { title: options.title },
+          options.content ? { content: options.content } : {},
+          options.projectPath ? { projectPath: options.projectPath } : {},
+          options.chainId ? { chainId: options.chainId } : {},
+          chainOrderValue !== void 0 ? { chainOrder: chainOrderValue } : {},
+          options.assignedAgentIds ? { assignedAgentIds: splitCsv(options.assignedAgentIds) } : {},
+          options.referenceDocs ? { referenceDocs: splitCsv(options.referenceDocs) } : {},
+          options.dependencyTaskIds ? { dependencyTaskIds: splitCsv(options.dependencyTaskIds) } : {},
+          options.tags ? { tags: splitCsv(options.tags) } : {},
+          options.pickupMode ? { pickupMode: options.pickupMode } : {}
+        );
+        const result = await client.post("/v1/tasks", body);
+        const num = String(result.taskNumber).padStart(6, "0");
+        console.log(`Task #${num} created: ${result.documentId}`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  task.command("list").description("List tasks").option("--status <status>", "Filter: queued, in-progress, blocked, done, cancelled").option("--project-path <path>", "Filter by project").option("--chain-id <id>", "Filter by chain").addOption(
+    new Option2("--pickup-mode <mode>", "Filter by pickup mode (no filter when omitted)").choices(
+      PICKUP_MODES
+    )
+  ).option("--limit <n>", "Max results", "50").action(
+    async (options) => {
+      try {
+        const client = new ApiClient();
+        const params = new URLSearchParams();
+        if (options.status) params.set("status", options.status);
+        if (options.projectPath) params.set("projectPath", options.projectPath);
+        if (options.chainId) params.set("chainId", options.chainId);
+        if (options.pickupMode) params.set("pickupMode", options.pickupMode);
+        params.set("limit", options.limit);
+        const query = params.toString();
+        const path2 = query ? `/v1/tasks?${query}` : "/v1/tasks";
+        const data = await client.get(path2);
+        if (data.length === 0) {
+          console.log(chalk8.yellow("No tasks found."));
+          return;
+        }
+        const table = new Table4({
+          head: [
+            chalk8.cyan("#"),
+            chalk8.cyan("Title"),
+            chalk8.cyan("Status"),
+            chalk8.cyan("ID"),
+            chalk8.cyan("Chain")
+          ],
+          style: {
+            head: [],
+            border: ["gray"]
+          }
+        });
+        for (const item of data) {
+          const title = item.title.length > 28 ? `${item.title.slice(0, 27)}...` : item.title;
+          const num = `#${String(item.taskNumber).padStart(6, "0")}`;
+          table.push([num, title, item.status, item.documentId, item.chainId ?? "-"]);
+        }
+        console.log(table.toString());
+        console.log(chalk8.gray(`
+Total: ${data.length} task(s)`));
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  task.command("get <taskId>").description("Get a task by ID").action(async (taskId) => {
+    try {
+      const client = new ApiClient();
+      const task2 = await client.get(`/v1/tasks/${taskId}`);
+      console.log(`Title:        ${task2.title}`);
+      console.log(`Task #:       ${String(task2.taskNumber).padStart(6, "0")}`);
+      console.log(`Status:       ${task2.status}`);
+      console.log(`ID:           ${task2.documentId}`);
+      console.log(`Filepath:     ${task2.filepath}`);
+      if (task2.projectPath) console.log(`Project Path: ${task2.projectPath}`);
+      if (task2.chainId) console.log(`Chain ID:     ${task2.chainId}`);
+      if (task2.chainOrder !== void 0) console.log(`Chain Order:  ${task2.chainOrder}`);
+      if (task2.tags && task2.tags.length > 0) console.log(`Tags:         ${task2.tags.join(", ")}`);
+      console.log(
+        `Dependency Tasks: ${task2.dependencyTaskIds && task2.dependencyTaskIds.length > 0 ? task2.dependencyTaskIds.join(", ") : "none"}`
+      );
+      console.log(
+        `Assigned Agents: ${task2.assignedAgentIds && task2.assignedAgentIds.length > 0 ? task2.assignedAgentIds.join(", ") : "none"}`
+      );
+      console.log(
+        `Reference Docs: ${task2.referenceDocs && task2.referenceDocs.length > 0 ? task2.referenceDocs.join(", ") : "none"}`
+      );
+      console.log(`Created:      ${task2.createdAt}`);
+      console.log(`Updated:      ${task2.updatedAt}`);
+      if (task2.content) {
+        console.log("---");
+        console.log(task2.content);
+      }
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+  task.command("update <taskId>").description("Update a task").option("--status <status>", "New status").option("--title <title>", "New title").option("--content <content>", "New content").option("--project-path <path>", "PARA project path").option("--chain-order <n>", "Position in chain (decimals allowed, e.g. 2.5)").option("--assigned-agent-ids <ids>", "Comma-separated agent IDs").option("--reference-docs <docIds>", "Comma-separated doc UUIDs").option("--dependency-task-ids <ids>", "Comma-separated prerequisite task UUIDs").option("--tags <tags>", "Comma-separated tags").option("--completed-at <iso>", "ISO timestamp for completion").addOption(
+    new Option2(
+      "--pickup-mode <mode>",
+      "Restrict who may claim this task (unrestricted when omitted on task)"
+    ).choices(PICKUP_MODES)
+  ).action(
+    async (taskId, options) => {
+      try {
+        let chainOrderValue;
+        if (options.chainOrder !== void 0) {
+          chainOrderValue = Number.parseFloat(options.chainOrder);
+          if (!Number.isFinite(chainOrderValue) || chainOrderValue < 0) {
+            console.error("Error: --chain-order must be a non-negative number.");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const body = Object.assign(
+          {},
+          options.status ? { status: options.status } : {},
+          options.title ? { title: options.title } : {},
+          options.content ? { content: options.content } : {},
+          options.projectPath ? { projectPath: options.projectPath } : {},
+          chainOrderValue !== void 0 ? { chainOrder: chainOrderValue } : {},
+          options.assignedAgentIds ? { assignedAgentIds: splitCsv(options.assignedAgentIds) } : {},
+          options.referenceDocs ? { referenceDocs: splitCsv(options.referenceDocs) } : {},
+          options.dependencyTaskIds ? { dependencyTaskIds: splitCsv(options.dependencyTaskIds) } : {},
+          options.tags ? { tags: splitCsv(options.tags) } : {},
+          options.completedAt ? { completedAt: options.completedAt } : {},
+          options.pickupMode ? { pickupMode: options.pickupMode } : {}
+        );
+        if (Object.keys(body).length === 0) {
+          console.error("Error: Provide at least one field to update.");
+          process.exitCode = 1;
+          return;
+        }
+        const client = new ApiClient();
+        const result = await client.put(`/v1/tasks/${taskId}`, body);
+        console.log(`Task ${result.documentId} updated.`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  task.command("claim <taskId>").description("Claim a task for execution").requiredOption("--agent <agentId>", "Agent identifier").addOption(
+    new Option2(
+      "--claimant-class <mode>",
+      "Asserted claimant class (interactive when omitted on claim)"
+    ).choices(PICKUP_MODES)
+  ).action(
+    async (taskId, options) => {
+      try {
+        const client = new ApiClient();
+        const body = { agentId: options.agent };
+        if (options.claimantClass) {
+          body["claimantClass"] = options.claimantClass;
+        }
+        await client.put(`/v1/tasks/${taskId}/claim`, body);
+        console.log(`Task ${taskId} claimed by ${options.agent}.`);
+      } catch (error) {
+        exitWithError(error);
+      }
+    }
+  );
+  task.command("delete <taskId>").description("Delete a task").option("-f, --force", "Skip confirmation prompt").action(async (taskId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirm3(`Delete task ${taskId}? (y/N) `);
+        if (!confirmed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const client = new ApiClient();
+      await client.delete(`/v1/tasks/${taskId}`);
+      console.log(`Task ${taskId} deleted.`);
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/tree.ts
+init_api_client();
+import chalk9 from "chalk";
+function registerTreeCommand(program2) {
+  program2.command("tree [path]").description(
+    "Recursively fetch documents with content. WARNING: This is the most expensive navigation operation. Prefer 'bisque ls' for navigation and 'bisque batch' for targeted loading."
+  ).option("--workspace <id>", "Workspace ID", "default").option("--limit <n>", "Page size (max 25)", "10").option("--max-items <n>", "Total items across all pages (max 200)", "200").option("--json", "Output as JSON").action(
+    async (path2, options) => {
+      try {
+        const client = new ApiClient();
+        const params = new URLSearchParams();
+        if (path2) params.set("path", path2);
+        params.set("workspace", options.workspace);
+        params.set("limit", options.limit);
+        params.set("maxItems", options.maxItems);
+        const result = await client.get(`/v1/documents/tree?${params.toString()}`);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        const data = result;
+        if (!data.documents || data.documents.length === 0) {
+          console.log(chalk9.dim("  (empty)"));
+          return;
+        }
+        for (const doc of data.documents) {
+          console.log(chalk9.blue(`--- ${doc.filepath} ---`));
+          console.log(chalk9.dim(`Title: ${doc.title}`));
+          console.log(doc.content);
+          console.log();
+        }
+        console.log(chalk9.dim(`Returned ${data.totalReturned}/${data.maxItems} max items`));
+        if (data.cursor) {
+          console.log(
+            chalk9.yellow("More results available. Use --json to get cursor for pagination.")
+          );
+        }
+      } catch (err) {
+        exitWithError(err);
+      }
+    }
+  );
+}
+
+// src/commands/update.ts
+init_api_client();
+function parseMetadataJson2(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { error: "Error: --metadata must be a JSON object" };
+    }
+    return { value: parsed };
+  } catch {
+    return { error: "Error: --metadata must be valid JSON" };
+  }
+}
+function buildUpdateBody(options) {
+  const body = {};
+  if (options.title !== void 0) {
+    body["title"] = options.title;
+  }
+  if (options.content !== void 0) {
+    body["content"] = options.content;
+  }
+  if (options.summary !== void 0) {
+    body["summary"] = options.summary;
+  }
+  if (options.tags !== void 0) {
+    body["tags"] = options.tags.split(",").map((t) => t.trim());
+  }
+  if (options.keywords !== void 0) {
+    body["keywords"] = options.keywords.split(",").map((k) => k.trim());
+  }
+  if (options.metadata !== void 0) {
+    const result = parseMetadataJson2(options.metadata);
+    if ("error" in result) {
+      return result;
+    }
+    body["metadata"] = result.value;
+  }
+  if (options.status !== void 0) {
+    body["status"] = options.status;
+  }
+  if (Object.keys(body).length === 0) {
+    return {
+      error: "Error: at least one update flag is required (--title, --content, --summary, --tags, --keywords, --metadata, --status)"
+    };
+  }
+  return { body };
+}
+function registerUpdateCommand(program2) {
+  program2.command("update <docId>").description("Update an existing document").option("--title <title>", "New title").option("--content <content>", "New content").option(
+    "--summary <summary>",
+    "Set the doc's summary field (short abstract, rendered in AGENTS.md ## What's here)"
+  ).option("--tags <tags>", "Replace tags (comma-separated)").option("--keywords <keywords>", "Replace keywords (comma-separated)").option("--metadata <json>", "JSON metadata object").option(
+    "--status <status>",
+    "New lifecycle state: live | superseded | archived. Used for manual transitions (e.g. archiving a draft). Supersession-specific transitions go through the v1.5 supersession route."
+  ).action(async (docId, options) => {
+    try {
+      const result = buildUpdateBody(options);
+      if ("error" in result) {
+        console.error(result.error);
+        process.exitCode = 1;
+        return;
+      }
+      const client = new ApiClient();
+      await client.put(`/v1/documents/${docId}`, result.body);
+      console.log(`Document ${docId} updated.`);
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/workspace.ts
+init_src();
+init_config();
+init_api_client();
+import { createInterface as createInterface4 } from "node:readline/promises";
+import chalk10 from "chalk";
+import Table5 from "cli-table3";
+init_runtime_context();
+init_workspace_context();
+async function resolveSubcommandWorkspaceId(options, config) {
+  if (options.workspace) return options.workspace;
+  const runtimeId = getCurrentWorkspaceId();
+  if (runtimeId) return runtimeId;
+  const configActive = await config.get("activeWorkspaceId");
+  if (configActive) return configActive;
+  return void 0;
+}
+async function confirm4(prompt, assumeYes) {
+  if (assumeYes) return true;
+  const rl = createInterface4({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = (await rl.question(`${prompt} `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function parseExpiresAt(input) {
+  const match = /^(\d+)([smhd]?)$/.exec(input.trim());
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  const unit = match[2] ?? "";
+  const multipliers = { s: 1, "": 1, m: 60, h: 3600, d: 86400 };
+  const seconds = value * (multipliers[unit] ?? 1);
+  return Math.floor(Date.now() / 1e3) + seconds;
+}
+function unwrapApiErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+async function workspaceList(json) {
+  try {
+    const config = new Config();
+    const cache = await refreshWorkspacesCache(config);
+    if (json) {
+      console.log(JSON.stringify(cache, null, 2));
+      return;
+    }
+    if (cache.workspaces.length === 0) {
+      console.log(chalk10.yellow("No workspaces found."));
+      return;
+    }
+    const personal = cache.workspaces.filter((w) => w.isPersonal);
+    const shared = cache.workspaces.filter((w) => !w.isPersonal);
+    const renderSection2 = (label, items) => {
+      if (items.length === 0) return;
+      console.log(chalk10.bold.cyan(`
+${label}`));
+      const table = new Table5({
+        head: [
+          chalk10.cyan("ID"),
+          chalk10.cyan("Name"),
+          chalk10.cyan("Role"),
+          chalk10.cyan("Last accessed")
+        ],
+        style: { head: [], border: ["gray"] }
+      });
+      for (const ws of items) {
+        const last = ws.lastAccessedAt ? new Date(ws.lastAccessedAt).toLocaleString() : "-";
+        table.push([ws.workspaceId, ws.name, ws.role, last]);
+      }
+      console.log(table.toString());
+    };
+    renderSection2("Personal", personal);
+    renderSection2("Shared", shared);
+    console.log(chalk10.gray(`
+Total: ${cache.workspaces.length} workspace(s)`));
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceSwitch(id) {
+  try {
+    const config = new Config();
+    const cache = await refreshWorkspacesCache(config);
+    const match = cache.workspaces.find((w) => w.workspaceId === id);
+    if (!match) {
+      console.error(chalk10.red(`Error: workspace '${id}' not found among your memberships.`));
+      console.error(
+        chalk10.gray(
+          "Run `bisque workspace list` to see what you can access. To join a workspace, run `bisque workspace join <code>`."
+        )
+      );
+      process.exit(3);
+    }
+    await config.set("activeWorkspaceId", id);
+    console.log(chalk10.green(`Active workspace set: ${match.name} (${match.role})`));
+    console.log(
+      chalk10.yellow(
+        "Note: Agents must still pass `--workspace <id>` explicitly on every mutating operation. This setting is a human convenience and is NOT read by agents."
+      )
+    );
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceCreate(name, options) {
+  try {
+    const config = new Config();
+    const client = new ApiClient(config);
+    const ws = await client.post("/v1/workspaces", { name });
+    if (options.json) {
+      console.log(JSON.stringify(ws, null, 2));
+      return;
+    }
+    console.log(chalk10.green(`Workspace created: ${ws.name}`));
+    console.log(`  ID: ${ws.workspaceId}`);
+    console.log(`  Owner: ${ws.ownerUserId}`);
+    const yes = options.yes === true || await confirm4("Switch to this workspace now? [y/N]", false);
+    if (yes) {
+      await refreshWorkspacesCache(config);
+      await config.set("activeWorkspaceId", ws.workspaceId);
+      console.log(chalk10.green(`Active workspace set: ${ws.name} (owner)`));
+    } else {
+      console.log(
+        chalk10.gray(
+          `Workspace ready. Run \`bisque workspace switch ${ws.workspaceId}\` to make it active.`
+        )
+      );
+    }
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceInvite(options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no active workspace. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const maxRedemptions = options.maxUses ? Number(options.maxUses) : 1;
+    if (!Number.isInteger(maxRedemptions) || maxRedemptions < 1 || maxRedemptions > 100) {
+      console.error(chalk10.red("Error: --max-uses must be an integer between 1 and 100."));
+      process.exit(1);
+    }
+    const expiresIn = options.expires ?? "7d";
+    const expiresAt = parseExpiresAt(expiresIn);
+    if (expiresAt === void 0) {
+      console.error(
+        chalk10.red("Error: --expires must be a duration like '7d', '24h', '30m' (max 30d).")
+      );
+      process.exit(1);
+    }
+    const maxExpiresAt = Math.floor(Date.now() / 1e3) + 30 * 86400;
+    if (expiresAt > maxExpiresAt) {
+      console.error(chalk10.red("Error: --expires must not exceed 30 days."));
+      process.exit(1);
+    }
+    const body = {
+      role: options.role ?? "member",
+      maxRedemptions,
+      expiresAt
+    };
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    const created = await client.post(
+      `/v1/workspaces/${targetWs}/invite-codes`,
+      body
+    );
+    if (options.json) {
+      console.log(JSON.stringify(created, null, 2));
+      return;
+    }
+    const expiresHuman = new Date(created.expiresAt * 1e3).toLocaleString();
+    console.log(chalk10.green(`Invite code created: ${chalk10.bold(created.code)}`));
+    console.log(`  Role: ${created.roleOnRedeem}`);
+    console.log(`  Max uses: ${created.maxRedemptions}`);
+    console.log(`  Expires: ${expiresHuman}`);
+    console.log("");
+    console.log(chalk10.gray("Share with your teammate:"));
+    console.log(chalk10.bold(`  bisque workspace join ${created.code}`));
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceJoin(code, options) {
+  try {
+    const config = new Config();
+    const client = new ApiClient(config);
+    const result = await client.post("/v1/workspaces/join", { code });
+    await refreshWorkspacesCache(config);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const verb = result.idempotent ? "Already a member of" : "Joined";
+    console.log(chalk10.green(`${verb} workspace: ${result.workspaceId} (role: ${result.role})`));
+    const yes = options.yes === true || await confirm4("Switch to this workspace now? [y/N]", false);
+    if (yes) {
+      await config.set("activeWorkspaceId", result.workspaceId);
+      console.log(chalk10.green("Active workspace updated."));
+    }
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceMembers(options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    const resp = await client.get(`/v1/workspaces/${targetWs}/members`);
+    const members = resp.members ?? [];
+    if (options.json) {
+      console.log(JSON.stringify(members, null, 2));
+      return;
+    }
+    if (members.length === 0) {
+      console.log(chalk10.yellow("No members found."));
+      return;
+    }
+    const table = new Table5({
+      head: [
+        chalk10.cyan("User ID"),
+        chalk10.cyan("Role"),
+        chalk10.cyan("Joined"),
+        chalk10.cyan("Last accessed")
+      ],
+      style: { head: [], border: ["gray"] }
+    });
+    for (const m of members) {
+      const joined = new Date(m.joinedAt).toLocaleString();
+      const last = m.lastAccessedAt ? new Date(m.lastAccessedAt).toLocaleString() : "-";
+      table.push([m.userId, m.role, joined, last]);
+    }
+    console.log(table.toString());
+    console.log(chalk10.gray(`
+Total: ${members.length} member(s)`));
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceTransfer(targetUserId, options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    if (options.clearSuccessor) {
+      const result2 = await client.post(`/v1/workspaces/${targetWs}/ownership-transfer`, {
+        mode: "set-successor",
+        successorUserId: null
+      });
+      if (options.json) {
+        console.log(JSON.stringify(result2, null, 2));
+        return;
+      }
+      console.log(chalk10.green(`Successor cleared for workspace ${result2.name}.`));
+      return;
+    }
+    const result = await client.post(`/v1/workspaces/${targetWs}/ownership-transfer`, {
+      mode: "transfer",
+      newOwnerUserId: targetUserId
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(
+      chalk10.green(`Ownership transferred to ${targetUserId} for workspace ${result.name}.`)
+    );
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceSetSuccessor(userIdOrNull, options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const successorUserId = userIdOrNull.toLowerCase() === "null" ? null : userIdOrNull;
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    const result = await client.post(`/v1/workspaces/${targetWs}/ownership-transfer`, {
+      mode: "set-successor",
+      successorUserId
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(
+      chalk10.green(
+        successorUserId ? `Successor set to ${successorUserId} for workspace ${result.name}.` : `Successor cleared for workspace ${result.name}.`
+      )
+    );
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+async function workspaceLeave(options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const selfId = await getSelfUserId(config);
+    if (!selfId) {
+      console.error(chalk10.red("Error: could not resolve your user id -- are you authenticated?"));
+      process.exit(2);
+    }
+    const ok = await confirm4(
+      `Leave workspace ${targetWs}? You will need a new invite code to rejoin. [y/N]`,
+      options.yes === true
+    );
+    if (!ok) {
+      console.log(chalk10.gray("Aborted."));
+      return;
+    }
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    await client.delete(`/v1/workspaces/${targetWs}/members/${selfId}`);
+    const active = await config.get("activeWorkspaceId");
+    if (active === targetWs) {
+      await config.set("activeWorkspaceId", void 0);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ workspaceId: targetWs, left: true }, null, 2));
+      return;
+    }
+    console.log(chalk10.green(`Left workspace ${targetWs}.`));
+  } catch (error) {
+    exitWithError(error);
+  }
+}
+function renderStructure(structure) {
+  const sections = [
+    { label: "Projects", folders: structure?.projects ?? [] },
+    { label: "Areas", folders: structure?.areas ?? [] },
+    { label: "Resources", folders: structure?.resources ?? [] },
+    { label: "Archive", folders: structure?.archive ?? [] }
+  ];
+  const totalFolders = sections.reduce((n, s) => n + s.folders.length, 0);
+  if (totalFolders === 0) {
+    console.log(chalk10.yellow("Workspace is empty -- no folders found."));
+    return;
+  }
+  for (const { label, folders } of sections) {
+    if (folders.length === 0) continue;
+    console.log(chalk10.bold.cyan(`
+${label}`));
+    for (const folder of folders) {
+      console.log(`  ${folder}`);
+    }
+  }
+  console.log("");
+}
+function renderDeleteResult(result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.status === "deleted") {
+    console.log(chalk10.green("Workspace deleted (cascade complete)."));
+    return;
+  }
+  if (result.status === "pending-async") {
+    console.log(
+      chalk10.green(
+        `Workspace soft-deleted; large-cascade scheduled (job: ${result.jobId}). Membership has been revoked; data drain happens asynchronously.`
+      )
+    );
+    return;
+  }
+  if (result.status === "transferred") {
+    console.log(
+      chalk10.green(
+        `Ownership transferred to ${result.workspace.ownerUserId}. New owner of '${result.workspace.name}'.`
+      )
+    );
+    return;
+  }
+}
+function renderDeleteConfirmMenu(resp) {
+  console.log(chalk10.bold("\nDelete workspace -- confirmation required"));
+  console.log(`  Workspace: ${resp.workspace.name} (${resp.workspace.id})`);
+  console.log(`  Members: ${resp.workspace.memberCount}`);
+  console.log(`  Admins: ${resp.workspace.adminCount}`);
+  console.log(chalk10.bold("\nAvailable actions:"));
+  for (const opt of resp.options) {
+    if (opt.action === "transfer-to") {
+      console.log(`  - transfer-to=<userId>   ${opt.label}`);
+      if (opt.validRecipients && opt.validRecipients.length > 0) {
+        console.log(chalk10.gray(`      eligible: ${opt.validRecipients.join(", ")}`));
+      }
+    } else {
+      console.log(`  - cascade-delete         ${opt.label}`);
+    }
+  }
+  console.log(
+    chalk10.gray("\nRe-run with --confirm cascade-delete OR --confirm transfer-to=<userId>")
+  );
+}
+async function buildDeleteQueryString(action, targetWs, assumeYes) {
+  if (action === "cascade-delete") {
+    const ok = await confirm4(
+      `Cascade-delete workspace ${targetWs}? This cannot be undone. [y/N]`,
+      assumeYes
+    );
+    if (!ok) {
+      console.log(chalk10.gray("Aborted."));
+      return void 0;
+    }
+    return "confirm=true&action=cascade-delete";
+  }
+  if (action.startsWith("transfer-to=")) {
+    const recipient = action.slice("transfer-to=".length);
+    if (!recipient) {
+      console.error(chalk10.red("Error: --confirm transfer-to=<userId> requires a userId."));
+      process.exit(1);
+    }
+    return `confirm=true&action=transfer-to&recipient=${encodeURIComponent(recipient)}`;
+  }
+  console.error(
+    chalk10.red(
+      `Error: --confirm must be 'cascade-delete' or 'transfer-to=<userId>' (got: ${action})`
+    )
+  );
+  process.exit(1);
+}
+async function runDeletePhase1(client, targetWs, json) {
+  const resp = await client.delete(`/v1/workspaces/${targetWs}`);
+  if (!resp || typeof resp === "object" && !("status" in resp)) {
+    if (json) {
+      console.log(JSON.stringify({ status: "deleted" }, null, 2));
+      return;
+    }
+    console.log(chalk10.green("Workspace deleted."));
+    return;
+  }
+  if (json) {
+    console.log(JSON.stringify(resp, null, 2));
+    return;
+  }
+  renderDeleteConfirmMenu(resp);
+}
+function classifyDeleteResponse(raw) {
+  if (raw === void 0) {
+    return { status: "deleted" };
+  }
+  if (typeof raw === "object" && raw !== null && "status" in raw && raw.status === "pending-async") {
+    const j = raw;
+    return { status: "pending-async", jobId: j.jobId };
+  }
+  return { status: "transferred", workspace: raw };
+}
+async function workspaceDelete(options) {
+  try {
+    const config = new Config();
+    const targetWs = await resolveSubcommandWorkspaceId(options, config);
+    if (!targetWs) {
+      console.error(
+        chalk10.red(
+          "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
+        )
+      );
+      process.exit(5);
+    }
+    const client = new ApiClient(config, { workspaceId: targetWs });
+    if (!options.confirm) {
+      await runDeletePhase1(client, targetWs, options.json === true);
+      return;
+    }
+    const queryString = await buildDeleteQueryString(
+      options.confirm,
+      targetWs,
+      options.yes === true
+    );
+    if (queryString === void 0) {
+      return;
+    }
+    const raw = await client.delete(`/v1/workspaces/${targetWs}?${queryString}`);
+    const result = classifyDeleteResponse(raw);
+    const active = await config.get("activeWorkspaceId");
+    if (active === targetWs) {
+      await config.set("activeWorkspaceId", void 0);
+    }
+    renderDeleteResult(result, options.json === true);
+  } catch (error) {
+    if (error instanceof BisqueApiError) {
+      exitWithError(error);
+    }
+    const message = unwrapApiErrorMessage(error);
+    console.error(chalk10.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+function registerWorkspaceCommand(program2) {
+  const workspace = program2.command("workspace").description("Manage workspaces (shared + personal)");
+  workspace.command("list").description("List your workspaces (personal first, then shared)").option("--json", "Output as JSON").action(async (options) => {
+    await workspaceList(options.json === true);
+  });
+  workspace.command("switch <id>").description("Set the active workspace for human-convenience use").action(async (id) => {
+    await workspaceSwitch(id);
+  });
+  workspace.command("create <name>").description("Create a new shared workspace (you become its owner)").option("--json", "Output as JSON").option("-y, --yes", "Auto-switch to the new workspace without prompting").action(async (name, options) => {
+    await workspaceCreate(name, options);
+  });
+  workspace.command("invite").description("Generate a new invite code (admin/owner only)").option("--role <role>", "Role granted to the invitee (admin|member|viewer)", "member").option("--max-uses <n>", "Maximum number of redemptions (1-100)", "1").option("--expires <duration>", "Expiration window (e.g. 7d, 24h, 30m; max 30d)", "7d").option("--workspace <id>", "Workspace to issue the invite against (defaults to active)").option("--json", "Output as JSON").action(
+    async (options) => {
+      await workspaceInvite(options);
+    }
+  );
+  workspace.command("join <code>").description("Redeem an invite code").option("-y, --yes", "Auto-switch to the joined workspace without prompting").option("--json", "Output as JSON").action(async (code, options) => {
+    await workspaceJoin(code, options);
+  });
+  workspace.command("members").description("List members of a workspace (defaults to active)").option("--workspace <id>", "Workspace to list (defaults to active)").option("--json", "Output as JSON").action(async (options) => {
+    await workspaceMembers(options);
+  });
+  workspace.command("transfer <userId>").description("Transfer ownership of a workspace (owner only)").option("--workspace <id>", "Workspace to transfer (defaults to active)").option("--clear-successor", "Clear the successor instead of transferring ownership now").option("--json", "Output as JSON").action(
+    async (userId, options) => {
+      await workspaceTransfer(userId, options);
+    }
+  );
+  workspace.command("set-successor <userIdOrNull>").description(
+    "Set or clear the workspace's ownership successor (owner only). Pass 'null' to clear."
+  ).option("--workspace <id>", "Workspace to update (defaults to active)").option("--json", "Output as JSON").action(async (userIdOrNull, options) => {
+    await workspaceSetSuccessor(userIdOrNull, options);
+  });
+  workspace.command("leave").description("Leave a workspace (you must not be the sole owner)").option("--workspace <id>", "Workspace to leave (defaults to active)").option("-y, --yes", "Skip confirmation prompt").option("--json", "Output as JSON").action(async (options) => {
+    await workspaceLeave(options);
+  });
+  workspace.command("delete").description("Delete a workspace (two-phase: first call shows options, second call executes)").option("--workspace <id>", "Workspace to delete (defaults to active)").option(
+    "--confirm <action>",
+    "Phase 2: 'cascade-delete' or 'transfer-to=<userId>' (omit for the options menu)"
+  ).option("-y, --yes", "Skip the interactive y/N prompt on cascade-delete").option("--json", "Output as JSON").action(
+    async (options) => {
+      await workspaceDelete(options);
+    }
+  );
+  workspace.command("structure").description("Show PARA folder hierarchy for the resolved workspace").action(async () => {
+    try {
+      const client = new ApiClient();
+      const result = await client.get("/v1/workspace/structure");
+      renderStructure(result.structure);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk10.red(`Error: ${message}`));
+      process.exitCode = 1;
+    }
+  });
+  workspace.command("get <id>").description("Get personal-workspace details (legacy)").option("--json", "Output as JSON").action(async (id, options) => {
+    try {
+      const client = new ApiClient();
+      const ws = await client.get(`/v1/workspaces/${id}`);
+      if (options.json) {
+        console.log(JSON.stringify(ws, null, 2));
+        return;
+      }
+      console.log(chalk10.bold("\nWorkspace Details\n"));
+      console.log(`${chalk10.cyan("ID:")}         ${ws.workspaceId}`);
+      console.log(`${chalk10.cyan("Name:")}       ${ws.name}`);
+      console.log(`${chalk10.cyan("User ID:")}    ${ws.userId}`);
+      console.log(`${chalk10.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
+      console.log(`${chalk10.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk10.red(`Error: ${message}`));
+      process.exitCode = 1;
+    }
+  });
+  workspace.command("default").description("Show personal-default workspace (legacy)").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = new ApiClient();
+      const ws = await client.get("/v1/workspaces/default");
+      if (options.json) {
+        console.log(JSON.stringify(ws, null, 2));
+        return;
+      }
+      console.log(chalk10.bold("\nDefault Workspace\n"));
+      console.log(`${chalk10.cyan("ID:")}         ${ws.workspaceId}`);
+      console.log(`${chalk10.cyan("Name:")}       ${ws.name}`);
+      console.log(`${chalk10.cyan("User ID:")}    ${ws.userId}`);
+      console.log(`${chalk10.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
+      console.log(`${chalk10.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
+// src/commands/index.ts
+function registerCommands(program2) {
+  program2.command("health").description("Check CLI health").action(async () => {
+    console.log("bisque CLI v0.1.0 - OK");
+  });
+  registerAuthCommand(program2);
+  registerConfigCommand(program2);
+  registerWorkspaceCommand(program2);
+  registerAddCommand(program2);
+  registerGetCommand(program2);
+  registerDeleteCommand(program2);
+  registerBulkAddCommand(program2);
+  registerBatchCommand(program2);
+  registerSearchCommand(program2);
+  registerMoveCommand(program2);
+  registerLinkCommand(program2);
+  registerTagCommand(program2);
+  registerInboxCommand(program2);
+  registerManifestCommand(program2);
+  registerRecallCommand(program2);
+  registerRecallAnnotateCommand(program2);
+  registerUpdateCommand(program2);
+  registerListCommand(program2);
+  registerLoadCommand(program2);
+  registerLsCommand(program2);
+  registerTaskCommand(program2);
+  registerChainCommand(program2);
+  registerTreeCommand(program2);
+  registerMaintenanceCommand(program2);
+  registerPersonaCommand(program2);
+  registerAgentsCommand(program2);
+  registerPluginCommand(program2);
+  registerSkillCommand(program2);
+  registerMeasureCommand(program2);
+}
+
+// src/index.ts
+init_config();
+init_api_client();
+init_runtime_context();
+init_workspace_context();
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("bisque").description("Agent memory layer CLI").version(version);
+program.addOption(
+  new Option3(
+    "--workspace <id>",
+    "Workspace ID to target (overrides BISQUE_WORKSPACE_ID and config)"
+  )
+).addOption(
+  new Option3(
+    "--no-workspace-header",
+    "Suppress the [workspace: \u2026] header on stdout (still emitted to stderr for agent scraping)"
+  )
+).addOption(new Option3("--quiet", "Suppress workspace headers and storage-attribution notes"));
+var ALWAYS_JSON_COMMANDS = /* @__PURE__ */ new Set(["manifest"]);
+program.hook("preAction", async (thisCommand, actionCommand) => {
+  const opts = thisCommand.opts();
+  const headerEnabled = opts.workspaceHeader !== false;
+  const quiet = opts.quiet === true;
+  const actionOpts = actionCommand?.opts?.() ?? {};
+  const explicitJsonFlag = actionOpts.json === true;
+  const actionName = actionCommand?.name?.() ?? "";
+  const alwaysJson = ALWAYS_JSON_COMMANDS.has(actionName);
+  const jsonMode = explicitJsonFlag || alwaysJson;
+  const config = new Config();
+  const workspaceContext = await resolveWorkspaceContext(config, opts.workspace);
+  setRuntimeContext({ workspaceContext, headerEnabled, quiet, config });
+  const effectiveHeaderEnabled = jsonMode ? false : headerEnabled;
+  printWorkspaceHeader(workspaceContext, { enabled: effectiveHeaderEnabled, quiet });
+});
+program.hook("postAction", async () => {
+  if (!consumeMembershipMutationFlag()) return;
+  try {
+    await refreshWorkspacesCache(new Config());
+  } catch {
+  }
+});
+registerCommands(program);
+program.parseAsync().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});