knowbrain-cli 0.0.1-rc.0

package/dist/kb.js

@@ -0,0 +1,2622 @@
+#!/usr/bin/env node
+
+// src/cli/run.ts
+import { CommanderError } from "commander";
+
+// src/http/http-error.ts
+function writeCliError(stderr, err) {
+  stderr.write(`${JSON.stringify(err)}
+`);
+}
+
+// src/cli/program.ts
+import { Command } from "commander";
+
+// src/commands/connectors/connectors.ts
+import { readFile as readFile2 } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+
+// ../sdk/dist/omi-sdk-error.js
+var OmiSdkError = class extends Error {
+  code;
+  details;
+  status;
+  constructor(init) {
+    super(init.message);
+    this.name = "OmiSdkError";
+    this.code = init.code;
+    this.details = init.details ?? null;
+    if (init.status !== void 0) {
+      this.status = init.status;
+    }
+  }
+};
+function omiSdkError(init) {
+  return new OmiSdkError(init);
+}
+
+// ../sdk/dist/error-from-response.js
+function statusFallbackCode(status) {
+  if (status === 404)
+    return "NOT_FOUND";
+  if (status === 409)
+    return "CONFLICT";
+  if (status === 400)
+    return "VALIDATION_ERROR";
+  return "INTERNAL";
+}
+async function omiSdkErrorFromResponse(res) {
+  const text = await res.text();
+  try {
+    const j = JSON.parse(text);
+    if (j && typeof j === "object" && !Array.isArray(j)) {
+      const o = j;
+      if (typeof o["code"] === "string" && typeof o["message"] === "string") {
+        return omiSdkError({
+          code: o["code"],
+          message: o["message"],
+          details: "details" in o ? o["details"] ?? null : null,
+          status: res.status
+        });
+      }
+      if (typeof o["error"] === "string") {
+        return omiSdkError({
+          code: statusFallbackCode(res.status),
+          message: o["error"],
+          details: null,
+          status: res.status
+        });
+      }
+    }
+  } catch {
+  }
+  return omiSdkError({
+    code: statusFallbackCode(res.status),
+    message: text.length > 0 ? text : res.statusText || `HTTP ${res.status}`,
+    details: null,
+    status: res.status
+  });
+}
+
+// ../../packages/core/dist/utils/kb-uri.js
+function parseKbUri(uri) {
+  const prefix = "kb://";
+  const t = uri.trim();
+  if (!t.startsWith(prefix)) {
+    throw new Error(`expected kb:// URI, got: ${uri}`);
+  }
+  const rest = t.slice(prefix.length).replace(/^\/+/u, "").replace(/\/+$/u, "");
+  if (rest.length === 0) {
+    throw new Error("kb:// URI must include at least a spaceId");
+  }
+  const parts = rest.split("/");
+  if (parts[0].length === 0) {
+    throw new Error("kb:// URI must include a spaceId");
+  }
+  const spaceId = parts[0];
+  const path = parts.slice(2).join("/");
+  if (parts.length >= 2 && parts[1].length > 0) {
+    return { spaceId, storeId: parts[1], path };
+  }
+  return { spaceId, path };
+}
+function formatKbUri(spaceId, storeId, path) {
+  if (storeId === void 0 || storeId.length === 0) {
+    return `kb://${spaceId}`;
+  }
+  if (path !== void 0 && path.length > 0) {
+    return `kb://${spaceId}/${storeId}/${path}`;
+  }
+  return `kb://${spaceId}/${storeId}`;
+}
+
+// ../../packages/core/dist/utils/logger.js
+import pino from "pino";
+function resolveLevel(explicit) {
+  if (explicit !== void 0 && explicit !== "") {
+    return explicit;
+  }
+  const fromEnv = process.env["LOG_LEVEL"];
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  return process.env["NODE_ENV"] === "production" ? "info" : "debug";
+}
+function usePrettyTransport() {
+  return process.env["LOG_PRETTY"] === "1";
+}
+function createOmiLogger(options) {
+  const level = resolveLevel(options.level);
+  const base = { service: options.service };
+  if (options.bindings) {
+    Object.assign(base, options.bindings);
+  }
+  const opts = { level, base };
+  if (usePrettyTransport()) {
+    opts.transport = {
+      target: "pino-pretty",
+      options: { colorize: true }
+    };
+  }
+  const dest = options.destination ?? "stdout";
+  if (dest === "stderr") {
+    return pino(opts, pino.destination(2));
+  }
+  return pino(opts);
+}
+
+// ../../packages/core/dist/metadata/field-role.js
+var FieldRole = {
+  mutable: "mutable",
+  immutable: "immutable",
+  status: "status"
+};
+
+// ../../packages/core/dist/metadata/field-decorator.js
+var rolesByConstructor = /* @__PURE__ */ new Map();
+function ensureMap(ctor) {
+  let m = rolesByConstructor.get(ctor);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    rolesByConstructor.set(ctor, m);
+  }
+  return m;
+}
+function metadataField(role) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    const key = typeof propertyKey === "string" ? propertyKey : String(propertyKey);
+    ensureMap(ctor).set(key, role);
+  };
+}
+function mutableField() {
+  return metadataField(FieldRole.mutable);
+}
+function immutableField() {
+  return metadataField(FieldRole.immutable);
+}
+function statusField() {
+  return metadataField(FieldRole.status);
+}
+
+// ../../packages/core/dist/metadata/space-scoped-base.js
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SpaceScopedResource = class {
+  id;
+  spaceId;
+  name;
+  /** Longer label; empty string means none. */
+  description = "";
+  createdAt;
+  updatedAt;
+};
+__decorate([
+  immutableField()
+], SpaceScopedResource.prototype, "id", void 0);
+__decorate([
+  immutableField()
+], SpaceScopedResource.prototype, "spaceId", void 0);
+__decorate([
+  mutableField()
+], SpaceScopedResource.prototype, "name", void 0);
+__decorate([
+  mutableField()
+], SpaceScopedResource.prototype, "description", void 0);
+__decorate([
+  immutableField()
+], SpaceScopedResource.prototype, "createdAt", void 0);
+__decorate([
+  immutableField()
+], SpaceScopedResource.prototype, "updatedAt", void 0);
+
+// ../../packages/core/dist/connectors/resource.js
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ConnectorResource = class extends SpaceScopedResource {
+  type;
+  config = {};
+  secrets = {};
+  targetStoreIds;
+  lastSyncAt;
+  lastSyncStatus = "ready";
+};
+__decorate2([
+  immutableField()
+], ConnectorResource.prototype, "type", void 0);
+__decorate2([
+  mutableField()
+], ConnectorResource.prototype, "config", void 0);
+__decorate2([
+  mutableField()
+], ConnectorResource.prototype, "secrets", void 0);
+__decorate2([
+  immutableField()
+], ConnectorResource.prototype, "targetStoreIds", void 0);
+__decorate2([
+  mutableField()
+], ConnectorResource.prototype, "lastSyncAt", void 0);
+__decorate2([
+  mutableField()
+], ConnectorResource.prototype, "lastSyncStatus", void 0);
+
+// ../../packages/core/dist/space/types.js
+var __decorate3 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SpaceResource = class {
+  id;
+  name;
+  /** Longer label; empty string means none. */
+  description = "";
+  status;
+  createdAt;
+  updatedAt;
+};
+__decorate3([
+  immutableField()
+], SpaceResource.prototype, "id", void 0);
+__decorate3([
+  mutableField()
+], SpaceResource.prototype, "name", void 0);
+__decorate3([
+  mutableField()
+], SpaceResource.prototype, "description", void 0);
+__decorate3([
+  statusField()
+], SpaceResource.prototype, "status", void 0);
+__decorate3([
+  immutableField()
+], SpaceResource.prototype, "createdAt", void 0);
+__decorate3([
+  immutableField()
+], SpaceResource.prototype, "updatedAt", void 0);
+
+// ../../packages/core/dist/store/types.js
+var __decorate4 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var StoreResource = class extends SpaceScopedResource {
+  status;
+  /** When true, durable head cannot be updated via {@link import("./runtime.js").Store.mergeProposal}. */
+  readOnly = false;
+};
+__decorate4([
+  statusField()
+], StoreResource.prototype, "status", void 0);
+__decorate4([
+  immutableField()
+], StoreResource.prototype, "readOnly", void 0);
+var ProposalResource = class extends SpaceScopedResource {
+  storeId;
+  /** Optional task association for task-scoped proposal listing. */
+  taskId;
+  baseRevisionId;
+  workDir;
+  status;
+};
+__decorate4([
+  immutableField()
+], ProposalResource.prototype, "storeId", void 0);
+__decorate4([
+  immutableField()
+], ProposalResource.prototype, "taskId", void 0);
+__decorate4([
+  immutableField()
+], ProposalResource.prototype, "baseRevisionId", void 0);
+__decorate4([
+  mutableField()
+], ProposalResource.prototype, "workDir", void 0);
+__decorate4([
+  statusField()
+], ProposalResource.prototype, "status", void 0);
+
+// ../../packages/core/dist/task/default-task.js
+var DEFAULT_TASK_ID = "default";
+
+// ../../packages/core/dist/task/resource.js
+var __decorate5 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var TaskResource = class extends SpaceScopedResource {
+  /** Immutable store bindings used to resolve runtime stores for this task. */
+  storeIds;
+  status;
+};
+__decorate5([
+  immutableField()
+], TaskResource.prototype, "storeIds", void 0);
+__decorate5([
+  statusField()
+], TaskResource.prototype, "status", void 0);
+
+// ../sdk/dist/parse-wire.js
+function assertRecord(j, label) {
+  if (!j || typeof j !== "object" || Array.isArray(j)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: `invalid ${label}: expected object`,
+      details: null
+    });
+  }
+  return j;
+}
+function parseSpaceResourceWire(j) {
+  const o = assertRecord(j, "space resource");
+  const r = new SpaceResource();
+  r.id = String(o["id"] ?? "");
+  r.name = String(o["name"] ?? "");
+  r.description = String(o["description"] ?? "");
+  r.status = o["status"];
+  r.createdAt = new Date(String(o["createdAt"] ?? ""));
+  r.updatedAt = new Date(String(o["updatedAt"] ?? ""));
+  return r;
+}
+function parseStringMapWire(o, field) {
+  if (o === void 0 || o === null) {
+    return {};
+  }
+  if (typeof o !== "object" || Array.isArray(o)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: `invalid connector resource: expected object for ${field}`,
+      details: null
+    });
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (typeof v === "string") {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function parseConnectorResourceWire(j) {
+  const o = assertRecord(j, "connector resource");
+  const r = new ConnectorResource();
+  r.id = String(o["id"] ?? "");
+  r.spaceId = String(o["spaceId"] ?? "");
+  r.name = String(o["name"] ?? "");
+  r.description = String(o["description"] ?? "");
+  r.type = String(o["type"] ?? "");
+  r.config = parseStringMapWire(o["config"], "config");
+  r.secrets = parseStringMapWire(o["secrets"], "secrets");
+  const ids = o["targetStoreIds"];
+  if (!Array.isArray(ids)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid connector resource: expected targetStoreIds array",
+      details: null
+    });
+  }
+  if (ids.some((x) => typeof x !== "string")) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid connector resource: expected targetStoreIds string[]",
+      details: null
+    });
+  }
+  r.targetStoreIds = ids;
+  const lsa = o["lastSyncAt"];
+  if (lsa !== void 0 && lsa !== null) {
+    r.lastSyncAt = new Date(String(lsa));
+  }
+  r.lastSyncStatus = String(o["lastSyncStatus"] ?? "ready");
+  r.createdAt = new Date(String(o["createdAt"] ?? ""));
+  r.updatedAt = new Date(String(o["updatedAt"] ?? ""));
+  return r;
+}
+function parseStoreResourceWire(j) {
+  const o = assertRecord(j, "store resource");
+  const r = new StoreResource();
+  r.id = String(o["id"] ?? "");
+  r.spaceId = String(o["spaceId"] ?? "");
+  r.name = String(o["name"] ?? "");
+  r.description = String(o["description"] ?? "");
+  r.status = o["status"];
+  r.readOnly = o["readOnly"] === true;
+  r.createdAt = new Date(String(o["createdAt"] ?? ""));
+  r.updatedAt = new Date(String(o["updatedAt"] ?? ""));
+  return r;
+}
+function parseTaskResourceWire(j) {
+  const o = assertRecord(j, "task resource");
+  const r = new TaskResource();
+  r.id = String(o["id"] ?? "");
+  r.spaceId = String(o["spaceId"] ?? "");
+  r.name = String(o["name"] ?? "");
+  r.description = String(o["description"] ?? "");
+  r.status = o["status"];
+  const storeIds = o["storeIds"];
+  if (!Array.isArray(storeIds)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid task resource: expected storeIds array",
+      details: null
+    });
+  }
+  if (storeIds.some((storeId) => typeof storeId !== "string")) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid task resource: expected storeIds string[]",
+      details: null
+    });
+  }
+  r.storeIds = storeIds;
+  r.createdAt = new Date(String(o["createdAt"] ?? ""));
+  r.updatedAt = new Date(String(o["updatedAt"] ?? ""));
+  return r;
+}
+function parseProposalResourceWire(j) {
+  const o = assertRecord(j, "proposal resource");
+  const r = new ProposalResource();
+  r.id = String(o["id"] ?? "");
+  r.spaceId = String(o["spaceId"] ?? "");
+  r.storeId = String(o["storeId"] ?? "");
+  if (o["taskId"] !== void 0) {
+    r.taskId = String(o["taskId"]);
+  }
+  r.name = String(o["name"] ?? "");
+  r.description = String(o["description"] ?? "");
+  r.baseRevisionId = String(o["baseRevisionId"] ?? "");
+  r.workDir = String(o["workDir"] ?? "");
+  r.status = o["status"];
+  r.createdAt = new Date(String(o["createdAt"] ?? ""));
+  r.updatedAt = new Date(String(o["updatedAt"] ?? ""));
+  return r;
+}
+function parseRevisionWire(j) {
+  const o = assertRecord(j, "revision");
+  return {
+    revisionId: String(o["revisionId"] ?? ""),
+    createTime: new Date(String(o["createTime"] ?? "")),
+    title: String(o["title"] ?? ""),
+    description: String(o["description"] ?? ""),
+    authorName: String(o["authorName"] ?? ""),
+    authorEmail: String(o["authorEmail"] ?? "")
+  };
+}
+function parseProposalDiffWire(j) {
+  const o = assertRecord(j, "proposal diff");
+  if (o["format"] !== "unified") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid proposal diff: expected format unified",
+      details: null
+    });
+  }
+  if (typeof o["rawUnifiedDiff"] !== "string") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid proposal diff: expected rawUnifiedDiff string",
+      details: null
+    });
+  }
+  if (!Array.isArray(o["files"])) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid proposal diff: expected files array",
+      details: null
+    });
+  }
+  return j;
+}
+function parseProposalDiffItemWire(j) {
+  const o = assertRecord(j, "proposal diff item");
+  if (!("proposal" in o) || !("diff" in o)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid proposal diff item: expected proposal and diff fields",
+      details: null
+    });
+  }
+  return {
+    proposal: parseProposalResourceWire(o["proposal"]),
+    diff: parseProposalDiffWire(o["diff"])
+  };
+}
+function parseCommandResultWire(j) {
+  const o = assertRecord(j, "command result");
+  if (typeof o["stdout"] !== "string") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid command result: expected stdout string",
+      details: null
+    });
+  }
+  if (typeof o["stderr"] !== "string") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid command result: expected stderr string",
+      details: null
+    });
+  }
+  if (typeof o["exitCode"] !== "number" || !Number.isFinite(o["exitCode"])) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid command result: expected exitCode number",
+      details: null
+    });
+  }
+  if (typeof o["startedAt"] !== "string" || typeof o["finishedAt"] !== "string") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: "invalid command result: expected startedAt/finishedAt strings",
+      details: null
+    });
+  }
+  return {
+    stdout: o["stdout"],
+    stderr: o["stderr"],
+    exitCode: o["exitCode"],
+    startedAt: o["startedAt"],
+    finishedAt: o["finishedAt"]
+  };
+}
+function parseMatchedContextWire(j) {
+  const o = assertRecord(j, "matched context");
+  const out = {
+    contextType: String(o["contextType"] ?? ""),
+    uri: String(o["uri"] ?? ""),
+    level: Number(o["level"] ?? 0),
+    score: Number(o["score"] ?? 0),
+    category: String(o["category"] ?? ""),
+    matchReason: String(o["matchReason"] ?? ""),
+    abstract: String(o["abstract"] ?? "")
+  };
+  if (o["overview"] !== void 0) {
+    out.overview = String(o["overview"]);
+  }
+  return out;
+}
+function parseMatchedContextArrayWire(j, label) {
+  if (!Array.isArray(j)) {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: `invalid ${label}: expected array`,
+      details: null
+    });
+  }
+  return j.map((item) => parseMatchedContextWire(item));
+}
+function parseSearchResultWire(j) {
+  const o = assertRecord(j, "search result");
+  return {
+    memories: parseMatchedContextArrayWire(o["memories"], "search result memories"),
+    resources: parseMatchedContextArrayWire(o["resources"], "search result resources"),
+    skills: parseMatchedContextArrayWire(o["skills"], "search result skills"),
+    total: Number(o["total"] ?? 0)
+  };
+}
+
+// ../sdk/dist/url.js
+function joinBaseUrl(base, path) {
+  const b = base.replace(/\/$/, "");
+  return `${b}${path.startsWith("/") ? path : `/${path}`}`;
+}
+
+// ../sdk/dist/create-omi-sdk.js
+function requireStoreScope(space) {
+  if (space.trim().length === 0) {
+    throw omiSdkError({
+      code: "VALIDATION_ERROR",
+      message: "space is required for store operations (set it when creating the SDK client)",
+      details: null
+    });
+  }
+}
+async function fetchOk(fetchFn, absoluteUrl, init) {
+  const res = await fetchFn(absoluteUrl, init);
+  if (!res.ok) {
+    throw await omiSdkErrorFromResponse(res);
+  }
+  return res;
+}
+async function readJsonBody(text, label) {
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: `empty JSON body (${label})`,
+      details: null
+    });
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw omiSdkError({
+      code: "INTERNAL",
+      message: `invalid JSON (${label})`,
+      details: null
+    });
+  }
+}
+function createOmiSdk(init) {
+  const fetchFn = init.fetch ?? globalThis.fetch.bind(globalThis);
+  const baseUrl = init.baseUrl.replace(/\/$/, "");
+  const space = init.space;
+  function abs(path) {
+    return joinBaseUrl(baseUrl, path);
+  }
+  function storeBase() {
+    requireStoreScope(space);
+    return `/spaces/${encodeURIComponent(space)}/stores`;
+  }
+  function taskBase() {
+    requireStoreScope(space);
+    return `/spaces/${encodeURIComponent(space)}/tasks`;
+  }
+  function connectorBase() {
+    requireStoreScope(space);
+    return `/spaces/${encodeURIComponent(space)}/connectors`;
+  }
+  const spaceApi = {
+    async create(input) {
+      const initReq = { method: "POST" };
+      if (input !== void 0 && Object.keys(input).length > 0) {
+        initReq.headers = { "content-type": "application/json" };
+        initReq.body = JSON.stringify(input);
+      }
+      const res = await fetchOk(fetchFn, abs("/spaces"), initReq);
+      const j = await readJsonBody(await res.text(), "POST /spaces");
+      return parseSpaceResourceWire(j);
+    },
+    async get(spaceId) {
+      const res = await fetchOk(fetchFn, abs(`/spaces/${encodeURIComponent(spaceId)}`), {
+        method: "GET"
+      });
+      const j = await readJsonBody(await res.text(), "GET /spaces/:id");
+      return parseSpaceResourceWire(j);
+    },
+    async list() {
+      const res = await fetchOk(fetchFn, abs("/spaces"), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET /spaces");
+      const o = j;
+      const arr = o["spaces"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list spaces: expected { spaces: [] }",
+          details: null
+        });
+      }
+      return arr.map((x) => parseSpaceResourceWire(x));
+    },
+    async update(spaceId, patch) {
+      const res = await fetchOk(fetchFn, abs(`/spaces/${encodeURIComponent(spaceId)}`), {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      const j = await readJsonBody(await res.text(), "PATCH /spaces/:id");
+      return parseSpaceResourceWire(j);
+    },
+    async delete(spaceId) {
+      await fetchOk(fetchFn, abs(`/spaces/${encodeURIComponent(spaceId)}`), {
+        method: "DELETE"
+      });
+    }
+  };
+  const storeApi = {
+    async create(input) {
+      const initReq = { method: "POST" };
+      if (input !== void 0 && Object.keys(input).length > 0) {
+        initReq.headers = { "content-type": "application/json" };
+        initReq.body = JSON.stringify(input);
+      }
+      const res = await fetchOk(fetchFn, abs(`${storeBase()}`), initReq);
+      const j = await readJsonBody(await res.text(), "POST .../stores");
+      return parseStoreResourceWire(j);
+    },
+    async get(storeId) {
+      const res = await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}`), {
+        method: "GET"
+      });
+      const j = await readJsonBody(await res.text(), "GET .../stores/:id");
+      return parseStoreResourceWire(j);
+    },
+    async list() {
+      const res = await fetchOk(fetchFn, abs(storeBase()), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../stores");
+      const o = j;
+      const arr = o["stores"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list stores: expected { stores: [] }",
+          details: null
+        });
+      }
+      return arr.map((x) => parseStoreResourceWire(x));
+    },
+    async update(storeId, patch) {
+      const res = await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}`), {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      const j = await readJsonBody(await res.text(), "PATCH .../stores/:id");
+      return parseStoreResourceWire(j);
+    },
+    async delete(storeId) {
+      await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}`), {
+        method: "DELETE"
+      });
+    },
+    async waitSync(storeId) {
+      await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}/wait-sync`), {
+        method: "POST"
+      });
+    },
+    async listRevisions(storeId) {
+      const res = await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}/revisions`), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../revisions");
+      const o = j;
+      const arr = o["revisions"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list revisions: expected { revisions: [] }",
+          details: null
+        });
+      }
+      return arr.map((x) => parseRevisionWire(x));
+    },
+    async restoreRevision(storeId, revisionId) {
+      await fetchOk(fetchFn, abs(`${storeBase()}/${encodeURIComponent(storeId)}/revisions/${encodeURIComponent(revisionId)}/restore`), { method: "POST" });
+    },
+    async uploadFile(params) {
+      const q = `${storeBase()}/${encodeURIComponent(params.storeId)}/files?path=${encodeURIComponent(params.path)}`;
+      await fetchOk(fetchFn, abs(q), {
+        method: "PUT",
+        headers: {
+          "content-type": params.contentType ?? "application/octet-stream"
+        },
+        body: params.body
+      });
+    },
+    async downloadFile(params) {
+      const q = `${storeBase()}/${encodeURIComponent(params.storeId)}/files?path=${encodeURIComponent(params.path)}`;
+      const res = await fetchOk(fetchFn, abs(q), { method: "GET" });
+      return new Uint8Array(await res.arrayBuffer());
+    },
+    async deleteFile(params) {
+      const q = `${storeBase()}/${encodeURIComponent(params.storeId)}/files?path=${encodeURIComponent(params.path)}`;
+      await fetchOk(fetchFn, abs(q), { method: "DELETE" });
+    },
+    async search(query, searchOption) {
+      const res = await fetchOk(fetchFn, abs(`${storeBase()}/search`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query, searchOption })
+      });
+      const j = await readJsonBody(await res.text(), "POST .../stores/search");
+      return parseSearchResultWire(j);
+    }
+  };
+  const taskApi = {
+    async create(input) {
+      const initReq = { method: "POST" };
+      if (input !== void 0 && Object.keys(input).length > 0) {
+        initReq.headers = { "content-type": "application/json" };
+        initReq.body = JSON.stringify(input);
+      }
+      const res = await fetchOk(fetchFn, abs(taskBase()), initReq);
+      const j = await readJsonBody(await res.text(), "POST .../tasks");
+      return parseTaskResourceWire(j);
+    },
+    async get(taskId) {
+      const res = await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}`), {
+        method: "GET"
+      });
+      const j = await readJsonBody(await res.text(), "GET .../tasks/:id");
+      return parseTaskResourceWire(j);
+    },
+    async list() {
+      const res = await fetchOk(fetchFn, abs(taskBase()), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../tasks");
+      const o = j;
+      const arr = o["tasks"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list tasks: expected { tasks: [] }",
+          details: null
+        });
+      }
+      return arr.map((item) => parseTaskResourceWire(item));
+    },
+    async update(taskId, patch) {
+      const res = await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}`), {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      const j = await readJsonBody(await res.text(), "PATCH .../tasks/:id");
+      return parseTaskResourceWire(j);
+    },
+    async delete(taskId) {
+      await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}`), {
+        method: "DELETE"
+      });
+    },
+    async listProposals(taskId) {
+      const res = await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/proposals`), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../tasks/:id/proposals");
+      const o = j;
+      const arr = o["proposals"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list proposals: expected { proposals: [] }",
+          details: null
+        });
+      }
+      return arr.map((item) => parseProposalResourceWire(item));
+    },
+    async executeShellCommand(taskId, command) {
+      const res = await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/shell`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(command)
+      });
+      const j = await readJsonBody(await res.text(), "POST .../tasks/:id/shell");
+      return parseCommandResultWire(j);
+    },
+    async diff(taskId) {
+      const res = await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/diff`), {
+        method: "GET"
+      });
+      const j = await readJsonBody(await res.text(), "GET .../tasks/:id/diff");
+      const o = j;
+      const arr = o["diffs"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "task diff: expected { diffs: [] }",
+          details: null
+        });
+      }
+      return arr.map((item) => parseProposalDiffItemWire(item));
+    },
+    async submit(taskId, proposalIds) {
+      await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/submit`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ proposalIds })
+      });
+    },
+    async approve(taskId, proposalIds) {
+      await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/approve`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ proposalIds })
+      });
+    },
+    async reject(taskId, proposalIds, reason) {
+      await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/reject`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ proposalIds, reason })
+      });
+    },
+    async merge(taskId, proposalIds) {
+      const res = await fetchFn(abs(`${taskBase()}/${encodeURIComponent(taskId)}/merge`), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ proposalIds })
+      });
+      if (res.status === 204) {
+        return;
+      }
+      if (!res.ok) {
+        throw await omiSdkErrorFromResponse(res);
+      }
+      throw omiSdkError({
+        code: "INTERNAL",
+        message: `unexpected merge response status ${res.status}`,
+        details: null,
+        status: res.status
+      });
+    },
+    async stop(taskId) {
+      await fetchOk(fetchFn, abs(`${taskBase()}/${encodeURIComponent(taskId)}/stop`), {
+        method: "POST"
+      });
+    }
+  };
+  const connectorApi = {
+    async create(input) {
+      const initReq = { method: "POST" };
+      if (input !== void 0 && Object.keys(input).length > 0) {
+        initReq.headers = { "content-type": "application/json" };
+        initReq.body = JSON.stringify(input);
+      }
+      const res = await fetchOk(fetchFn, abs(connectorBase()), initReq);
+      const j = await readJsonBody(await res.text(), "POST .../connectors");
+      return parseConnectorResourceWire(j);
+    },
+    async get(connectorId) {
+      const res = await fetchOk(fetchFn, abs(`${connectorBase()}/${encodeURIComponent(connectorId)}`), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../connectors/:id");
+      return parseConnectorResourceWire(j);
+    },
+    async list() {
+      const res = await fetchOk(fetchFn, abs(connectorBase()), { method: "GET" });
+      const j = await readJsonBody(await res.text(), "GET .../connectors");
+      const o = j;
+      const arr = o["connectors"];
+      if (!Array.isArray(arr)) {
+        throw omiSdkError({
+          code: "INTERNAL",
+          message: "list connectors: expected { connectors: [] }",
+          details: null
+        });
+      }
+      return arr.map((x) => parseConnectorResourceWire(x));
+    },
+    async update(connectorId, patch) {
+      const res = await fetchOk(fetchFn, abs(`${connectorBase()}/${encodeURIComponent(connectorId)}`), {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      const j = await readJsonBody(await res.text(), "PATCH .../connectors/:id");
+      return parseConnectorResourceWire(j);
+    },
+    async delete(connectorId) {
+      await fetchOk(fetchFn, abs(`${connectorBase()}/${encodeURIComponent(connectorId)}`), {
+        method: "DELETE"
+      });
+    }
+  };
+  return { spaceApi, storeApi, taskApi, connectorApi };
+}
+
+// src/auth/origin.ts
+function resolveAuthOrigin(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+
+// src/auth/credentials.ts
+import { chmod, mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var CREDENTIALS_MODE = 384;
+function defaultCredentialsPath() {
+  const configHome = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+  return join(configHome, "kb", "credentials.json");
+}
+function resolveCredentialsPath(options) {
+  return options?.filePath ?? defaultCredentialsPath();
+}
+async function loadCredentials(options) {
+  const filePath = resolveCredentialsPath(options);
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const o = parsed;
+    if (typeof o["accessToken"] !== "string" || typeof o["expiresAt"] !== "string" || typeof o["origin"] !== "string" || typeof o["spaceId"] !== "string" || o["spaceId"].length === 0) {
+      return null;
+    }
+    return {
+      accessToken: o["accessToken"],
+      expiresAt: o["expiresAt"],
+      origin: o["origin"],
+      spaceId: o["spaceId"]
+    };
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return null;
+    }
+    throw e;
+  }
+}
+async function saveCredentials(credentials, options) {
+  const filePath = resolveCredentialsPath(options);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(credentials)}
+`, {
+    encoding: "utf8",
+    mode: CREDENTIALS_MODE
+  });
+  await chmod(filePath, CREDENTIALS_MODE);
+}
+async function clearCredentials(options) {
+  const filePath = resolveCredentialsPath(options);
+  try {
+    await unlink(filePath);
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return;
+    }
+    throw e;
+  }
+}
+function credentialsMatchOrigin(credentials, origin) {
+  return credentials.origin.replace(/\/$/, "") === origin.replace(/\/$/, "");
+}
+function isCredentialsExpired(credentials, nowMs = Date.now()) {
+  const expiresAt = Date.parse(credentials.expiresAt);
+  if (Number.isNaN(expiresAt)) {
+    return true;
+  }
+  return nowMs >= expiresAt;
+}
+
+// src/auth/authenticated-fetch.ts
+function createAuthenticatedFetch(ctx, options) {
+  const baseFetch = ctx.deps.fetch;
+  const origin = resolveAuthOrigin(ctx.baseUrl);
+  return async (input, init) => {
+    const credentials = await loadCredentials(options);
+    const headers = new Headers(init?.headers);
+    const hasValidCreds = credentials !== null && credentialsMatchOrigin(credentials, origin) && !isCredentialsExpired(credentials);
+    if (hasValidCreds && credentials) {
+      headers.set("Authorization", `Bearer ${credentials.accessToken}`);
+      headers.set("Origin", origin);
+    }
+    const res = await baseFetch(input, { ...init, headers });
+    if (res.status === 401) {
+      const expired = credentials !== null && credentialsMatchOrigin(credentials, origin) && isCredentialsExpired(credentials);
+      if (expired) {
+        return new Response(
+          JSON.stringify({
+            code: "AUTH_EXPIRED",
+            message: "Session expired. Run `kb login` to sign in again.",
+            details: null
+          }),
+          { status: 401, headers: { "content-type": "application/json" } }
+        );
+      }
+      if (!hasValidCreds) {
+        return new Response(
+          JSON.stringify({
+            code: "AUTH_REQUIRED",
+            message: "Authentication required. Run `kb login` to sign in.",
+            details: null
+          }),
+          { status: 401, headers: { "content-type": "application/json" } }
+        );
+      }
+    }
+    return res;
+  };
+}
+
+// src/cli/api-base.ts
+var DEFAULT_API_PATH_PREFIX = "/api/knowbrain";
+function joinBaseUrl2(base, path) {
+  const b = base.replace(/\/$/, "");
+  return `${b}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function resolveKbApiPathPrefix(env) {
+  const raw = env["KB_API_PATH_PREFIX"];
+  if (raw === void 0) {
+    return DEFAULT_API_PATH_PREFIX;
+  }
+  return raw;
+}
+function resolveKbApiBaseUrl(origin, env) {
+  const base = origin.replace(/\/$/, "");
+  const prefix = resolveKbApiPathPrefix(env);
+  if (prefix === "") {
+    return base;
+  }
+  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  if (base.endsWith(normalized)) {
+    return base;
+  }
+  return joinBaseUrl2(base, normalized);
+}
+
+// src/cli/sdk-factory.ts
+function createKbSdk(ctx, space) {
+  const apiBaseUrl = resolveKbApiBaseUrl(ctx.baseUrl, ctx.deps.env);
+  const fetchFn = createAuthenticatedFetch(ctx);
+  return createOmiSdk({ baseUrl: apiBaseUrl, space, fetch: fetchFn });
+}
+
+// src/cli/context.ts
+var DEFAULT_BASE_URL = "http://localhost:3000";
+var defaultKbCliDeps = {
+  fetch: globalThis.fetch.bind(globalThis),
+  stdout: process.stdout,
+  stderr: process.stderr,
+  env: process.env
+};
+function parseGlobalOpts(program) {
+  const o = program.opts();
+  return {
+    baseUrl: o.baseUrl ?? DEFAULT_BASE_URL,
+    logLevel: o.logLevel ?? "error"
+  };
+}
+function createKbCliContext(deps, program) {
+  const g = parseGlobalOpts(program);
+  const logger = deps.logger ?? createOmiLogger({
+    service: "cli",
+    level: g.logLevel,
+    destination: "stderr",
+    bindings: { component: "kb" }
+  });
+  return { deps, baseUrl: g.baseUrl, logger };
+}
+
+// src/cli/space-resolve.ts
+function resolveExplicitSpaceId(program, env) {
+  const o = program.opts();
+  if (o.space !== void 0 && o.space.length > 0) {
+    return o.space;
+  }
+  const fromEnv = env["KB_SPACE"];
+  if (fromEnv !== void 0 && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return void 0;
+}
+async function resolveSpaceId(program, deps, baseUrl, credentialsOptions) {
+  const explicit = resolveExplicitSpaceId(program, deps.env);
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  const credentials = await loadCredentials(credentialsOptions);
+  const origin = resolveAuthOrigin(baseUrl);
+  if (credentials !== null && credentialsMatchOrigin(credentials, origin)) {
+    return credentials.spaceId;
+  }
+  return void 0;
+}
+async function requireSpaceId(program, deps, baseUrl, credentialsOptions) {
+  const id = await resolveSpaceId(program, deps, baseUrl, credentialsOptions);
+  if (id === void 0) {
+    writeCliError(deps.stderr, {
+      code: "VALIDATION_ERROR",
+      message: "Missing space id: pass --space <id>, set KB_SPACE, or run kb login",
+      details: null
+    });
+    return null;
+  }
+  return id;
+}
+
+// src/http/write-json.ts
+function writeStdoutPrettyJson(stdout, value) {
+  stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+
+// src/http/command-success.ts
+function successJson(value) {
+  return { kind: "json", value };
+}
+function successVoid() {
+  return { kind: "void" };
+}
+function writeCommandSuccess(stdout, success) {
+  if (success.kind === "void") {
+    return;
+  }
+  writeStdoutPrettyJson(stdout, success.value);
+}
+
+// src/http/sdk-bridge.ts
+function cliErrorFromUnknown(err) {
+  if (err instanceof OmiSdkError) {
+    return { code: err.code, message: err.message, details: err.details ?? null };
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return { code: "INTERNAL", message: msg, details: null };
+}
+
+// src/commands/connectors/connectors.ts
+function isRecord(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function parseKvList(values) {
+  const out = {};
+  if (values === void 0) {
+    return out;
+  }
+  for (const raw of values) {
+    const i = raw.indexOf("=");
+    if (i <= 0) {
+      throw new Error(`invalid --config-kv "${raw}": expected KEY=value`);
+    }
+    const k = raw.slice(0, i).trim();
+    const v = raw.slice(i + 1);
+    if (k.length === 0) {
+      throw new Error(`invalid --config-kv "${raw}": empty key`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+function mergeStringMaps(base, extra) {
+  return { ...base, ...extra };
+}
+async function loadConnectorCreateInputFromFile(path) {
+  const text = await readFile2(path, "utf8");
+  const raw = path.endsWith(".json") ? JSON.parse(text) : parseYaml(text);
+  if (!isRecord(raw)) {
+    throw new Error("config file root must be an object");
+  }
+  const out = {};
+  if (typeof raw["id"] === "string") {
+    out.id = raw["id"];
+  }
+  if (typeof raw["name"] === "string") {
+    out.name = raw["name"];
+  }
+  if (typeof raw["description"] === "string") {
+    out.description = raw["description"];
+  }
+  if (typeof raw["type"] === "string") {
+    out.type = raw["type"];
+  }
+  if (isRecord(raw["config"])) {
+    const c = {};
+    for (const [k, v] of Object.entries(raw["config"])) {
+      if (typeof v === "string") {
+        c[k] = v;
+      }
+    }
+    out.config = c;
+  }
+  if (isRecord(raw["secrets"])) {
+    const s = {};
+    for (const [k, v] of Object.entries(raw["secrets"])) {
+      if (typeof v === "string") {
+        s[k] = v;
+      }
+    }
+    out.secrets = s;
+  }
+  if (Array.isArray(raw["targetStoreIds"])) {
+    const ids = raw["targetStoreIds"].filter((x) => typeof x === "string");
+    out.targetStoreIds = ids;
+  }
+  return out;
+}
+function registerConnectorCommands(connectors, rootProgram, deps, exitRef) {
+  connectors.command("create").description("Create a connector in the current space").option("--id <id>", "Explicit connector id").option("--name <name>", "Display name").option("--description <text>", "Description").option("--type <type>", "Connector type (e.g. notion, feishu)").option("--target-stores <csv>", "Comma-separated target store ids").option("--config <path>", "YAML or JSON file with partial create fields").option("--config-kv <pair...>", "Non-secret config KEY=value (repeat for multiple keys)").option("--secret-kv <pair...>", "Secret KEY=value (repeat for multiple keys)").action(
+    async (opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const sdk = createKbSdk(ctx, spaceId);
+      try {
+        let fileInput = {};
+        if (opts.config !== void 0) {
+          fileInput = await loadConnectorCreateInputFromFile(opts.config);
+        }
+        const targetFromFlag = opts.targetStores !== void 0 ? opts.targetStores.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+        const merged = {
+          name: opts.name ?? fileInput.name ?? "",
+          description: opts.description ?? fileInput.description ?? "",
+          type: opts.type ?? fileInput.type ?? "",
+          targetStoreIds: targetFromFlag ?? fileInput.targetStoreIds ?? [],
+          config: mergeStringMaps(fileInput.config ?? {}, parseKvList(opts.configKv)),
+          secrets: mergeStringMaps(fileInput.secrets ?? {}, parseKvList(opts.secretKv))
+        };
+        const id = opts.id ?? fileInput.id;
+        if (id !== void 0 && id.trim() !== "") {
+          merged.id = id.trim();
+        }
+        const created = await sdk.connectorApi.create(merged);
+        writeCommandSuccess(ctx.deps.stdout, successJson(created));
+        exitRef.code = 0;
+      } catch (e) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+        exitRef.code = 1;
+      }
+    }
+  );
+}
+
+// src/cli/task-resolve.ts
+function normalizeTaskId(candidate) {
+  if (candidate === void 0) {
+    return void 0;
+  }
+  const trimmed = candidate.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveTaskId(program, env, explicitTaskId) {
+  const fromExplicit = normalizeTaskId(explicitTaskId);
+  if (fromExplicit !== void 0) {
+    return fromExplicit;
+  }
+  const opts = program.opts();
+  const fromOption = normalizeTaskId(opts.task);
+  if (fromOption !== void 0) {
+    return fromOption;
+  }
+  return normalizeTaskId(env["KB_TASK"]);
+}
+function resolveTaskContextId(program, env, explicitTaskId) {
+  return resolveTaskId(program, env, explicitTaskId) ?? DEFAULT_TASK_ID;
+}
+function requireTaskId(program, deps, explicitTaskId) {
+  const taskId = resolveTaskId(program, deps.env, explicitTaskId);
+  if (taskId === void 0) {
+    writeCliError(deps.stderr, {
+      code: "VALIDATION_ERROR",
+      message: "Missing task id: pass --task <id> or set KB_TASK",
+      details: null
+    });
+    return null;
+  }
+  return taskId;
+}
+function requireTaskContextId(program, deps, explicitTaskId) {
+  return resolveTaskContextId(program, deps.env, explicitTaskId);
+}
+
+// src/commands/diff.ts
+function registerDiffCommand(program, rootProgram, deps, exitRef) {
+  program.command("diff").description("Show merged proposal diffs for the current task").option("--task <taskId>", "Override task id").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const diffs = await sdk.taskApi.diff(taskId);
+      writeCommandSuccess(ctx.deps.stdout, successJson({ diffs }));
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/proposal/proposal.ts
+async function resolveProposalIds(sdk, taskId, proposalIds, all) {
+  if (all) {
+    const proposals = await sdk.taskApi.listProposals(taskId);
+    return proposals.map((proposal) => proposal.id);
+  }
+  return proposalIds;
+}
+function ensureProposalSelection(proposalIds, deps, exitRef) {
+  if (proposalIds.length > 0) {
+    return true;
+  }
+  writeCliError(deps.stderr, {
+    code: "VALIDATION_ERROR",
+    message: "Missing proposal ids: pass proposal ids or use --all",
+    details: null
+  });
+  exitRef.code = 1;
+  return false;
+}
+function registerProposalCommands(proposal, rootProgram, deps, exitRef) {
+  proposal.command("list").description("List proposals for the current task").option("--task <taskId>", "Override task id").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const proposals = await sdk.taskApi.listProposals(taskId);
+      writeCommandSuccess(ctx.deps.stdout, successJson({ proposals }));
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  proposal.command("submit").description("Submit one or more proposals").argument("[proposalIds...]", "Proposal ids").option("--all", "Submit all proposals in current task", false).option("--task <taskId>", "Override task id").action(async (proposalIds, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const resolvedIds = await resolveProposalIds(sdk, taskId, proposalIds, opts.all === true);
+      if (!ensureProposalSelection(resolvedIds, deps, exitRef)) {
+        return;
+      }
+      await sdk.taskApi.submit(taskId, resolvedIds);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  proposal.command("approve").description("Approve one or more proposals").argument("[proposalIds...]", "Proposal ids").option("--all", "Approve all proposals in current task", false).option("--task <taskId>", "Override task id").action(async (proposalIds, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const resolvedIds = await resolveProposalIds(sdk, taskId, proposalIds, opts.all === true);
+      if (!ensureProposalSelection(resolvedIds, deps, exitRef)) {
+        return;
+      }
+      await sdk.taskApi.approve(taskId, resolvedIds);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  proposal.command("reject").description("Reject one or more proposals").argument("[proposalIds...]", "Proposal ids").option("--reason <reason>", "Optional reject reason").option("--all", "Reject all proposals in current task", false).option("--task <taskId>", "Override task id").action(
+    async (proposalIds, opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+      const sdk = createKbSdk(ctx, spaceId);
+      try {
+        const resolvedIds = await resolveProposalIds(sdk, taskId, proposalIds, opts.all === true);
+        if (!ensureProposalSelection(resolvedIds, deps, exitRef)) {
+          return;
+        }
+        await sdk.taskApi.reject(taskId, resolvedIds, opts.reason ?? "");
+        writeCommandSuccess(ctx.deps.stdout, successVoid());
+        exitRef.code = 0;
+      } catch (error) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+        exitRef.code = 1;
+      }
+    }
+  );
+  proposal.command("merge").description("Merge one or more proposals").argument("[proposalIds...]", "Proposal ids").option("--all", "Merge all proposals in current task", false).option("--task <taskId>", "Override task id").action(async (proposalIds, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const resolvedIds = await resolveProposalIds(sdk, taskId, proposalIds, opts.all === true);
+      if (!ensureProposalSelection(resolvedIds, deps, exitRef)) {
+        return;
+      }
+      await sdk.taskApi.merge(taskId, resolvedIds);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/search.ts
+function parseLimit(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error("invalid option --limit: expected a positive integer");
+  }
+  return parsed;
+}
+function parseScoreThreshold(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    throw new Error("invalid option --score-threshold: expected a finite number");
+  }
+  return parsed;
+}
+function toSearchOption(opts) {
+  const option = {};
+  if (opts.targetUri !== void 0) {
+    option.targetUri = opts.targetUri;
+  }
+  const limit = parseLimit(opts.limit);
+  if (limit !== void 0) {
+    option.limit = limit;
+  }
+  const scoreThreshold = parseScoreThreshold(opts.scoreThreshold);
+  if (scoreThreshold !== void 0) {
+    option.scoreThreshold = scoreThreshold;
+  }
+  return Object.keys(option).length === 0 ? void 0 : option;
+}
+function registerSearchCommand(program, rootProgram, deps, exitRef) {
+  program.command("search").description("Search synced knowledge within the current space").argument("<query>", "Search query").option("--target-uri <uri>", "SearchOption.targetUri").option("--limit <n>", "SearchOption.limit").option("--score-threshold <n>", "SearchOption.scoreThreshold").action(async (query, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    let searchOption;
+    try {
+      searchOption = toSearchOption(opts);
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const result = await sdk.storeApi.search(query, searchOption);
+      writeCommandSuccess(ctx.deps.stdout, successJson(result));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/shell.ts
+function parseTimeoutMs(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error("invalid option --timeout-ms: expected a positive integer");
+  }
+  return parsed;
+}
+function parseEnvList(values) {
+  const out = {};
+  for (const entry of values ?? []) {
+    const idx = entry.indexOf("=");
+    if (idx <= 0 || idx === entry.length - 1) {
+      throw new Error(`invalid --env entry "${entry}": expected KEY=VALUE`);
+    }
+    const key = entry.slice(0, idx);
+    const val = entry.slice(idx + 1);
+    out[key] = val;
+  }
+  return out;
+}
+function registerShellCommand(program, rootProgram, deps, exitRef) {
+  program.command("shell").description("Execute a shell command in task context").argument("<command>", "Command to run").option("--task <taskId>", "Override task id").option("--cwd <cwd>", "Relative working directory", ".").option("--timeout-ms <ms>", "Timeout in milliseconds", parseTimeoutMs, 3e4).option("--env <pair...>", "Environment entries in KEY=VALUE form").action(
+    async (command, opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const taskId = requireTaskContextId(rootProgram, deps, opts.task);
+      const sdk = createKbSdk(ctx, spaceId);
+      try {
+        const env = parseEnvList(opts.env);
+        const result = await sdk.taskApi.executeShellCommand(taskId, {
+          command,
+          cwd: opts.cwd ?? ".",
+          timeoutMs: opts.timeoutMs,
+          env
+        });
+        if (result.exitCode === 0) {
+          if (result.stdout.length > 0) {
+            ctx.deps.stdout.write(result.stdout);
+          }
+          exitRef.code = 0;
+          return;
+        }
+        writeCommandSuccess(ctx.deps.stdout, successJson(result));
+        exitRef.code = 1;
+      } catch (error) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+        exitRef.code = 1;
+      }
+    }
+  );
+}
+
+// src/commands/space/space.ts
+function registerSpaceCommands(space, rootProgram, deps, exitRef) {
+  space.command("create").description("Create a space").option("--id <id>", "Explicit id").option("--name <name>", "Display name").option("--description <text>", "Description").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli");
+    const sdk = createKbSdk(ctx, "");
+    const input = {};
+    if (opts.id !== void 0) {
+      input.id = opts.id;
+    }
+    if (opts.name !== void 0) {
+      input.name = opts.name;
+    }
+    if (opts.description !== void 0) {
+      input.description = opts.description;
+    }
+    try {
+      const created = await sdk.spaceApi.create(
+        Object.keys(input).length > 0 ? input : void 0
+      );
+      writeCommandSuccess(ctx.deps.stdout, successJson(created));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  space.command("update").description("Update a space").argument("<id>", "Space id").option("--name <name>", "Display name").option("--description <text>", "Description").action(async (id, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli");
+    const sdk = createKbSdk(ctx, "");
+    const patch = {};
+    if (opts.name !== void 0) {
+      patch.name = opts.name;
+    }
+    if (opts.description !== void 0) {
+      patch.description = opts.description;
+    }
+    try {
+      const updated = await sdk.spaceApi.update(id, patch);
+      writeCommandSuccess(ctx.deps.stdout, successJson(updated));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  space.command("get").description("Get a space by id").argument("<id>", "Space id").action(async (id) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli");
+    const sdk = createKbSdk(ctx, "");
+    try {
+      const row = await sdk.spaceApi.get(id);
+      writeCommandSuccess(ctx.deps.stdout, successJson(row));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  space.command("delete").description("Delete a space").argument("<id>", "Space id").action(async (id) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli");
+    const sdk = createKbSdk(ctx, "");
+    try {
+      await sdk.spaceApi.delete(id);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  space.command("list").description("List spaces").action(async () => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli");
+    const sdk = createKbSdk(ctx, "");
+    try {
+      const spaces = await sdk.spaceApi.list();
+      writeCommandSuccess(ctx.deps.stdout, successJson({ spaces }));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/store/store.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+
+// src/commands/store/store-cli-output.ts
+function storeResourceToCliOutput(row, spaceId) {
+  const id = row.id;
+  return {
+    storeId: id,
+    storeName: row.name,
+    storeDescription: row.description,
+    storeReadOnly: row.readOnly,
+    storeCreatedAt: row.createdAt,
+    storeUpdatedAt: row.updatedAt,
+    path: formatKbUri(spaceId, id)
+  };
+}
+
+// src/commands/store/store.ts
+function registerStoreCommands(store, rootProgram, deps, exitRef) {
+  store.command("create").description("Create a store in the current space").option("--id <id>", "Explicit store id").option("--name <name>", "Display name").option("--description <text>", "Description").option("--read-only", "Create store in read-only mode", false).action(
+    async (opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const sdk = createKbSdk(ctx, spaceId);
+      const input = {};
+      if (opts.id !== void 0) {
+        input.id = opts.id;
+      }
+      if (opts.name !== void 0) {
+        input.name = opts.name;
+      }
+      if (opts.description !== void 0) {
+        input.description = opts.description;
+      }
+      if (opts.readOnly === true) {
+        input.readOnly = true;
+      }
+      try {
+        const created = await sdk.storeApi.create(
+          Object.keys(input).length > 0 ? input : void 0
+        );
+        writeStdoutPrettyJson(ctx.deps.stdout, storeResourceToCliOutput(created, spaceId));
+        exitRef.code = 0;
+      } catch (e) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+        exitRef.code = 1;
+      }
+    }
+  );
+  store.command("update").description("Update a store").argument("<storeId>", "Store id").option("--name <name>", "Display name").option("--description <text>", "Description").action(async (storeId, opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    const patch = {};
+    if (opts.name !== void 0) {
+      patch.name = opts.name;
+    }
+    if (opts.description !== void 0) {
+      patch.description = opts.description;
+    }
+    try {
+      const updated = await sdk.storeApi.update(storeId, patch);
+      writeStdoutPrettyJson(ctx.deps.stdout, storeResourceToCliOutput(updated, spaceId));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("get").description("Get a store by id").argument("<storeId>", "Store id").action(async (storeId) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const row = await sdk.storeApi.get(storeId);
+      writeStdoutPrettyJson(ctx.deps.stdout, storeResourceToCliOutput(row, spaceId));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("delete").description("Delete a store").argument("<storeId>", "Store id").action(async (storeId) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      await sdk.storeApi.delete(storeId);
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("list").description("List stores in the current space").action(async () => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const rows = await sdk.storeApi.list();
+      const out = {
+        stores: rows.map((r) => storeResourceToCliOutput(r, spaceId))
+      };
+      writeStdoutPrettyJson(ctx.deps.stdout, out);
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("upload").description("Upload a local file into a store path (kb://spaceId/storeId/path)").requiredOption("--file <path>", "Local file path").requiredOption("--to <uri>", "Destination kb://\u2026 URI").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    let storeId;
+    let destPath;
+    try {
+      const u = parseKbUri(opts.to);
+      if (u.storeId === void 0) {
+        deps.stderr.write(
+          `${JSON.stringify({
+            code: "VALIDATION_ERROR",
+            message: "upload --to must include a storeId (kb://<spaceId>/<storeId>/<path>)",
+            details: null
+          })}
+`
+        );
+        exitRef.code = 1;
+        return;
+      }
+      storeId = u.storeId;
+      destPath = u.path;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      deps.stderr.write(
+        `${JSON.stringify({ code: "VALIDATION_ERROR", message: msg, details: null })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    if (destPath.length === 0) {
+      deps.stderr.write(
+        `${JSON.stringify({
+          code: "VALIDATION_ERROR",
+          message: "upload --to must include a path after the store id (e.g. kb://spaceId/storeId/file.txt)",
+          details: null
+        })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const buf = await readFile3(opts.file);
+      await sdk.storeApi.uploadFile({
+        storeId,
+        path: destPath,
+        body: new Uint8Array(buf)
+      });
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("download").description("Download a store file to a local path").requiredOption("--from <uri>", "Source kb://\u2026 URI").requiredOption("--to <path>", "Local file path").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    let storeId;
+    let sourcePath;
+    try {
+      const u = parseKbUri(opts.from);
+      if (u.storeId === void 0) {
+        deps.stderr.write(
+          `${JSON.stringify({
+            code: "VALIDATION_ERROR",
+            message: "download --from must include a storeId (kb://<spaceId>/<storeId>/<path>)",
+            details: null
+          })}
+`
+        );
+        exitRef.code = 1;
+        return;
+      }
+      storeId = u.storeId;
+      sourcePath = u.path;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      deps.stderr.write(
+        `${JSON.stringify({ code: "VALIDATION_ERROR", message: msg, details: null })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    if (sourcePath.length === 0) {
+      deps.stderr.write(
+        `${JSON.stringify({
+          code: "VALIDATION_ERROR",
+          message: "download --from must include a path after the store id",
+          details: null
+        })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const bytes = await sdk.storeApi.downloadFile({ storeId, path: sourcePath });
+      await writeFile2(opts.to, Buffer.from(bytes));
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+  store.command("remove").description("Remove a file from a store (kb://spaceId/storeId/path)").requiredOption("--from <uri>", "kb://\u2026 URI of the file to remove").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    let storeId;
+    let filePath;
+    try {
+      const u = parseKbUri(opts.from);
+      if (u.storeId === void 0) {
+        deps.stderr.write(
+          `${JSON.stringify({
+            code: "VALIDATION_ERROR",
+            message: "remove --from must include a storeId (kb://<spaceId>/<storeId>/<path>)",
+            details: null
+          })}
+`
+        );
+        exitRef.code = 1;
+        return;
+      }
+      storeId = u.storeId;
+      filePath = u.path;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      deps.stderr.write(
+        `${JSON.stringify({ code: "VALIDATION_ERROR", message: msg, details: null })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    if (filePath.length === 0) {
+      deps.stderr.write(
+        `${JSON.stringify({
+          code: "VALIDATION_ERROR",
+          message: "remove --from must include a path after the store id",
+          details: null
+        })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      await sdk.storeApi.deleteFile({ storeId, path: filePath });
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/task/task.ts
+function appendStoreId(value, current) {
+  return [...current, value];
+}
+function registerTaskCommands(task, rootProgram, deps, exitRef) {
+  task.command("start").description("Start a task in the current space").option("--id <id>", "Explicit task id").option("--name <name>", "Display name").option("--description <text>", "Description").option("--readonly", "Start in readonly mode", false).option("--store <storeId>", "Bind store id to task runtime", appendStoreId, []).action(
+    async (opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const sdk = createKbSdk(ctx, spaceId);
+      const storeIds = opts.store ?? [];
+      const input = storeIds.length > 0 ? { storeIds } : { all: true };
+      if (opts.id !== void 0) {
+        input.id = opts.id;
+      }
+      if (opts.name !== void 0) {
+        input.name = opts.name;
+      }
+      if (opts.description !== void 0) {
+        input.description = opts.description;
+      }
+      if (opts.readonly === true) {
+        input.readonly = true;
+      }
+      try {
+        const created = await sdk.taskApi.create(input);
+        writeCommandSuccess(ctx.deps.stdout, successJson(created));
+        exitRef.code = 0;
+      } catch (error) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+        exitRef.code = 1;
+      }
+    }
+  );
+  task.command("get").description("Get a task by id").argument("[taskId]", "Task id (optional when --task or KB_TASK is set)").action(async (taskIdArg) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskId(rootProgram, deps, taskIdArg);
+    if (taskId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const row = await sdk.taskApi.get(taskId);
+      writeCommandSuccess(ctx.deps.stdout, successJson(row));
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  task.command("list").description("List tasks in the current space").action(async () => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      const tasks = await sdk.taskApi.list();
+      writeCommandSuccess(ctx.deps.stdout, successJson({ tasks }));
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  task.command("update").description("Update a task").argument("[taskId]", "Task id (optional when --task or KB_TASK is set)").option("--name <name>", "Display name").option("--description <text>", "Description").option("--clear-description", "Clear description", false).action(
+    async (taskIdArg, opts) => {
+      const ctx = createKbCliContext(deps, rootProgram);
+      const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+      if (spaceId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const taskId = requireTaskId(rootProgram, deps, taskIdArg);
+      if (taskId === null) {
+        exitRef.code = 1;
+        return;
+      }
+      const patch = {};
+      if (opts.name !== void 0) {
+        patch.name = opts.name;
+      }
+      if (opts.clearDescription === true) {
+        patch.description = null;
+      } else if (opts.description !== void 0) {
+        patch.description = opts.description;
+      }
+      const sdk = createKbSdk(ctx, spaceId);
+      try {
+        const row = await sdk.taskApi.update(taskId, patch);
+        writeCommandSuccess(ctx.deps.stdout, successJson(row));
+        exitRef.code = 0;
+      } catch (error) {
+        writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+        exitRef.code = 1;
+      }
+    }
+  );
+  task.command("delete").description("Delete a task").argument("[taskId]", "Task id (optional when --task or KB_TASK is set)").action(async (taskIdArg) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskId(rootProgram, deps, taskIdArg);
+    if (taskId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      await sdk.taskApi.delete(taskId);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+  task.command("stop").description("Stop a task").argument("[taskId]", "Task id (optional when --task or KB_TASK is set)").action(async (taskIdArg) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const taskId = requireTaskId(rootProgram, deps, taskIdArg);
+    if (taskId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      await sdk.taskApi.stop(taskId);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (error) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(error));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/auth/constants.ts
+var KB_DEVICE_CLIENT_ID = "knowbrain";
+var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+
+// src/auth/device-oauth.ts
+function sleepDefault(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function authJsonHeaders(origin) {
+  return {
+    "content-type": "application/json",
+    Origin: origin
+  };
+}
+function deviceOAuthError(code2, message) {
+  return { code: code2, message, details: null };
+}
+function mapTokenError(error, description) {
+  switch (error) {
+    case "expired_token":
+      return deviceOAuthError(
+        "AUTH_EXPIRED",
+        description ?? "Device authorization expired. Run `kb login` again."
+      );
+    case "access_denied":
+      return deviceOAuthError("AUTH_DENIED", description ?? "Sign-in was denied.");
+    case "invalid_grant":
+    case "invalid_client":
+      return deviceOAuthError(
+        "AUTH_FAILED",
+        description ?? "Device authorization failed. Run `kb login` again."
+      );
+    default:
+      return deviceOAuthError("AUTH_FAILED", description ?? error);
+  }
+}
+async function parseJsonBody(res) {
+  const text = await res.text();
+  if (text.trim() === "") {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function requestDeviceCode(fetchFn, origin) {
+  const res = await fetchFn(`${origin}/api/auth/device/code`, {
+    method: "POST",
+    headers: authJsonHeaders(origin),
+    body: JSON.stringify({ client_id: KB_DEVICE_CLIENT_ID })
+  });
+  const body = await parseJsonBody(res);
+  if (!res.ok) {
+    const o2 = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    const err = typeof o2["error"] === "string" ? o2["error"] : void 0;
+    if (err === "invalid_client") {
+      throw mapTokenError("invalid_client");
+    }
+    throw deviceOAuthError("AUTH_FAILED", `Device code request failed (HTTP ${res.status})`);
+  }
+  const o = body;
+  if (typeof o["device_code"] !== "string" || typeof o["user_code"] !== "string" || typeof o["verification_uri_complete"] !== "string" || typeof o["expires_in"] !== "number" || typeof o["interval"] !== "number") {
+    throw deviceOAuthError("INTERNAL", "Invalid device code response");
+  }
+  if (!Number.isFinite(o["expires_in"]) || o["expires_in"] <= 0) {
+    throw deviceOAuthError("INTERNAL", "Invalid device code response");
+  }
+  if (!Number.isFinite(o["interval"]) || o["interval"] < 0) {
+    throw deviceOAuthError("INTERNAL", "Invalid device code response");
+  }
+  return {
+    device_code: o["device_code"],
+    user_code: o["user_code"],
+    verification_uri: typeof o["verification_uri"] === "string" ? o["verification_uri"] : "",
+    verification_uri_complete: o["verification_uri_complete"],
+    expires_in: o["expires_in"],
+    interval: o["interval"]
+  };
+}
+async function pollDeviceToken(fetchFn, origin, deviceCode, options) {
+  const sleepFn = options.sleep ?? sleepDefault;
+  const nowFn = options.now ?? (() => Date.now());
+  if (!Number.isFinite(options.expiresInSec) || options.expiresInSec <= 0) {
+    throw deviceOAuthError("INTERNAL", "Invalid device token poll expiry");
+  }
+  if (!Number.isFinite(options.intervalSec) || options.intervalSec < 0) {
+    throw deviceOAuthError("INTERNAL", "Invalid device token poll interval");
+  }
+  const deadline = nowFn() + options.expiresInSec * 1e3;
+  let intervalSec = options.intervalSec;
+  while (true) {
+    const nowBeforeSleep = nowFn();
+    if (nowBeforeSleep >= deadline) {
+      throw mapTokenError("expired_token");
+    }
+    const intervalMs = intervalSec * 1e3;
+    const sleepMs = Number.isFinite(intervalMs) ? Math.min(Math.max(intervalMs, 0), deadline - nowBeforeSleep) : deadline - nowBeforeSleep;
+    await sleepFn(sleepMs);
+    const res = await fetchFn(`${origin}/api/auth/device/token`, {
+      method: "POST",
+      headers: authJsonHeaders(origin),
+      body: JSON.stringify({
+        grant_type: DEVICE_GRANT_TYPE,
+        device_code: deviceCode,
+        client_id: KB_DEVICE_CLIENT_ID
+      })
+    });
+    const body = await parseJsonBody(res);
+    if (body && typeof body === "object" && !Array.isArray(body)) {
+      const o = body;
+      if (typeof o["access_token"] === "string" && typeof o["expires_in"] === "number") {
+        const success = {
+          access_token: o["access_token"],
+          token_type: typeof o["token_type"] === "string" ? o["token_type"] : "Bearer",
+          expires_in: o["expires_in"]
+        };
+        if (typeof o["scope"] === "string") {
+          success.scope = o["scope"];
+        }
+        return success;
+      }
+      if (typeof o["error"] === "string") {
+        if (o["error"] === "authorization_pending") {
+          continue;
+        }
+        if (o["error"] === "slow_down") {
+          intervalSec += 5;
+          continue;
+        }
+        throw mapTokenError(
+          o["error"],
+          typeof o["error_description"] === "string" ? o["error_description"] : void 0
+        );
+      }
+    }
+    if (!res.ok && res.status !== 400) {
+      throw deviceOAuthError("AUTH_FAILED", `Token poll failed (HTTP ${res.status})`);
+    }
+  }
+}
+async function fetchSessionProfile(fetchFn, origin, accessToken) {
+  const res = await fetchFn(`${origin}/api/auth/get-session`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      Origin: origin
+    }
+  });
+  if (!res.ok) {
+    return {};
+  }
+  const body = await parseJsonBody(res);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return {};
+  }
+  const user = body["user"];
+  if (!user || typeof user !== "object" || Array.isArray(user)) {
+    return {};
+  }
+  const profile = {};
+  const email = user["email"];
+  if (typeof email === "string") {
+    profile.email = email;
+  }
+  const spaceId = user["id"];
+  if (typeof spaceId === "string" && spaceId.length > 0) {
+    profile.spaceId = spaceId;
+  }
+  return profile;
+}
+async function runDeviceLogin(baseUrl, options = {}) {
+  const fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const stderr = options.stderr ?? process.stderr;
+  const origin = resolveAuthOrigin(baseUrl);
+  const logger = options.logger;
+  logger?.debug({ origin }, "device login start");
+  const codeResponse = await requestDeviceCode(fetchFn, origin);
+  stderr.write(`Open this link to sign in:
+  ${codeResponse.verification_uri_complete}
+
+`);
+  stderr.write(`Or enter code: ${codeResponse.user_code}
+
+`);
+  stderr.write("Waiting for approval\u2026\n");
+  if (options.openBrowser) {
+    try {
+      await options.openBrowser(codeResponse.verification_uri_complete);
+    } catch (cause) {
+      logger?.warn({ cause }, "could not open browser");
+    }
+  }
+  const pollOptions = {
+    intervalSec: codeResponse.interval,
+    expiresInSec: codeResponse.expires_in,
+    stderr
+  };
+  if (options.sleep !== void 0) {
+    pollOptions.sleep = options.sleep;
+  }
+  if (options.now !== void 0) {
+    pollOptions.now = options.now;
+  }
+  const token = await pollDeviceToken(fetchFn, origin, codeResponse.device_code, pollOptions);
+  const nowFn = options.now ?? (() => Date.now());
+  const profile = await fetchSessionProfile(fetchFn, origin, token.access_token);
+  if (profile.spaceId === void 0) {
+    throw deviceOAuthError("INTERNAL", "Invalid get-session response: missing user id");
+  }
+  const credentials = {
+    accessToken: token.access_token,
+    expiresAt: new Date(nowFn() + token.expires_in * 1e3).toISOString(),
+    origin,
+    spaceId: profile.spaceId
+  };
+  await saveCredentials(credentials, options);
+  if (profile.email) {
+    stderr.write(`Signed in as ${profile.email}
+`);
+  } else {
+    stderr.write("Signed in.\n");
+  }
+  logger?.info({ origin }, "device login ok");
+  const result = { credentials, spaceId: profile.spaceId };
+  if (profile.email !== void 0) {
+    result.userEmail = profile.email;
+  }
+  return result;
+}
+
+// src/auth/open-url.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function openUrlInBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    await execFileAsync("open", [url]);
+    return;
+  }
+  if (platform === "win32") {
+    await execFileAsync("cmd", ["/c", "start", "", url]);
+    return;
+  }
+  await execFileAsync("xdg-open", [url]);
+}
+
+// src/commands/login.ts
+function isCliErrorJson(err) {
+  return err !== null && typeof err === "object" && "code" in err && typeof err.code === "string" && "message" in err && typeof err.message === "string";
+}
+function registerLoginCommand(program, rootProgram, deps, exitRef) {
+  program.command("login").description("Sign in via device authorization (browser)").action(async () => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug({ baseUrl: ctx.baseUrl }, "cli login start");
+    try {
+      await runDeviceLogin(ctx.baseUrl, {
+        fetch: ctx.deps.fetch,
+        stderr: ctx.deps.stderr,
+        logger: ctx.logger,
+        openBrowser: openUrlInBrowser
+      });
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (e) {
+      ctx.logger.error({ err: e }, "cli login failed");
+      if (isCliErrorJson(e)) {
+        writeCliError(ctx.deps.stderr, e);
+      } else {
+        const message = e instanceof Error ? e.message : String(e);
+        writeCliError(ctx.deps.stderr, { code: "INTERNAL", message, details: null });
+      }
+      exitRef.code = 1;
+    }
+  });
+}
+function registerLogoutCommand(program, rootProgram, deps, exitRef) {
+  program.command("logout").description("Remove stored sign-in credentials").action(async () => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    ctx.logger.debug("cli logout start");
+    try {
+      await clearCredentials();
+      ctx.logger.info("cli logout ok");
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (e) {
+      ctx.logger.error({ err: e }, "cli logout failed");
+      const message = e instanceof Error ? e.message : String(e);
+      writeCliError(ctx.deps.stderr, { code: "INTERNAL", message, details: null });
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/commands/wait-sync.ts
+function registerWaitSyncCommand(program, rootProgram, deps, exitRef) {
+  program.command("waitSync").description("Wait for memory sync for a store (OpenViking)").requiredOption("--store <uri>", "kb://<spaceId>/<storeId> (path segment optional)").action(async (opts) => {
+    const ctx = createKbCliContext(deps, rootProgram);
+    const spaceId = await requireSpaceId(rootProgram, deps, ctx.baseUrl);
+    if (spaceId === null) {
+      exitRef.code = 1;
+      return;
+    }
+    let storeId;
+    try {
+      const u = parseKbUri(opts.store);
+      if (u.storeId === void 0) {
+        deps.stderr.write(
+          `${JSON.stringify({
+            code: "VALIDATION_ERROR",
+            message: "--store must include a storeId (kb://<spaceId>/<storeId>)",
+            details: null
+          })}
+`
+        );
+        exitRef.code = 1;
+        return;
+      }
+      storeId = u.storeId;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      deps.stderr.write(
+        `${JSON.stringify({ code: "VALIDATION_ERROR", message: msg, details: null })}
+`
+      );
+      exitRef.code = 1;
+      return;
+    }
+    const sdk = createKbSdk(ctx, spaceId);
+    try {
+      await sdk.storeApi.waitSync(storeId);
+      writeCommandSuccess(ctx.deps.stdout, successVoid());
+      exitRef.code = 0;
+    } catch (e) {
+      writeCliError(ctx.deps.stderr, cliErrorFromUnknown(e));
+      exitRef.code = 1;
+    }
+  });
+}
+
+// src/cli/program.ts
+function buildProgram(deps, exitRef) {
+  const program = new Command();
+  program.name("kb");
+  program.option("--base-url <url>", "API base URL", deps.env["KB_BASE_URL"] ?? DEFAULT_BASE_URL).option("--log-level <level>", "stderr log level (error|warn|info|debug)", "error").option(
+    "--space <id>",
+    "Default space id (overrides KB_SPACE and login credentials)",
+    deps.env["KB_SPACE"]
+  );
+  program.option(
+    "--task <id>",
+    "Default task id for task/proposal/shell/diff commands (overrides KB_TASK)",
+    deps.env["KB_TASK"]
+  );
+  registerLoginCommand(program, program, deps, exitRef);
+  registerLogoutCommand(program, program, deps, exitRef);
+  const space = program.command("space").description("Manage spaces");
+  registerSpaceCommands(space, program, deps, exitRef);
+  const store = program.command("store").description("Manage stores (space from --space, KB_SPACE, or kb login credentials)");
+  registerStoreCommands(store, program, deps, exitRef);
+  const connectors = program.command("connectors").description("Manage connectors (space from --space, KB_SPACE, or kb login credentials)");
+  registerConnectorCommands(connectors, program, deps, exitRef);
+  const task = program.command("task").description("Manage tasks (space from --space, KB_SPACE, or kb login credentials)");
+  registerTaskCommands(task, program, deps, exitRef);
+  const proposal = program.command("proposal").description("Manage proposals in the current task");
+  registerProposalCommands(proposal, program, deps, exitRef);
+  registerWaitSyncCommand(program, program, deps, exitRef);
+  registerSearchCommand(program, program, deps, exitRef);
+  registerShellCommand(program, program, deps, exitRef);
+  registerDiffCommand(program, program, deps, exitRef);
+  return program;
+}
+
+// src/cli/run.ts
+function validationError(message) {
+  return { code: "VALIDATION_ERROR", message, details: null };
+}
+function printUsage(stderr) {
+  stderr.write(`Usage:
+  kb login
+  kb logout
+  kb [--base-url <url>] [--log-level <level>] [--space <id>] space create ...
+  kb [--base-url <url>] [--log-level <level>] [--space <id>] store create [--name <name>] ...
+  kb [--base-url <url>] [--log-level <level>] [--space <id>] waitSync --store <kb://...>
+
+Environment:
+  KB_BASE_URL          Service origin (default ${DEFAULT_BASE_URL})
+  KB_API_PATH_PREFIX   Resource API path prefix (default /api/knowbrain; empty for direct OMI)
+  KB_SPACE             Default space id when --space is omitted (overrides login credentials)
+`);
+}
+async function runKbCli(argv, deps = defaultKbCliDeps) {
+  if (argv.length === 0) {
+    printUsage(deps.stderr);
+    return 1;
+  }
+  const exitRef = { code: 0 };
+  const program = buildProgram(deps, exitRef);
+  program.exitOverride();
+  program.showHelpAfterError(false);
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return exitRef.code;
+  } catch (e) {
+    if (e instanceof CommanderError) {
+      if (e.exitCode === 0) {
+        return 0;
+      }
+      writeCliError(deps.stderr, validationError(e.message));
+      return e.exitCode;
+    }
+    const message = e instanceof Error ? e.message : String(e);
+    writeCliError(deps.stderr, { code: "INTERNAL", message, details: null });
+    return 1;
+  }
+}
+
+// src/main.ts
+var code = await runKbCli(process.argv.slice(2));
+process.exit(code);
+//# sourceMappingURL=kb.js.map