@stndrds/cli 1.0.0-alpha.3 → 1.0.0-alpha.302

package/dist/bin.mjs

@@ -1,124 +1,26 @@
 #!/usr/bin/env node
+/*! © 2025-2026 AND YOU CREATE SAS (RCS Paris 940 190 614). Proprietary — see LICENSE (Standards SDK License 1.0). */
 
 // src/program.ts
-import chalk5 from "chalk";
+import chalk10 from "chalk";
 import { Command } from "commander";
 
 // src/client.ts
-var ApiClientError = class extends Error {
-  constructor(statusCode, message) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "ApiClientError";
-  }
-};
-function buildUrl(base, path, params) {
-  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
-  const normalizedPath = path.replace(/^\/+/, "");
-  const url = new URL(normalizedPath, normalizedBase);
-  if (params) {
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== void 0 && value !== null) {
-        url.searchParams.set(key, String(value));
-      }
-    }
-  }
-  return url.toString();
-}
+import { StandardsRequestError, createTransport } from "@stndrds/client";
+var ApiClientError = StandardsRequestError;
 function createClient(config) {
-  const { apiUrl, apiKey } = config;
-  const headers = {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json"
-  };
-  async function request(method, path, options) {
-    const url = buildUrl(apiUrl, path, options?.params);
-    let response;
-    try {
-      response = await fetch(url, {
-        method,
-        headers,
-        body: options?.body ? JSON.stringify(options.body) : void 0,
-        signal: AbortSignal.timeout(3e4)
-      });
-    } catch (error) {
-      if (error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError") {
-        throw new ApiClientError(0, `Could not connect to ${apiUrl}. Is the server running?`);
-      }
-      throw error;
-    }
-    if (response.status === 204) {
-      return null;
-    }
-    const data = await response.json();
-    if (!response.ok) {
-      const message = data.message ?? `Request failed with status ${response.status}`;
-      throw new ApiClientError(response.status, message);
-    }
-    return data;
-  }
-  return {
-    get(path, params) {
-      return request("GET", path, { params });
-    },
-    post(path, body) {
-      return request("POST", path, { body });
-    },
-    patch(path, body) {
-      return request("PATCH", path, { body });
-    },
-    put(path, body) {
-      return request("PUT", path, { body });
-    },
-    delete(path) {
-      return request("DELETE", path);
-    }
-  };
-}
-
-// src/commands/auth.ts
-import chalk from "chalk";
-
-// src/commands/common.ts
-function getGlobalOptions(cmd) {
-  return cmd.optsWithGlobals();
-}
-function getFormat(cmd) {
-  return getGlobalOptions(cmd).format;
-}
-function getClientFromCommand(cmd) {
-  const root = getGlobalOptions(cmd);
-  if (!(root.apiUrl && root.apiKey)) {
-    throw new Error('No Standards instance configured. Run "standards login" or pass --api-key.');
-  }
-  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
-}
-
-// src/commands/auth.ts
-function registerAuthCommand(program) {
-  const auth = program.command("auth").description("Inspect CLI authentication");
-  auth.command("whoami").description("Show current configuration and validate API key").action(async (_opts, cmd) => {
-    const root = getGlobalOptions(cmd);
-    const client = getClientFromCommand(cmd);
-    const write = (msg) => process.stdout.write(`${msg}
-`);
-    write(chalk.bold("Standards CLI Configuration"));
-    write(`  API URL:  ${root.apiUrl}`);
-    write(`  API Key:  ${root.apiKey ? `${root.apiKey.slice(0, 8)}...` : chalk.red("not set")}`);
-    write("");
-    const keys = await client.get("/api-keys");
-    write(chalk.green("\u2713 API key is valid"));
-    if (Array.isArray(keys) && keys.length > 0) {
-      const activeKeys = keys.filter(
-        (key) => typeof key === "object" && key !== null && !("revokedAt" in key && key.revokedAt)
-      );
-      write(`  Active keys: ${activeKeys.length}`);
-    }
+  return createTransport({
+    baseUrl: config.apiUrl,
+    apiKey: config.apiKey,
+    tenantId: config.tenantId
   });
 }
 
+// src/commands/ai.ts
+import { ValidationError } from "@stndrds/schema";
+
 // src/output.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 import Table from "cli-table3";
 var MAX_CELL_WIDTH = 50;
 function truncate(value, maxLength) {
@@ -147,7 +49,7 @@ function formatTable(items) {
   if (items.length === 0) return "No results.";
   const headers = Object.keys(items[0]);
   const table = new Table({
-    head: headers.map((h) => chalk2.bold(h)),
+    head: headers.map((h) => chalk.bold(h)),
     style: { head: [], border: [] }
   });
   for (const item of items) {
@@ -177,165 +79,186 @@ function formatOutput(data, format) {
 `);
 }
 
-// src/commands/documents.ts
-function registerDocumentsCommand(program) {
-  const documents = program.command("documents").description("Manage documents");
-  documents.command("list").description("List documents").option("--status <status>", "filter by processing status").option("--limit <n>", "max documents to return").option("--offset <n>", "number of documents to skip").action(async (opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const params = {};
-    if (opts.status) params.processingStatus = opts.status;
-    if (opts.limit) params.limit = opts.limit;
-    if (opts.offset) params.offset = opts.offset;
-    const result = await client.get("/documents", params);
-    formatOutput(result, getFormat(cmd));
-  });
-  documents.command("get").description("Get a document by ID").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const result = await client.get(`/documents/${id}`);
-    formatOutput(result, getFormat(cmd));
-  });
-  documents.command("create").description("Create a new document").requiredOption("--title <title>", "document title").option("--values <json>", "document values as JSON string").action(async (opts, cmd) => {
+// src/commands/common.ts
+function getGlobalOptions(cmd) {
+  return cmd.optsWithGlobals();
+}
+function getFormat(cmd) {
+  return getGlobalOptions(cmd).format;
+}
+function parseCsvList(value) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function getClientFromCommand(cmd) {
+  const root = getGlobalOptions(cmd);
+  if (!(root.apiUrl && root.apiKey)) {
+    throw new Error('No Standards instance configured. Run "standards login" or pass --api-key.');
+  }
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey, tenantId: root.tenant });
+}
+function requireTenant(cmd, message) {
+  const { tenant } = getGlobalOptions(cmd);
+  if (!tenant) {
+    throw new Error(message);
+  }
+  return tenant;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/ai.ts
+var SCOPES = ["me", "workspace"];
+var ISO_DAY = /^\d{4}-\d{2}-\d{2}$/u;
+function parseDay(flag, value) {
+  if (!ISO_DAY.test(value)) {
+    throw new ValidationError(`${flag} must be a YYYY-MM-DD date`, []);
+  }
+  return value;
+}
+function parseScope(scope) {
+  if (SCOPES.includes(scope)) return scope;
+  throw new ValidationError(`--scope must be one of: ${SCOPES.join(", ")}`, []);
+}
+function registerAiCommand(program) {
+  const ai = program.command("ai").description("Inspect AI usage and credit state");
+  ai.command("usage").description("Aggregate the AI journal over an inclusive UTC day window").requiredOption("--from <day>", "first day of the window (YYYY-MM-DD)").requiredOption("--to <day>", "last day of the window, inclusive (YYYY-MM-DD)").option("--scope <scope>", "me or workspace", "me").action(async (opts, cmd) => {
+    const params = {
+      from: parseDay("--from", opts.from),
+      to: parseDay("--to", opts.to),
+      scope: parseScope(opts.scope ?? "me")
+    };
     const client = getClientFromCommand(cmd);
-    const body = { title: opts.title };
-    if (opts.values) body.values = JSON.parse(opts.values);
-    const result = await client.post("/documents", body);
+    const result = await client.get("/ai/usage", params);
     formatOutput(result, getFormat(cmd));
   });
-  documents.command("update").description("Update a document").argument("<id>", "document ID").option("--title <title>", "new title").option("--values <json>", "new values as JSON string").action(async (id, opts, cmd) => {
+  ai.command("wallet").description("Show the tenant's billing mode and AI credit state").action(async (_opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const body = {};
-    if (opts.title) body.title = opts.title;
-    if (opts.values) body.values = JSON.parse(opts.values);
-    const result = await client.patch(`/documents/${id}`, body);
+    const result = await client.get("/ai/wallet");
     formatOutput(result, getFormat(cmd));
   });
-  documents.command("delete").description("Delete a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+}
+
+// src/commands/auth.ts
+import chalk2 from "chalk";
+function registerAuthCommand(program) {
+  const auth = program.command("auth").description("Inspect CLI authentication");
+  auth.command("whoami").description("Show current configuration and validate API key").action(async (_opts, cmd) => {
+    const root = getGlobalOptions(cmd);
     const client = getClientFromCommand(cmd);
-    await client.delete(`/documents/${id}`);
-    process.stdout.write(`Document ${id} deleted.
+    const write = (msg) => process.stdout.write(`${msg}
 `);
+    write(chalk2.bold("Standards CLI Configuration"));
+    write(`  API URL:  ${root.apiUrl}`);
+    write(`  API Key:  ${root.apiKey ? `${root.apiKey.slice(0, 8)}...` : chalk2.red("not set")}`);
+    write("");
+    const keys = await client.get("/api-keys");
+    write(chalk2.green("\u2713 API key is valid"));
+    if (Array.isArray(keys) && keys.length > 0) {
+      const activeKeys = keys.filter(
+        (key) => typeof key === "object" && key !== null && !("revokedAt" in key && key.revokedAt)
+      );
+      write(`  Active keys: ${activeKeys.length}`);
+    }
   });
-  documents.command("preview").description("Get preview file for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const result = await client.get(`/documents/${id}/preview`);
-    formatOutput(result, getFormat(cmd));
-  });
-  documents.command("slots").description("List slots for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+}
+
+// src/commands/bundles.ts
+function registerBundlesCommand(program) {
+  const bundles = program.command("bundles").description("Manage system bundles assigned to the current tenant (admin)");
+  bundles.command("list").description("List the bundles actively assigned to the current tenant").action(async (_opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const result = await client.get(`/documents/${id}/slots`);
+    const result = await client.get("/bundles/assigned");
     formatOutput(result, getFormat(cmd));
   });
-  documents.command("add-slot").description("Add a file slot to a document").argument("<id>", "document ID").requiredOption("--slot-name <name>", "slot name").requiredOption("--file-id <fileId>", "file ID").action(async (id, opts, cmd) => {
+  bundles.command("updatable").description("List assigned bundles that have a newer version available").action(async (_opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const result = await client.post(`/documents/${id}/slots`, {
-      slotName: opts.slotName,
-      fileId: opts.fileId
-    });
+    const result = await client.get("/bundles/updatable");
     formatOutput(result, getFormat(cmd));
   });
-  documents.command("remove-slot").description("Remove a slot from a document").argument("<id>", "document ID").argument("<slotId>", "slot ID").action(async (id, slotId, _opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    await client.delete(`/documents/${id}/slots/${slotId}`);
-    process.stdout.write(`Slot ${slotId} removed.
-`);
-  });
-}
-
-// src/commands/keys.ts
-import chalk3 from "chalk";
-function registerKeysCommand(program) {
-  const keys = program.command("keys").description("Manage Standards API keys");
-  keys.command("list").description("List API keys").action(async (_opts, cmd) => {
+  bundles.command("assign").description("Assign (install) a bundle to the current tenant").argument("<bundleId>", "bundle ID to assign").action(async (bundleId, _opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const result = await client.get("/api-keys");
+    const result = await client.post("/bundles/assign", { bundleId });
     formatOutput(result, getFormat(cmd));
   });
-  keys.command("create").description("Create a new API key").requiredOption("--name <name>", "name for the API key").option("--expires <date>", "expiration date (ISO 8601)").option("--yes", "create without confirmation").action(async (opts, cmd) => {
+  bundles.command("uninstall").description("Uninstall a bundle: deactivate it and demote its now-orphaned objects").argument("<bundleId>", "bundle ID to uninstall").option("--yes", "uninstall without confirmation").action(async (bundleId, opts, cmd) => {
     if (!opts.yes) {
-      throw new Error('Creating API keys is explicit. Re-run with "--yes" to confirm.');
+      throw new Error('Uninstalling a bundle is explicit. Re-run with "--yes" to confirm.');
     }
     const client = getClientFromCommand(cmd);
-    const body = {
-      name: opts.name,
-      permissions: []
-    };
-    if (opts.expires) body.expiresAt = opts.expires;
-    const result = await client.post("/api-keys", body);
+    const result = await client.delete(`/bundles/${bundleId}`);
     formatOutput(result, getFormat(cmd));
   });
-  keys.command("revoke").description("Revoke an API key").argument("<id>", "API key ID").option("--yes", "revoke without confirmation").action(async (id, opts, cmd) => {
-    if (!opts.yes) {
-      throw new Error('Revoking API keys is explicit. Re-run with "--yes" to confirm.');
-    }
+  bundles.command("update").description("Apply assigned bundles \u2014 picks up newer bundle versions (additive sync)").action(async (_opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    await client.delete(`/api-keys/${id}`);
-    process.stdout.write(`${chalk3.green("\u2713")} API key ${id} revoked.
-`);
+    const result = await client.post("/bundles/update");
+    formatOutput(result, getFormat(cmd));
   });
 }
 
-// src/commands/records.ts
-function parseSortFlag(sort) {
-  const [attribute, direction = "asc"] = sort.split(":");
-  return JSON.stringify([{ attribute, direction }]);
+// src/commands/connectors.ts
+import { ValidationError as ValidationError2 } from "@stndrds/schema";
+import chalk3 from "chalk";
+var PROVIDER_IDS = {
+  gmail: true,
+  outlook: true,
+  "google-calendar": true,
+  "outlook-calendar": true
+};
+var PROVIDERS = Object.keys(PROVIDER_IDS);
+function resolveScope(scope) {
+  return scope === "actor" ? "actor" : "tenant";
 }
-function registerRecordsCommand(program) {
-  const records = program.command("records").description("Manage records (CRUD + search)");
-  records.command("list").description("List records for an object").argument("<object>", "object name (e.g. contacts)").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const params = {};
-    if (opts.limit) params.limit = opts.limit;
-    if (opts.offset) params.offset = opts.offset;
-    if (opts.sort) params.sorts = parseSortFlag(opts.sort);
-    if (opts.filter) params.filters = opts.filter;
-    const result = await client.get(`/records/${objectName}`, params);
-    formatOutput(result, getFormat(cmd));
-  });
-  records.command("get").description("Get a record by ID").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+function registerConnectorsCommand(program) {
+  const connectors = program.command("connectors").description("Manage email and calendar connectors (OAuth connections)");
+  connectors.command("providers").description("List the connector providers this deployment holds credentials for").action(async (_opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const result = await client.get(`/records/${objectName}/${id}`);
+    const result = await client.get("/connectors/providers");
     formatOutput(result, getFormat(cmd));
   });
-  records.command("create").description("Create a new record").argument("<object>", "object name").option("--data <json>", "record data as JSON string").action(async (objectName, opts, cmd) => {
-    const data = opts.data ? JSON.parse(opts.data) : {};
+  connectors.command("list").description("List connector connections").option("--scope <scope>", "connection scope (tenant or actor)", "tenant").action(async (opts, cmd) => {
     const client = getClientFromCommand(cmd);
-    const result = await client.post(`/records/${objectName}`, { data });
+    const result = await client.get("/connectors/connections", {
+      scope: resolveScope(opts.scope)
+    });
     formatOutput(result, getFormat(cmd));
   });
-  records.command("update").description("Update a record").argument("<object>", "object name").argument("<id>", "record ID").option("--data <json>", "fields to update as JSON string").action(async (objectName, id, opts, cmd) => {
-    const data = opts.data ? JSON.parse(opts.data) : {};
+  connectors.command("connect").description("Start an OAuth flow and return the authorization URL to open").requiredOption(
+    "--provider <provider>",
+    `connector provider (${PROVIDERS.join(", ")}); run "connectors providers" for the ones this deployment configured`
+  ).option("--scope <scope>", "connection scope (tenant or actor)", "tenant").action(async (opts, cmd) => {
+    if (!PROVIDERS.includes(opts.provider)) {
+      throw new ValidationError2(`--provider must be one of: ${PROVIDERS.join(", ")}`, []);
+    }
     const client = getClientFromCommand(cmd);
-    const result = await client.put(`/records/${objectName}/${id}`, data);
+    const result = await client.post("/connectors/auth/start", {
+      provider: opts.provider,
+      scope: resolveScope(opts.scope)
+    });
     formatOutput(result, getFormat(cmd));
   });
-  records.command("delete").description("Delete a record").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+  connectors.command("disconnect").description("Disconnect (delete) a connector connection").argument("<id>", "connection ID").option("--yes", "disconnect without confirmation").action(async (id, opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Disconnecting a connector is explicit. Re-run with "--yes" to confirm.');
+    }
     const client = getClientFromCommand(cmd);
-    await client.delete(`/records/${objectName}/${id}`);
-    process.stdout.write(`Record ${id} deleted.
+    await client.delete(`/connectors/connections/${id}`);
+    process.stdout.write(`${chalk3.green("\u2713")} Connector connection ${id} disconnected.
 `);
   });
-  records.command("search").description("Full-text search records").argument("<object>", "object name").requiredOption("--query <q>", "search query string").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const params = { q: opts.query };
-    if (opts.limit) params.limit = opts.limit;
-    if (opts.offset) params.offset = opts.offset;
-    if (opts.sort) params.sorts = parseSortFlag(opts.sort);
-    if (opts.filter) params.filters = opts.filter;
-    const result = await client.get(`/records/${objectName}/search`, params);
-    formatOutput(result, getFormat(cmd));
-  });
 }
 
-// src/commands/root.ts
-import { stdin as input, stdout as output } from "process";
-import { createInterface } from "readline/promises";
-import chalk4 from "chalk";
+// src/commands/device.ts
+import { hostname } from "os";
+import { SchemaError as SchemaError2, SchemaErrorCode as SchemaErrorCode2 } from "@stndrds/schema";
 
 // src/config.ts
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname, join } from "path";
 var DEFAULT_API_URL = "http://localhost:4100/v1";
+var ENV_PROFILE_NAME = "sandbox";
 function getDefaultApiUrl() {
   return DEFAULT_API_URL;
 }
@@ -348,6 +271,7 @@ async function readConfig() {
     const raw = await readFile(getConfigPath(), "utf8");
     const parsed = JSON.parse(raw);
     return {
+      ...parsed.installationId ? { installationId: parsed.installationId } : {},
       currentProfile: parsed.currentProfile,
       profiles: parsed.profiles ?? {}
     };
@@ -360,19 +284,60 @@ async function readConfig() {
 }
 async function writeConfig(config) {
   const path = getConfigPath();
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const directory = dirname(path);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await chmod(directory, 448);
   await writeFile(path, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
+  await chmod(path, 384);
+}
+function normalizeApiOrigin(apiUrl) {
+  try {
+    return new URL(apiUrl).origin;
+  } catch {
+    return apiUrl.replace(/\/+$/, "");
+  }
 }
 async function upsertProfile(input2) {
   const config = await readConfig();
+  const existingProfile = config.profiles[input2.name];
+  const device = existingProfile?.device && normalizeApiOrigin(existingProfile.apiUrl) === normalizeApiOrigin(input2.apiUrl) ? existingProfile.device : void 0;
   config.profiles[input2.name] = {
     apiUrl: input2.apiUrl,
-    apiKey: input2.apiKey
+    apiKey: input2.apiKey,
+    ...device ? { device } : {}
   };
   config.currentProfile = input2.name;
   await writeConfig(config);
 }
+async function getOrCreateInstallationId() {
+  const config = await readConfig();
+  if (config.installationId) return config.installationId;
+  const installationId = randomUUID();
+  config.installationId = installationId;
+  await writeConfig(config);
+  return installationId;
+}
+async function getStoredDeviceCredential(profileName) {
+  const config = await readConfig();
+  return config.profiles[profileName]?.device ?? null;
+}
+async function storeDeviceCredential(profileName, credential) {
+  const config = await readConfig();
+  const profile = config.profiles[profileName];
+  if (!profile) return false;
+  profile.device = credential;
+  await writeConfig(config);
+  return true;
+}
+async function removeDeviceCredential(profileName) {
+  const config = await readConfig();
+  const profile = config.profiles[profileName];
+  if (!profile?.device) return false;
+  profile.device = void 0;
+  await writeConfig(config);
+  return true;
+}
 async function setCurrentProfile(name) {
   const config = await readConfig();
   if (!config.profiles[name]) {
@@ -393,19 +358,39 @@ async function removeProfile(name) {
 }
 async function listProfiles() {
   const config = await readConfig();
-  return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b)).map(([name, profile]) => ({
+  const profiles = Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b)).map(([name, profile]) => ({
     name,
     apiUrl: profile.apiUrl,
     current: config.currentProfile === name
   }));
+  const envProfile = getEnvProfile();
+  if (envProfile) {
+    profiles.push({
+      name: ENV_PROFILE_NAME,
+      apiUrl: envProfile.apiUrl,
+      current: !config.currentProfile,
+      source: "env"
+    });
+  }
+  return profiles;
 }
 async function getActiveProfile() {
   const config = await readConfig();
-  if (!config.currentProfile) return null;
+  if (!config.currentProfile) {
+    const envProfile = getEnvProfile();
+    return envProfile ? { name: ENV_PROFILE_NAME, ...envProfile } : null;
+  }
   const profile = config.profiles[config.currentProfile];
   if (!profile) return null;
   return { name: config.currentProfile, ...profile };
 }
+function getEnvProfile() {
+  if (!process.env.STANDARDS_API_KEY) return null;
+  return {
+    apiUrl: process.env.STANDARDS_API_URL ?? DEFAULT_API_URL,
+    apiKey: process.env.STANDARDS_API_KEY
+  };
+}
 async function resolveCliConfig(options) {
   if (options.apiUrl || options.apiKey) {
     return {
@@ -430,37 +415,1347 @@ async function resolveCliConfig(options) {
   };
 }
 
-// src/commands/root.ts
-async function promptForMissingValue(label) {
-  const rl = createInterface({ input, output });
+// src/device/worker-client.ts
+import { SchemaError, SchemaErrorCode } from "@stndrds/schema";
+var REQUEST_TIMEOUT_MS = 3e4;
+var DeviceWorkerRequestError = class extends SchemaError {
+  constructor(statusCode, message, code = SchemaErrorCode.REPOSITORY_QUERY_FAILED) {
+    super(message, code, { statusCode });
+    this.statusCode = statusCode;
+    this.name = "DeviceWorkerRequestError";
+  }
+};
+var DeviceCredentialRejectedError = class extends DeviceWorkerRequestError {
+  constructor() {
+    super(
+      401,
+      "Device credential rejected; run standards device pair again",
+      SchemaErrorCode.ACCESS_DENIED
+    );
+    this.name = "DeviceCredentialRejectedError";
+  }
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (!text) return void 0;
   try {
-    const value = await rl.question(`${label}: `);
-    return value.trim();
-  } finally {
-    rl.close();
+    return JSON.parse(text);
+  } catch {
+    return void 0;
   }
 }
-function registerRootCommands(program) {
-  program.command("login").description("Connect the CLI to a Standards instance").option("--url <url>", "Standards API URL", getDefaultApiUrl()).option("--key <key>", "API key to store for this instance").option("--name <name>", "local instance name", "local").action(async (opts) => {
-    const apiKey = opts.key ?? await promptForMissingValue("API key");
-    if (!apiKey) throw new Error("API key is required");
-    const client = createClient({ apiUrl: opts.url, apiKey });
-    await client.get("/api-keys");
-    await upsertProfile({ name: opts.name, apiUrl: opts.url, apiKey });
-    process.stdout.write(
-      `${chalk4.green("\u2713")} Standards instance "${opts.name}" saved and selected.
-`
-    );
-    process.stdout.write(`  API URL: ${opts.url}
-`);
-    process.stdout.write(`  API Key: ${apiKey.slice(0, 8)}...
-`);
-    process.stdout.write(`  Use it with: standards --instance ${opts.name} <command>
-`);
+function messageFrom(value, fallback) {
+  return isRecord(value) && typeof value.message === "string" ? value.message : fallback;
+}
+function parseLease(value) {
+  if (!isRecord(value)) throw new DeviceWorkerRequestError(200, "Invalid lease response");
+  const leaseToken = value.leaseToken;
+  if (!isRecord(value.command)) {
+    throw new DeviceWorkerRequestError(200, "Invalid lease response");
+  }
+  const leasedCommand = value.command;
+  const { id, intent, command, cwd, timeoutMs } = leasedCommand;
+  if (typeof id !== "string" || typeof leaseToken !== "string" || typeof intent !== "string" || typeof command !== "string" || cwd !== void 0 && cwd !== null && typeof cwd !== "string" || typeof timeoutMs !== "number" || !Number.isInteger(timeoutMs)) {
+    throw new DeviceWorkerRequestError(200, "Invalid lease response");
+  }
+  return {
+    id,
+    leaseToken,
+    intent,
+    command,
+    timeoutMs,
+    ...typeof cwd === "string" ? { cwd } : {}
+  };
+}
+function parseHeartbeat(value) {
+  if (!isRecord(value)) {
+    throw new DeviceWorkerRequestError(200, "Invalid heartbeat response");
+  }
+  const { cancel } = value;
+  if (typeof cancel !== "boolean") {
+    throw new DeviceWorkerRequestError(200, "Invalid heartbeat response");
+  }
+  const reason = value.reason;
+  if (reason !== void 0 && reason !== "cancelled" && reason !== "revoked") {
+    throw new DeviceWorkerRequestError(200, "Invalid heartbeat response");
+  }
+  return { cancel, ...reason === void 0 ? {} : { reason } };
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+var DeviceWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetch = options.fetch ?? fetch;
+    this.apiUrl = options.apiUrl.replace(/\/+$/, "");
+  }
+  async request(path, input2 = {}) {
+    const timeoutSignal = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    const signal = input2.signal ? AbortSignal.any([input2.signal, timeoutSignal]) : timeoutSignal;
+    let response;
+    try {
+      response = await this.fetch(`${this.apiUrl}/device-worker${path}`, {
+        method: "POST",
+        signal,
+        headers: {
+          authorization: `Device ${this.options.token}`,
+          "content-type": "application/json",
+          ...input2.leaseToken ? { "x-device-lease-token": input2.leaseToken } : {}
+        },
+        ...input2.body === void 0 ? {} : { body: JSON.stringify(input2.body) }
+      });
+    } catch (error) {
+      if (input2.signal?.aborted) throw new DOMException("Aborted", "AbortError");
+      if (isAbortError(error)) throw error;
+      throw new DeviceWorkerRequestError(0, "Device worker request failed");
+    }
+    if (response.status === 401) throw new DeviceCredentialRejectedError();
+    if (!response.ok) {
+      const body = await readJson(response);
+      throw new DeviceWorkerRequestError(
+        response.status,
+        messageFrom(body, `Device worker request failed with status ${response.status}`),
+        response.status === 409 ? SchemaErrorCode.CONFLICT : SchemaErrorCode.REPOSITORY_QUERY_FAILED
+      );
+    }
+    return response;
+  }
+  async lease(signal) {
+    const response = await this.request("/commands/lease", {
+      body: { version: "1", capabilities: ["exec"] },
+      signal
+    });
+    if (response.status === 204) return null;
+    return parseLease(await readJson(response));
+  }
+  async markRunning(commandId, leaseToken) {
+    await this.request(`/commands/${commandId}/running`, { leaseToken });
+  }
+  async heartbeat(commandId, leaseToken, signal) {
+    const response = await this.request(`/commands/${commandId}/heartbeat`, {
+      leaseToken,
+      signal
+    });
+    return parseHeartbeat(await readJson(response));
+  }
+  async output(commandId, leaseToken, stdout, stderr) {
+    await this.request(`/commands/${commandId}/output`, {
+      leaseToken,
+      body: { stdout, stderr }
+    });
+  }
+  async complete(commandId, leaseToken, result) {
+    await this.request(`/commands/${commandId}/complete`, {
+      leaseToken,
+      body: {
+        exitCode: result.exitCode,
+        success: result.success,
+        ...result.errorCode ? { errorCode: result.errorCode } : {}
+      }
+    });
+  }
+};
+
+// src/device/process-runner.ts
+import { spawn } from "child_process";
+import { constants } from "fs";
+import { access, stat } from "fs/promises";
+import { isAbsolute } from "path";
+import { StringDecoder } from "string_decoder";
+var OUTPUT_LIMIT = 3e4;
+var TERMINATION_GRACE_MS = 5e3;
+var TERMINATION_POLL_MS = 50;
+var BoundedTextBuffer = class {
+  constructor() {
+    this.decoder = new StringDecoder("utf8");
+    this.decoderFlushed = false;
+    this.value = "";
+    this.truncated = false;
+  }
+  append(chunk) {
+    if (this.truncated) return;
+    const text = typeof chunk === "string" ? chunk : this.decoder.write(Buffer.from(chunk));
+    this.appendText(text);
+  }
+  appendText(text) {
+    const remaining = OUTPUT_LIMIT - this.value.length;
+    if (text.length <= remaining) {
+      this.value += text;
+      return;
+    }
+    this.value += text.slice(0, Math.max(remaining, 0));
+    this.truncated = true;
+  }
+  toString() {
+    if (!this.decoderFlushed) {
+      this.decoderFlushed = true;
+      this.appendText(this.decoder.end());
+    }
+    return this.truncated ? `${this.value}
+... output truncated to ${OUTPUT_LIMIT} chars` : this.value;
+  }
+};
+function isMissingProcess(error) {
+  return error instanceof Error && "code" in error && error.code === "ESRCH";
+}
+function signalProcessGroup(pid, signal, kill) {
+  try {
+    kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (isMissingProcess(error)) return false;
+    throw error;
+  }
+}
+function beginProcessGroupTermination(pid, deps = {}) {
+  const kill = deps.kill ?? process.kill.bind(process);
+  const setTimer = deps.setTimer ?? setTimeout;
+  const clearTimer = deps.clearTimer ?? clearTimeout;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let escalationTimer;
+    let pollTimer;
+    function clearTimers() {
+      if (escalationTimer) clearTimer(escalationTimer);
+      if (pollTimer) clearTimer(pollTimer);
+    }
+    function finish() {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve();
+    }
+    function fail(error) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      reject(error);
+    }
+    function poll() {
+      if (settled) return;
+      try {
+        if (!signalProcessGroup(pid, 0, kill)) {
+          finish();
+          return;
+        }
+        pollTimer = setTimer(poll, TERMINATION_POLL_MS);
+      } catch (error) {
+        fail(error);
+      }
+    }
+    try {
+      if (!signalProcessGroup(pid, "SIGTERM", kill)) {
+        finish();
+        return;
+      }
+      escalationTimer = setTimer(() => {
+        try {
+          if (!signalProcessGroup(pid, 0, kill)) {
+            finish();
+            return;
+          }
+          signalProcessGroup(pid, "SIGKILL", kill);
+        } catch (error) {
+          fail(error);
+        }
+      }, TERMINATION_GRACE_MS);
+      pollTimer = setTimer(poll, TERMINATION_POLL_MS);
+    } catch (error) {
+      fail(error);
+    }
+  });
+}
+async function resolveShell(shell = process.env.SHELL) {
+  if (!(shell && isAbsolute(shell))) return "/bin/sh";
+  try {
+    const metadata = await stat(shell);
+    if (!metadata.isFile()) return "/bin/sh";
+    await access(shell, constants.X_OK);
+    return shell;
+  } catch {
+    return "/bin/sh";
+  }
+}
+function terminalResult(reason, stdout, stderr) {
+  return {
+    stdout: stdout.toString(),
+    stderr: stderr.toString(),
+    exitCode: reason === "timed_out" ? 124 : 130,
+    success: false,
+    errorCode: reason
+  };
+}
+async function runDeviceProcess(input2) {
+  if (input2.signal?.aborted) {
+    return { stdout: "", stderr: "", exitCode: 130, success: false, errorCode: "cancelled" };
+  }
+  const shell = await resolveShell();
+  if (input2.signal?.aborted) {
+    return { stdout: "", stderr: "", exitCode: 130, success: false, errorCode: "cancelled" };
+  }
+  const stdout = new BoundedTextBuffer();
+  const stderr = new BoundedTextBuffer();
+  return new Promise((resolve) => {
+    let settled = false;
+    let terminationReason;
+    let termination;
+    let child;
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      input2.signal?.removeEventListener("abort", cancel);
+      resolve(result);
+    }
+    function finishTerminationFailure(error) {
+      finish({
+        stdout: stdout.toString(),
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        errorCode: "execution_failed"
+      });
+    }
+    function terminate(reason) {
+      if (settled || terminationReason || !child?.pid) return;
+      terminationReason = reason;
+      termination = beginProcessGroupTermination(child.pid);
+      termination.catch(finishTerminationFailure);
+    }
+    function cancel() {
+      terminate("cancelled");
+    }
+    const timeout = setTimeout(() => terminate("timed_out"), input2.timeoutMs);
+    try {
+      const spawned2 = spawn(shell, ["-lc", input2.command], {
+        cwd: input2.cwd,
+        env: process.env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child = spawned2;
+    } catch (error) {
+      finish({
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        errorCode: "execution_failed"
+      });
+      return;
+    }
+    input2.signal?.addEventListener("abort", cancel, { once: true });
+    if (input2.signal?.aborted) cancel();
+    const spawned = child;
+    spawned.stdout.on("data", (chunk) => stdout.append(chunk));
+    spawned.stderr.on("data", (chunk) => stderr.append(chunk));
+    spawned.once("error", (error) => {
+      finish({
+        stdout: stdout.toString(),
+        stderr: error.message,
+        exitCode: 1,
+        success: false,
+        errorCode: "execution_failed"
+      });
+    });
+    spawned.once("close", (code) => {
+      if (terminationReason) {
+        const reason = terminationReason;
+        (termination ?? Promise.resolve()).then(
+          () => finish(terminalResult(reason, stdout, stderr)),
+          finishTerminationFailure
+        );
+        return;
+      }
+      const exitCode = code ?? 1;
+      finish({
+        stdout: stdout.toString(),
+        stderr: stderr.toString(),
+        exitCode,
+        success: exitCode === 0,
+        ...code === null ? { errorCode: "execution_failed" } : {}
+      });
+    });
+  });
+}
+
+// src/device/worker-loop.ts
+var HEARTBEAT_INTERVAL_MS = 2e3;
+var INITIAL_RETRY_MS = 250;
+var MAX_RETRY_MS = 1e4;
+var RETRY_JITTER_MS = 250;
+function computeRetryDelay(attempt, random = Math.random) {
+  const exponential = Math.min(INITIAL_RETRY_MS * 2 ** attempt, MAX_RETRY_MS);
+  return exponential + Math.floor(random() * RETRY_JITTER_MS);
+}
+function sleepWithAbort(milliseconds, signal) {
+  if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    function abort() {
+      clearTimeout(timer);
+      reject(new DOMException("Aborted", "AbortError"));
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, milliseconds);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function isAbortError2(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function isRetryableIdleError(error) {
+  return error instanceof DeviceWorkerRequestError && (error.statusCode === 0 || error.statusCode >= 500);
+}
+function isLeaseConflict(error) {
+  return error instanceof DeviceWorkerRequestError && error.statusCode === 409;
+}
+async function executeLease(command, input2, runProcess, sleep) {
+  try {
+    await input2.client.markRunning(command.id, command.leaseToken);
+  } catch (error) {
+    if (error instanceof DeviceCredentialRejectedError) throw error;
+    return;
+  }
+  input2.onEvent?.({ type: "running", commandId: command.id, intent: command.intent });
+  const commandController = new AbortController();
+  const heartbeatController = new AbortController();
+  let completionAllowed = true;
+  let heartbeatFailure;
+  function abortCommand() {
+    commandController.abort();
+  }
+  input2.signal.addEventListener("abort", abortCommand, { once: true });
+  const processPromise = runProcess({
+    command: command.command,
+    cwd: command.cwd,
+    timeoutMs: command.timeoutMs,
+    signal: commandController.signal
+  });
+  const heartbeatPromise = (async () => {
+    while (!heartbeatController.signal.aborted) {
+      try {
+        await sleep(HEARTBEAT_INTERVAL_MS, heartbeatController.signal);
+        const heartbeat = await input2.client.heartbeat(
+          command.id,
+          command.leaseToken,
+          heartbeatController.signal
+        );
+        if (heartbeat.cancel) {
+          if (heartbeat.reason === "revoked") completionAllowed = false;
+          commandController.abort();
+          return;
+        }
+      } catch (error) {
+        if (heartbeatController.signal.aborted && isAbortError2(error)) return;
+        heartbeatFailure = error;
+        completionAllowed = false;
+        commandController.abort();
+        return;
+      }
+    }
+  })();
+  let result;
+  try {
+    result = await processPromise;
+  } catch (error) {
+    result = {
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error),
+      exitCode: 1,
+      success: false,
+      errorCode: "execution_failed"
+    };
+  } finally {
+    heartbeatController.abort();
+    await heartbeatPromise;
+    input2.signal.removeEventListener("abort", abortCommand);
+  }
+  if (heartbeatFailure instanceof DeviceCredentialRejectedError) throw heartbeatFailure;
+  if (!completionAllowed || isLeaseConflict(heartbeatFailure)) return;
+  try {
+    await input2.client.output(command.id, command.leaseToken, result.stdout, result.stderr);
+    await input2.client.complete(command.id, command.leaseToken, result);
+  } catch (error) {
+    if (error instanceof DeviceCredentialRejectedError) throw error;
+    return;
+  }
+  input2.onEvent?.({ type: "completed", commandId: command.id, exitCode: result.exitCode });
+}
+async function runDeviceWorker(input2) {
+  const runProcess = input2.runProcess ?? runDeviceProcess;
+  const sleep = input2.sleep ?? sleepWithAbort;
+  const random = input2.random ?? Math.random;
+  let retryAttempt = 0;
+  while (!input2.signal.aborted) {
+    let command;
+    try {
+      command = await input2.client.lease(input2.signal);
+      retryAttempt = 0;
+    } catch (error) {
+      if (input2.signal.aborted) return;
+      if (error instanceof DeviceCredentialRejectedError) throw error;
+      if (!isRetryableIdleError(error)) throw error;
+      try {
+        await sleep(computeRetryDelay(retryAttempt, random), input2.signal);
+      } catch (sleepError) {
+        if (input2.signal.aborted && isAbortError2(sleepError)) return;
+        throw sleepError;
+      }
+      retryAttempt += 1;
+      continue;
+    }
+    if (!command) continue;
+    await executeLease(command, input2, runProcess, sleep);
+  }
+}
+
+// src/commands/device.ts
+var NAMED_PROFILE_REQUIRED = "Device pairing requires a named Standards profile";
+var SUPPORTED_PLATFORMS_REQUIRED = "Device workers support macOS and Linux only";
+var DeviceCommandError = class extends SchemaError2 {
+  constructor(message) {
+    super(message, SchemaErrorCode2.VALIDATION_FAILED);
+    this.name = "DeviceCommandError";
+  }
+};
+function requireSupportedPlatform(platform) {
+  if (platform === "darwin" || platform === "linux") return platform;
+  throw new DeviceCommandError(SUPPORTED_PLATFORMS_REQUIRED);
+}
+function requireNamedProfile(command) {
+  const options = getGlobalOptions(command);
+  if (!(options.profileName && options.apiUrl && options.apiKey)) {
+    throw new DeviceCommandError(NAMED_PROFILE_REQUIRED);
+  }
+  return {
+    apiUrl: options.apiUrl,
+    apiKey: options.apiKey,
+    profileName: options.profileName,
+    tenantId: options.tenant
+  };
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseDeviceView(value) {
+  if (!isRecord2(value)) throw new DeviceCommandError("Invalid device response");
+  const { id, name, platform, arch, hostname: deviceHostname } = value;
+  const { status } = value;
+  if (typeof id !== "string" || typeof name !== "string" || platform !== "darwin" && platform !== "linux" || typeof arch !== "string" || typeof deviceHostname !== "string" || status !== "online" && status !== "offline" && status !== "revoked") {
+    throw new DeviceCommandError("Invalid device response");
+  }
+  return { id, name, platform, arch, hostname: deviceHostname, status };
+}
+function parsePairDeviceResponse(value) {
+  if (!isRecord2(value) || typeof value.token !== "string") {
+    throw new DeviceCommandError("Invalid device pairing response");
+  }
+  return { device: parseDeviceView(value.device), token: value.token };
+}
+function parseDeviceList(value) {
+  if (!Array.isArray(value)) throw new DeviceCommandError("Invalid device list response");
+  return value.map(parseDeviceView);
+}
+async function pairDevice(name, command) {
+  const platform = requireSupportedPlatform(process.platform);
+  const profile = requireNamedProfile(command);
+  const installationId = await getOrCreateInstallationId();
+  const client = createClient({
+    apiUrl: profile.apiUrl,
+    apiKey: profile.apiKey,
+    tenantId: profile.tenantId
+  });
+  const response = parsePairDeviceResponse(
+    await client.post("/devices/pair", {
+      installationId,
+      name,
+      platform,
+      arch: process.arch,
+      hostname: hostname()
+    })
+  );
+  const stored = await storeDeviceCredential(profile.profileName, {
+    id: response.device.id,
+    name: response.device.name,
+    token: response.token
+  });
+  if (!stored) throw new DeviceCommandError(NAMED_PROFILE_REQUIRED);
+  process.stdout.write(`Paired ${response.device.name} (${response.device.id})
+`);
+}
+async function showDeviceStatus(command) {
+  const profile = requireNamedProfile(command);
+  const credential = await getStoredDeviceCredential(profile.profileName);
+  if (!credential) {
+    throw new DeviceCommandError("No paired device; run standards device pair first");
+  }
+  const client = createClient({
+    apiUrl: profile.apiUrl,
+    apiKey: profile.apiKey,
+    tenantId: profile.tenantId
+  });
+  const devices = parseDeviceList(await client.get("/devices"));
+  const pairedDevice = devices.find((device) => device.id === credential.id);
+  formatOutput(
+    pairedDevice ? [pairedDevice] : [{ id: credential.id, name: credential.name, status: "revoked" }],
+    getFormat(command)
+  );
+}
+async function revokeDevice(command) {
+  const profile = requireNamedProfile(command);
+  const credential = await getStoredDeviceCredential(profile.profileName);
+  if (!credential) {
+    throw new DeviceCommandError("No paired device; run standards device pair first");
+  }
+  const client = createClient({
+    apiUrl: profile.apiUrl,
+    apiKey: profile.apiKey,
+    tenantId: profile.tenantId
+  });
+  await client.delete(`/devices/${credential.id}`);
+  await removeDeviceCredential(profile.profileName);
+}
+async function serveDevice(command) {
+  const platform = requireSupportedPlatform(process.platform);
+  const profile = requireNamedProfile(command);
+  const credential = await getStoredDeviceCredential(profile.profileName);
+  if (!credential) {
+    throw new DeviceCommandError("No paired device; run standards device pair first");
+  }
+  const userClient = createClient({
+    apiUrl: profile.apiUrl,
+    apiKey: profile.apiKey,
+    tenantId: profile.tenantId
+  });
+  const devices = parseDeviceList(await userClient.get("/devices"));
+  const device = devices.find((candidate) => candidate.id === credential.id);
+  if (!device) throw new DeviceCommandError("Device is unavailable");
+  if (device.platform !== platform) {
+    throw new DeviceCommandError("Device platform does not match paired device");
+  }
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  process.stdout.write(`Connected as ${credential.name}
+`);
+  process.stdout.write("Waiting for commands \u2014 press Ctrl+C to disconnect\n");
+  try {
+    await runDeviceWorker({
+      client: new DeviceWorkerClient({ apiUrl: profile.apiUrl, token: credential.token }),
+      signal: controller.signal,
+      onEvent: (event) => {
+        if (event.type === "running") {
+          process.stdout.write(`Running ${event.commandId}: ${event.intent}
+`);
+          return;
+        }
+        process.stdout.write(`Completed ${event.commandId} with exit code ${event.exitCode}
+`);
+      }
+    });
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+  }
+}
+function registerDeviceCommand(program) {
+  const device = program.command("device").description("Pair and run this computer as a device");
+  device.command("pair").description("Pair this computer with Standards").requiredOption("--name <name>", "device name").action(
+    async (options, command) => pairDevice(options.name, command)
+  );
+  device.command("status").description("Show the paired device status").action(async (_options, command) => showDeviceStatus(command));
+  device.command("revoke").description("Revoke this computer's device credential").action(async (_options, command) => revokeDevice(command));
+  device.command("serve").description("Run the foreground device worker").action(async (_options, command) => serveDevice(command));
+}
+
+// src/commands/documents.ts
+import { formatByteSize } from "@stndrds/schema";
+function toFileRow(file) {
+  return {
+    id: file.id,
+    position: file.position,
+    type: file.mimeType,
+    size: formatByteSize(file.size),
+    ocrStatus: file.ocrStatus
+  };
+}
+function registerDocumentsCommand(program) {
+  const documents = program.command("documents").description("Manage documents");
+  documents.command("list").description("List documents").option("--limit <n>", "max documents to return").option("--offset <n>", "number of documents to skip").action(async (opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const params = {};
+    if (opts.limit) params.limit = opts.limit;
+    if (opts.offset) params.offset = opts.offset;
+    const result = await client.get("/documents", params);
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("get").description("Get a document by ID").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get(`/documents/${id}`);
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("create").description("Create a new document").requiredOption("--title <title>", "document title").option("--values <json>", "document values as JSON string").action(async (opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const body = { title: opts.title };
+    if (opts.values) body.values = JSON.parse(opts.values);
+    const result = await client.post("/documents", body);
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("update").description("Update a document").argument("<id>", "document ID").option("--title <title>", "new title").option("--values <json>", "new values as JSON string").action(async (id, opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const body = {};
+    if (opts.title) body.title = opts.title;
+    if (opts.values) body.values = JSON.parse(opts.values);
+    const result = await client.patch(`/documents/${id}`, body);
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("delete").description("Delete a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/documents/${id}`);
+    process.stdout.write(`Document ${id} deleted.
+`);
+  });
+  documents.command("preview").description("Get preview file for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get(`/documents/${id}/preview`);
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("files").description("List files in a document's pack (position-ordered)").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const files = await client.get(`/documents/${id}/files`);
+    const sorted = [...files].sort((a, b) => a.position - b.position);
+    const format = getFormat(cmd);
+    formatOutput(format === "table" ? sorted.map(toFileRow) : sorted, format);
+  });
+  documents.command("add-file").description("Append a file to a document's pack").argument("<id>", "document ID").requiredOption("--file-id <fileId>", "file ID").action(async (id, opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.post(`/documents/${id}/files`, { fileId: opts.fileId });
+    formatOutput(result, getFormat(cmd));
+  });
+  documents.command("remove-file").description("Remove a file from a document's pack").argument("<id>", "document ID").argument("<fileId>", "file ID").action(async (id, fileId, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/documents/${id}/files/${fileId}`);
+    process.stdout.write(`File ${fileId} removed.
+`);
+  });
+  documents.command("content").description("Print a document's aggregated OCR text (every pack file, position order)").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const text = await client.getText(`/documents/${id}/content`);
+    process.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+  });
+}
+
+// src/commands/embeddings.ts
+import chalk4 from "chalk";
+function registerEmbeddingsCommand(program) {
+  const embeddings = program.command("embeddings").description("Maintain record embeddings");
+  embeddings.command("drain").description("Embed every pending memory and skill record of the tenant").action(async (_opts, cmd) => {
+    const tenant = requireTenant(
+      cmd,
+      'An embedding drain names its tenant explicitly. Pass "--tenant <id>".'
+    );
+    const client = getClientFromCommand(cmd);
+    await client.post("/admin/embeddings/drain", { tenantId: tenant });
+    process.stdout.write(`${chalk4.green("\u2713")} Embedding drain accepted for tenant ${tenant}.
+`);
+  });
+}
+
+// src/commands/folders.ts
+import { readFile as readFile2 } from "fs/promises";
+function registerFoldersCommand(program) {
+  const folders = program.command("folders").description("Manage record drive folders");
+  folders.command("reconcile-paths").description("Create a folder tree on a record drive from paths").argument("<object>", "object name (e.g. contacts)").argument("<recordId>", "record ID owning the drive").option(
+    "--path <path>",
+    "folder path to create (repeatable)",
+    (val, acc) => {
+      acc.push(val);
+      return acc;
+    },
+    []
+  ).option("--paths-file <file>", "file containing one path per line").option("--mode <mode>", "reconcile mode: repair or dryRun", "repair").action(async (objectName, recordId, opts, cmd) => {
+    const paths = [...opts.path];
+    if (opts.pathsFile) {
+      const content = await readFile2(opts.pathsFile, "utf-8");
+      const filePaths = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+      paths.push(...filePaths);
+    }
+    if (paths.length === 0) {
+      throw new Error("No paths provided. Pass at least one --path or a non-empty --paths-file.");
+    }
+    const client = getClientFromCommand(cmd);
+    const result = await client.post(`/folders/record-drive/${recordId}/reconcile-paths`, {
+      objectName,
+      paths,
+      mode: opts.mode
+    });
+    formatOutput(result, getFormat(cmd));
+  });
+}
+
+// src/commands/keys.ts
+import chalk5 from "chalk";
+function registerKeysCommand(program) {
+  const keys = program.command("keys").description("Manage Standards API keys");
+  keys.command("list").description("List API keys").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/api-keys");
+    formatOutput(result, getFormat(cmd));
+  });
+  keys.command("create").description("Create a new API key").requiredOption("--name <name>", "name for the API key").option("--expires <date>", "expiration date (ISO 8601)").option("--yes", "create without confirmation").action(async (opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Creating API keys is explicit. Re-run with "--yes" to confirm.');
+    }
+    const client = getClientFromCommand(cmd);
+    const body = {
+      name: opts.name,
+      permissions: []
+    };
+    if (opts.expires) body.expiresAt = opts.expires;
+    const result = await client.post("/api-keys", body);
+    formatOutput(result, getFormat(cmd));
+  });
+  keys.command("revoke").description("Revoke an API key").argument("<id>", "API key ID").option("--yes", "revoke without confirmation").action(async (id, opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Revoking API keys is explicit. Re-run with "--yes" to confirm.');
+    }
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/api-keys/${id}`);
+    process.stdout.write(`${chalk5.green("\u2713")} API key ${id} revoked.
+`);
+  });
+}
+
+// src/commands/mcp.ts
+import { RESOURCE_VISIBILITIES, ValidationError as ValidationError3 } from "@stndrds/schema";
+import chalk6 from "chalk";
+var AUTH_TYPES = ["none", "header"];
+function buildAuth(opts) {
+  const type = opts.authType ?? "none";
+  if (!AUTH_TYPES.includes(type)) {
+    throw new ValidationError3(`--auth-type must be one of: ${AUTH_TYPES.join(", ")}`, []);
+  }
+  if (type === "none") {
+    return { type: "none" };
+  }
+  if (!(opts.headerName && opts.secret)) {
+    throw new ValidationError3('--auth-type "header" requires both --header-name and --secret.', []);
+  }
+  return { type: "header", headerName: opts.headerName, secret: opts.secret };
+}
+function resolveVisibility(visibility) {
+  if (visibility === void 0) {
+    return "workspace";
+  }
+  if (!RESOURCE_VISIBILITIES.includes(visibility)) {
+    throw new ValidationError3(
+      `--visibility must be one of: ${RESOURCE_VISIBILITIES.join(", ")}`,
+      []
+    );
+  }
+  return visibility;
+}
+function registerMcpCommand(program) {
+  const mcp = program.command("mcp").description("Manage MCP servers mounted into this workspace's agents");
+  mcp.command("list").description("List connected MCP servers").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/mcp-servers");
+    formatOutput(result, getFormat(cmd));
+  });
+  mcp.command("catalog").description("List the vendored MCP catalog entries available to connect").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/mcp-servers/catalog");
+    formatOutput(result, getFormat(cmd));
+  });
+  mcp.command("connect").description("Connect a remote MCP server and mount its tools").requiredOption("--slug <slug>", "unique slug for the server").requiredOption("--name <name>", "display name").requiredOption("--url <url>", "remote MCP endpoint URL").option("--visibility <visibility>", "workspace or private", "workspace").option("--catalog-entry <id>", "catalog entry ID this server instantiates").option("--auth-type <type>", "none or header", "none").option("--header-name <name>", 'header name when --auth-type is "header"').option("--secret <secret>", 'header value when --auth-type is "header"').action(async (opts, cmd) => {
+    const auth = buildAuth(opts);
+    const visibility = resolveVisibility(opts.visibility);
+    const client = getClientFromCommand(cmd);
+    const result = await client.post("/mcp-servers", {
+      slug: opts.slug,
+      name: opts.name,
+      url: opts.url,
+      visibility,
+      catalogEntryId: opts.catalogEntry ?? null,
+      auth
+    });
+    formatOutput(result, getFormat(cmd));
+  });
+  mcp.command("refresh").description("Re-discover a server's tools and refresh its status").argument("<id>", "MCP server ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.post(`/mcp-servers/${id}/refresh`);
+    formatOutput(result, getFormat(cmd));
+  });
+  mcp.command("trust").description("Mark a server trusted so its tools run without per-call approval").argument("<id>", "MCP server ID").option("--revoke", "revoke trust instead of granting it").action(async (id, opts, cmd) => {
+    const trusted = !opts.revoke;
+    const client = getClientFromCommand(cmd);
+    await client.post(`/mcp-servers/${id}/trust`, { trusted });
+    process.stdout.write(
+      `${chalk6.green("\u2713")} MCP server ${id} ${trusted ? "trusted" : "untrusted"}.
+`
+    );
+  });
+  mcp.command("disconnect").description("Disconnect (delete) an MCP server").argument("<id>", "MCP server ID").option("--yes", "disconnect without confirmation").action(async (id, opts, cmd) => {
+    if (!opts.yes) {
+      throw new ValidationError3(
+        'Disconnecting an MCP server is explicit. Re-run with "--yes" to confirm.',
+        []
+      );
+    }
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/mcp-servers/${id}`);
+    process.stdout.write(`${chalk6.green("\u2713")} MCP server ${id} disconnected.
+`);
+  });
+}
+
+// src/commands/meetings.ts
+import { createHmac } from "crypto";
+import {
+  FAKE_MEETING_BOT_SIGNATURE_HEADER,
+  RECORDING_OVERRIDES,
+  ValidationError as ValidationError4
+} from "@stndrds/schema";
+var ORDERS = ["asc", "desc"];
+function parseOrder(order) {
+  if (ORDERS.includes(order)) return order;
+  throw new ValidationError4(`--order must be one of: ${ORDERS.join(", ")}`, []);
+}
+function parseCount(flag, value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new ValidationError4(`${flag} must be a non-negative integer`, []);
+  }
+  return parsed;
+}
+function buildQuery(opts) {
+  const query = {};
+  if (opts.search !== void 0) query.search = opts.search;
+  if (opts.since !== void 0) query.since = opts.since;
+  if (opts.before !== void 0) query.before = opts.before;
+  if (opts.addresses !== void 0) query.addresses = parseCsvList(opts.addresses);
+  if (opts.record !== void 0) query.recordId = opts.record;
+  if (opts.order !== void 0) query.order = parseOrder(opts.order);
+  if (opts.limit !== void 0) query.limit = parseCount("--limit", opts.limit);
+  if (opts.offset !== void 0) query.offset = parseCount("--offset", opts.offset);
+  return query;
+}
+function parseOverride(opts) {
+  const chosen = RECORDING_OVERRIDES.filter(
+    (override) => opts[override]
+  );
+  if (opts.auto) chosen.push(null);
+  if (chosen.length !== 1) {
+    throw new ValidationError4("record needs exactly one of --force, --skip or --auto", []);
+  }
+  return chosen[0] ?? null;
+}
+var SIMULATED_LINE_MS = 4e3;
+var DEFAULT_SIMULATED_LINES = 12;
+var SIMULATED_SENTENCES = [
+  "Bonjour \xE0 tous, merci d'\xEAtre l\xE0, on commence par le point d'avancement.",
+  "De mon c\xF4t\xE9 la maquette est valid\xE9e, il reste les retours du client.",
+  "On garde le planning initial, la livraison est pr\xE9vue pour vendredi.",
+  "Est-ce que quelqu'un a des questions sur le budget de la phase deux ?",
+  "Je propose qu'on fasse un point rapide jeudi pour v\xE9rifier les tests.",
+  "Tr\xE8s bien, je vous envoie le compte rendu dans la journ\xE9e, bonne journ\xE9e."
+];
+function simulatedSpeakers(meeting) {
+  const speakers = meeting.participants.map(
+    (participant) => participant.name?.trim() || participant.address.split("@")[0] || participant.address
+  );
+  return speakers.length > 0 ? speakers : ["Speaker"];
+}
+function buildSimulatedSegments(speakers, lines) {
+  return Array.from({ length: lines }, (_, index) => ({
+    speaker: speakers[index % speakers.length] ?? null,
+    startsAtMs: index * SIMULATED_LINE_MS,
+    endsAtMs: (index + 1) * SIMULATED_LINE_MS,
+    text: SIMULATED_SENTENCES[index % SIMULATED_SENTENCES.length] ?? ""
+  }));
+}
+function signFakeWebhook(secret, body) {
+  return createHmac("sha256", secret).update(body).digest("hex");
+}
+function withQueryOptions(command) {
+  return command.option("--search <text>", "match title, description and location").option("--since <iso>", "inclusive ISO lower bound on the start").option("--before <iso>", "exclusive ISO upper bound on the start").option("--addresses <emails>", "comma-separated participant addresses to restrict to").option("--record <id>", "only meetings linked to this record").option("--order <order>", "asc for what is coming next, desc to read history").option("--limit <n>", "max meetings to return").option("--offset <n>", "number of meetings to skip");
+}
+function registerMeetingsCommand(program) {
+  const meetings = program.command("meetings").description("Read calendar meetings and the records each one concerns");
+  withQueryOptions(
+    meetings.command("list").description("List meetings, newest window first by default")
+  ).action(async (opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.post("/meetings/search", buildQuery(opts));
+    formatOutput(result, getFormat(cmd));
+  });
+  meetings.command("get").description("Get one meeting, with its participants and linked records").argument("<id>", "meeting ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get(`/meetings/${id}`);
+    formatOutput(result, getFormat(cmd));
+  });
+  withQueryOptions(
+    meetings.command("for-record").description("List the meetings a record's email addresses appear in").argument("<recordId>", "record ID").option(
+      "--email-attributes <ids>",
+      "comma-separated email attribute IDs to match participants on"
+    )
+  ).action(
+    async (recordId, opts, cmd) => {
+      const client = getClientFromCommand(cmd);
+      const result = await client.post(`/meetings/records/${recordId}`, {
+        // The API defaults an absent list to none, which matches nothing —
+        // send the key only when the caller named the attributes.
+        ...opts.emailAttributes !== void 0 && {
+          emailAttributeIds: parseCsvList(opts.emailAttributes)
+        },
+        query: buildQuery(opts)
+      });
+      formatOutput(result, getFormat(cmd));
+    }
+  );
+  meetings.command("transcript").description("Read a meeting's completed transcript").argument("<id>", "meeting ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get(`/meetings/${id}/transcript`);
+    formatOutput(result, getFormat(cmd));
+  });
+  meetings.command("record").description("Force, skip, or hand back to the workspace policy the recording of a meeting").argument("<id>", "meeting ID").option("--force", "record this meeting whatever the workspace policy says").option("--skip", "never record this meeting").option("--auto", "clear the override and follow the workspace policy").action(async (id, opts, cmd) => {
+    const override = parseOverride(opts);
+    const client = getClientFromCommand(cmd);
+    const result = await client.put(`/meetings/${id}/recording`, { override });
+    formatOutput(result, getFormat(cmd));
+  });
+  meetings.command("simulate-transcript").description("Complete a fake-provider bot by posting a generated transcript to its webhook").argument("<id>", "meeting ID").option(
+    "--lines <n>",
+    "number of transcript lines to generate",
+    String(DEFAULT_SIMULATED_LINES)
+  ).action(async (id, opts, cmd) => {
+    const secret = process.env.MEETING_BOT_FAKE_SECRET;
+    if (!secret) {
+      throw new ValidationError4("MEETING_BOT_FAKE_SECRET is not set in this shell", []);
+    }
+    const lines = parseCount("--lines", opts.lines);
+    if (lines < 1) throw new ValidationError4("--lines must be at least 1", []);
+    const client = getClientFromCommand(cmd);
+    const meeting = await client.get(`/meetings/${id}`);
+    const { status, botId } = meeting.recording;
+    if (status !== "scheduled" && status !== "recording" || botId === null) {
+      throw new ValidationError4(`Meeting ${id} has no bot to complete (status: ${status})`, []);
+    }
+    const segments = buildSimulatedSegments(simulatedSpeakers(meeting), lines);
+    const startedAt = meeting.startsAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const endedAt = new Date(
+      new Date(startedAt).getTime() + lines * SIMULATED_LINE_MS
+    ).toISOString();
+    const body = JSON.stringify({
+      botId,
+      transcript: {
+        fullText: segments.map((segment) => segment.text).join("\n"),
+        segments,
+        language: "fr",
+        startedAt,
+        endedAt
+      }
+    });
+    const response = await fetch(
+      `${getGlobalOptions(cmd).apiUrl}/meetings/transcripts/webhook/fake`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          [FAKE_MEETING_BOT_SIGNATURE_HEADER]: signFakeWebhook(secret, body)
+        },
+        body
+      }
+    );
+    if (!response.ok) {
+      throw new ValidationError4(`webhook answered ${response.status}`, []);
+    }
+    formatOutput({ botId, segments: segments.length }, getFormat(cmd));
+  });
+}
+
+// src/commands/pull.ts
+import chalk7 from "chalk";
+
+// src/drift/reconciliation-prompt.ts
+var PREAMBLE = [
+  "# Standards schema reconciliation",
+  "",
+  "The deployed runtime has drifted from code. Walk each item **with the developer**,",
+  "then edit the fluent builders. The pre-deploy gate (STANDARDS_SYNC_CHECK=1) applies",
+  "your choices at deploy. Loop until the gate reports clean. Never make a destructive",
+  "choice without the developer's explicit confirmation.",
+  ""
+].join("\n");
+function isViewDiverged(view) {
+  return view.origin !== "code" && view.baselineHash !== null && view.dbHash !== view.baselineHash;
+}
+function hasReconcilableDrift(state) {
+  return state.drift.customObjects.length > 0 || state.drift.systemObjectDrift.length > 0 || state.views.some(isViewDiverged) || state.views.some((v) => v.origin === "code" && v.workspaceOverlay !== null) || state.views.some((v) => v.origin === "runtime");
+}
+function renderAttribute(objectName, sealed, attr) {
+  const action = attr.tolerated ? "Already tolerated \u2014 declare it in the builder to make it a system attribute, or leave tolerated." : `Choose: **declare** \`${attr.name}\` on the \`${objectName}\` builder (\u2192 becomes system on next sync), OR **tolerate** it \u2014 add \`.tolerate(["${attr.name}"])\`${sealed ? " (required: the object is sealed)" : ""}.`;
+  return `- \`${objectName}.${attr.name}\` (${attr.type})
+  ${action}`;
+}
+function renderView(view) {
+  const d = view.delta;
+  const lines = [`### view \`${view.object}:${view.name}:${view.type}\``];
+  if (d) {
+    if (d.tabsAdded.length) lines.push(`- tabs added at runtime: ${d.tabsAdded.join(", ")}`);
+    if (d.tabsRemoved.length) lines.push(`- tabs removed at runtime: ${d.tabsRemoved.join(", ")}`);
+    for (const t of d.tabsChanged)
+      lines.push(`- tab "${t.name}" changed: ${t.changedKeys.join(", ")}`);
+    if (d.topLevelChanged.length) lines.push(`- changed: ${d.topLevelChanged.join(", ")}`);
+  }
+  lines.push(
+    "",
+    "Runtime config to fold into the builder call (or record an explicit resolution to let code win):",
+    "```json",
+    JSON.stringify(view.config, null, 2),
+    "```"
+  );
+  return lines.join("\n");
+}
+function renderWorkspaceOverlay(view) {
+  const lines = [
+    `### view \`${view.object}:${view.name}:${view.type}\``,
+    "",
+    "Workspace overlay to fold into the builder call (or leave as a runtime-only workspace customization):",
+    "```json",
+    JSON.stringify(view.workspaceOverlay, null, 2),
+    "```"
+  ];
+  return lines.join("\n");
+}
+function renderAdoptionCandidate(view) {
+  const lines = [
+    `### view \`${view.object}:${view.name}:${view.type}\``,
+    "",
+    "Runtime-only view to adopt into a builder call (or leave as runtime-only):",
+    "```json",
+    JSON.stringify(view.config, null, 2),
+    "```"
+  ];
+  return lines.join("\n");
+}
+function renderReconciliationPrompt(state) {
+  if (!hasReconcilableDrift(state))
+    return `${PREAMBLE}
+No drift to reconcile \u2014 the runtime matches code.
+`;
+  const parts = [PREAMBLE];
+  for (const obj of state.drift.customObjects) {
+    parts.push(
+      `## Custom object \`${obj.name}\` (runtime-only)
+Add an \`object("${obj.name}")\` builder, then its attributes:`
+    );
+    for (const a of obj.attributes) parts.push(renderAttribute(obj.name, false, a));
+  }
+  for (const entry of state.drift.systemObjectDrift) {
+    parts.push(`## \`${entry.objectName}\`${entry.sealed ? " (sealed)" : ""} \u2014 custom attributes`);
+    for (const a of entry.customAttributes)
+      parts.push(renderAttribute(entry.objectName, entry.sealed, a));
+  }
+  const overlaidViews = state.views.filter(
+    (v) => v.origin === "code" && v.workspaceOverlay !== null
+  );
+  if (overlaidViews.length) {
+    parts.push("## Workspace customizations to fold into code");
+    for (const v of overlaidViews) parts.push(renderWorkspaceOverlay(v));
+  }
+  const runtimeViews = state.views.filter((v) => v.origin === "runtime");
+  if (runtimeViews.length) {
+    parts.push("## Runtime views to adopt into code");
+    for (const v of runtimeViews) parts.push(renderAdoptionCandidate(v));
+  }
+  const divergedViews = state.views.filter(isViewDiverged);
+  if (divergedViews.length) {
+    parts.push("## Drifted views");
+    for (const v of divergedViews) parts.push(renderView(v));
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+
+// src/commands/pull.ts
+async function runPullCommand(client) {
+  let state;
+  try {
+    state = await client.get("/schema/state");
+  } catch (error) {
+    return { exitCode: 2, errorMessage: messageOf(error) };
+  }
+  return { exitCode: 0, prompt: renderReconciliationPrompt(state) };
+}
+function registerPullCommand(program) {
+  program.command("pull").description("Emit a self-contained reconciliation prompt for the current runtime drift").option("--json", "Emit the raw /schema/state JSON instead of the prompt").action(async (opts, cmd) => {
+    let client;
+    try {
+      client = getClientFromCommand(cmd);
+    } catch (error) {
+      console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
+      process.exit(2);
+      return;
+    }
+    if (opts.json) {
+      try {
+        const state = await client.get("/schema/state");
+        console.info(JSON.stringify(state, null, 2));
+        process.exit(0);
+      } catch (error) {
+        console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
+        process.exit(2);
+      }
+      return;
+    }
+    const result = await runPullCommand(client);
+    if (result.exitCode === 2) {
+      console.error(chalk7.red(`\u2717 ${result.errorMessage}`));
+      process.exit(2);
+      return;
+    }
+    console.info(result.prompt);
+    process.exit(0);
+  });
+}
+
+// src/commands/quotas.ts
+function registerQuotasCommand(program) {
+  const quotas = program.command("quotas").description("Inspect the tenant's remaining capacity");
+  quotas.command("list").description("List one state per quota key (limit is null when nothing is enforced)").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/quotas");
+    formatOutput(result, getFormat(cmd));
+  });
+}
+
+// src/commands/records.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename } from "path";
+function parseSortFlag(sort) {
+  const [attribute, direction = "asc"] = sort.split(":");
+  return [{ attribute, direction }];
+}
+var COUNT_MODES = ["none", "estimated", "exact"];
+function parseCountFlag(count) {
+  if (COUNT_MODES.includes(count)) return count;
+  throw new Error(`Invalid --count value "${count}". Expected one of: ${COUNT_MODES.join(", ")}.`);
+}
+function buildQueryBody(opts) {
+  const body = {};
+  if (opts.limit) body.limit = Number(opts.limit);
+  if (opts.offset) body.offset = Number(opts.offset);
+  if (opts.sort) body.sorts = parseSortFlag(opts.sort);
+  if (opts.filter) body.filters = JSON.parse(opts.filter);
+  if (opts.fields !== void 0) body.fields = parseCsvList(opts.fields);
+  if (opts.count) body.countMode = parseCountFlag(opts.count);
+  return body;
+}
+var COUNT_OPTION_DESCRIPTION = "total count mode (none, estimated, exact); omit for no total in page.total";
+function registerRecordsCommand(program) {
+  const records = program.command("records").description("Manage records (CRUD + search)");
+  records.command("list").description("List records for an object").argument("<object>", "object name (e.g. contacts)").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").option(
+    "--fields <names>",
+    "comma-separated reference attributes to hydrate (empty for none, omit for all)"
+  ).option("--count <mode>", COUNT_OPTION_DESCRIPTION).action(async (objectName, opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const body = buildQueryBody(opts);
+    const result = await client.post(`/records/${objectName}/list`, body);
+    formatOutput(result, getFormat(cmd));
+  });
+  records.command("get").description("Get a record by ID").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get(`/records/${objectName}/${id}`);
+    formatOutput(result, getFormat(cmd));
+  });
+  records.command("create").description("Create a new record").argument("<object>", "object name").option("--data <json>", "record data as JSON string").action(async (objectName, opts, cmd) => {
+    const data = opts.data ? JSON.parse(opts.data) : {};
+    const client = getClientFromCommand(cmd);
+    const result = await client.post(`/records/${objectName}`, { data });
+    formatOutput(result, getFormat(cmd));
+  });
+  records.command("update").description("Update a record").argument("<object>", "object name").argument("<id>", "record ID").option("--data <json>", "fields to update as JSON string").action(async (objectName, id, opts, cmd) => {
+    const data = opts.data ? JSON.parse(opts.data) : {};
+    const client = getClientFromCommand(cmd);
+    const result = await client.put(`/records/${objectName}/${id}`, data);
+    formatOutput(result, getFormat(cmd));
+  });
+  records.command("delete").description("Delete a record").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/records/${objectName}/${id}`);
+    process.stdout.write(`Record ${id} deleted.
+`);
+  });
+  records.command("search").description("Full-text search records").argument("<object>", "object name").requiredOption("--query <q>", "search query string").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").option(
+    "--fields <names>",
+    "comma-separated reference attributes to hydrate (empty for none, omit for all)"
+  ).option("--count <mode>", COUNT_OPTION_DESCRIPTION).action(async (objectName, opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const body = { q: opts.query, ...buildQueryBody(opts) };
+    const result = await client.post(`/records/${objectName}/search`, body);
+    formatOutput(result, getFormat(cmd));
+  });
+  records.command("attach-document").description("Upload and attach a local file to a record").argument("<object>", "object name (e.g. contacts)").argument("<recordId>", "record ID").requiredOption("--file <path>", "local file path to upload").option("--attribute <attr>", "attribute name to attach the document to").option("--parent-id <folderId>", "parent folder ID").option("--title <title>", "document title (defaults to filename)").action(async (objectName, recordId, opts, cmd) => {
+    const fileContent = await readFile3(opts.file);
+    const fileName = basename(opts.file);
+    const title = opts.title ?? fileName;
+    const form = new FormData();
+    form.append("files", new Blob([fileContent]), fileName);
+    form.append("title", title);
+    if (opts.attribute) form.append("attributeName", opts.attribute);
+    if (opts.parentId) form.append("parentId", opts.parentId);
+    const client = getClientFromCommand(cmd);
+    const result = await client.postMultipart(
+      `/records/${objectName}/${recordId}/documents/attach`,
+      form
+    );
+    formatOutput(result, getFormat(cmd));
+  });
+}
+
+// src/commands/root.ts
+import { stdin as input, stdout as output } from "process";
+import { createInterface } from "readline/promises";
+import chalk8 from "chalk";
+async function promptForMissingValue(label) {
+  const rl = createInterface({ input, output });
+  try {
+    const value = await rl.question(`${label}: `);
+    return value.trim();
+  } finally {
+    rl.close();
+  }
+}
+function registerRootCommands(program) {
+  program.command("login").description("Connect the CLI to a Standards instance").option("--url <url>", "Standards API URL", getDefaultApiUrl()).option("--key <key>", "API key to store for this instance").option("--name <name>", "local instance name", "local").action(async (opts) => {
+    const apiKey = opts.key ?? await promptForMissingValue("API key");
+    if (!apiKey) throw new Error("API key is required");
+    const client = createClient({ apiUrl: opts.url, apiKey });
+    await client.get("/api-keys");
+    await upsertProfile({ name: opts.name, apiUrl: opts.url, apiKey });
+    process.stdout.write(
+      `${chalk8.green("\u2713")} Standards instance "${opts.name}" saved and selected.
+`
+    );
+    process.stdout.write(`  API URL: ${opts.url}
+`);
+    process.stdout.write(`  API Key: ${apiKey.slice(0, 8)}...
+`);
+    process.stdout.write(`  Use it with: standards --instance ${opts.name} <command>
+`);
   });
   program.command("use").description("Select the active Standards instance").argument("<name>", "instance name").action(async (name) => {
     await setCurrentProfile(name);
-    process.stdout.write(`${chalk4.green("\u2713")} Standards instance "${name}" selected.
+    process.stdout.write(`${chalk8.green("\u2713")} Standards instance "${name}" selected.
 `);
   });
   program.command("instances").description("List configured Standards instances").action(async (_opts, cmd) => {
@@ -479,7 +1774,7 @@ function registerRootCommands(program) {
   });
   program.command("logout").description("Remove a Standards instance from local CLI config").argument("[name]", "instance name, defaults to current").action(async (name) => {
     await removeProfile(name);
-    process.stdout.write(`${chalk4.green("\u2713")} Standards instance removed.
+    process.stdout.write(`${chalk8.green("\u2713")} Standards instance removed.
 `);
   });
 }
@@ -499,6 +1794,49 @@ function registerSchemaCommand(program) {
   });
 }
 
+// src/commands/search.ts
+import chalk9 from "chalk";
+function registerSearchCommand(program) {
+  const search = program.command("search").description("Maintain the Standards search index");
+  search.command("reindex").description("Clear the tenant search index and re-inject every record").option("--yes", "reindex without confirmation").action(async (opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error(
+        'A full reindex clears the index before refilling it. Re-run with "--yes" to confirm.'
+      );
+    }
+    const tenant = requireTenant(
+      cmd,
+      'A full reindex names its tenant explicitly. Pass "--tenant <id>" with the tenant you are authenticated in.'
+    );
+    const client = getClientFromCommand(cmd);
+    await client.post("/admin/search/full-reindex", { tenantId: tenant });
+    process.stdout.write(
+      `${chalk9.green("\u2713")} Full reindex accepted for tenant ${tenant}. It runs in the background \u2014 follow the server logs for progress.
+`
+    );
+  });
+}
+
+// src/commands/sources.ts
+function registerSourcesCommand(program) {
+  const sources = program.command("sources").description("Inspect and remove remote schema sources on the current tenant");
+  sources.command("list").description("List remote schema sources: id, hash, last apply, object names").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/schema/sources");
+    formatOutput(result, getFormat(cmd));
+  });
+  sources.command("remove").description(
+    "Remove a remote schema source: its objects are demoted to custom, records are kept"
+  ).argument("<sourceId>", "source id declared in code").option("--yes", "remove without confirmation").action(async (sourceId, opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Removing a schema source is explicit. Re-run with "--yes" to confirm.');
+    }
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/schema/sources/${sourceId}`);
+    formatOutput({ removed: sourceId }, getFormat(cmd));
+  });
+}
+
 // src/program.ts
 var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help"]);
 function isPublicCommand(actionCommand) {
@@ -507,13 +1845,25 @@ function isPublicCommand(actionCommand) {
 }
 function createProgram() {
   const program = new Command();
-  program.name("standards").description("CLI to interact with Standards API").version("1.0.0-alpha.3").option("--format <format>", "output format (json, table, csv)", "json").option("--api-url <url>", "API base URL").option("--api-key <key>", "API key for authentication").option("--instance <name>", "Standards instance profile to use");
+  program.name("standards").description("CLI to interact with Standards API").version("1.0.0-alpha.139").option("--format <format>", "output format (json, table, csv)", "json").option("--api-url <url>", "API base URL").option("--api-key <key>", "API key for authentication").option("--instance <name>", "Standards instance profile to use").option("--tenant <id>", "Tenant ID (multi-tenant setups, defaults to primary tenant)");
   registerRootCommands(program);
   registerRecordsCommand(program);
   registerSchemaCommand(program);
+  registerPullCommand(program);
   registerDocumentsCommand(program);
+  registerDeviceCommand(program);
+  registerFoldersCommand(program);
   registerKeysCommand(program);
   registerAuthCommand(program);
+  registerBundlesCommand(program);
+  registerSourcesCommand(program);
+  registerConnectorsCommand(program);
+  registerMcpCommand(program);
+  registerMeetingsCommand(program);
+  registerSearchCommand(program);
+  registerEmbeddingsCommand(program);
+  registerAiCommand(program);
+  registerQuotasCommand(program);
   program.hook("preAction", async (_thisCommand, actionCommand) => {
     const raw = program.opts();
     const resolved = await resolveCliConfig({
@@ -524,13 +1874,14 @@ function createProgram() {
     program.setOptionValue("apiUrl", resolved.apiUrl);
     program.setOptionValue("apiKey", resolved.apiKey);
     program.setOptionValue("profileName", resolved.profileName);
+    program.setOptionValue("tenant", raw.tenant);
     if (!(resolved.apiKey || isPublicCommand(actionCommand))) {
       console.error(
-        chalk5.red(
+        chalk10.red(
           `\u2717 Error: No Standards instance configured. Run "standards login" or pass --api-key.`
         )
       );
-      process.exit(1);
+      process.exit(2);
     }
   });
   return program;
@@ -539,13 +1890,13 @@ async function runProgram(argv = process.argv) {
   const program = createProgram();
   await program.parseAsync(argv).catch((error) => {
     if (error instanceof ApiClientError) {
-      if (error.statusCode > 0) {
-        console.error(chalk5.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
+      if (error.status > 0) {
+        console.error(chalk10.red(`\u2717 Error (${error.status}): ${error.message}`));
       } else {
-        console.error(chalk5.red(`\u2717 Error: ${error.message}`));
+        console.error(chalk10.red(`\u2717 Error: ${error.message}`));
       }
     } else if (error instanceof Error) {
-      console.error(chalk5.red(`\u2717 Error: ${error.message}`));
+      console.error(chalk10.red(`\u2717 Error: ${error.message}`));
     }
     process.exit(1);
   });