@syndicalt/snow-cli 1.0.0 → 1.5.0

package/dist/index.js

@@ -202,7 +202,7 @@ var init_client = __esm({
                   const retryAfterHeader = err.response?.headers["retry-after"];
                   const baseDelay = 1e3 * Math.pow(2, config._retryCount - 1);
                   const delayMs = retryAfterHeader ? Math.max(parseInt(String(retryAfterHeader), 10) * 1e3, baseDelay) : baseDelay;
-                  await new Promise((resolve) => setTimeout(resolve, delayMs));
+                  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
                   return this.http.request(config);
                 }
                 const detail2 = err.response?.data?.error?.message ?? err.message;
@@ -321,8 +321,8 @@ Hint: PDI instances have lower transaction quotas. Wait a moment then retry, or
 
 // src/index.ts
 init_esm_shims();
-import { Command as Command7 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
 
 // src/commands/instance.ts
 init_esm_shims();
@@ -517,8 +517,8 @@ function printRecords(records, format) {
     return;
   }
   const naturalWidths = keys.map((k) => {
-    const maxVal = rows.reduce((max, row) => {
-      return Math.max(max, flattenValue(row[k]).length);
+    const maxVal = rows.reduce((max, row2) => {
+      return Math.max(max, flattenValue(row2[k]).length);
     }, k.length);
     return Math.min(maxVal, 60);
   });
@@ -528,9 +528,9 @@ function printRecords(records, format) {
   const divider = chalk2.dim(colWidths.map((w) => "\u2500".repeat(w)).join("  "));
   console.log(header);
   console.log(divider);
-  for (const row of rows) {
+  for (const row2 of rows) {
     const line = keys.map((k, i) => {
-      const val = flattenValue(row[k]);
+      const val = flattenValue(row2[k]);
       return val.length > colWidths[i] ? val.slice(0, colWidths[i] - 1) + "\u2026" : val.padEnd(colWidths[i]);
     }).join("  ");
     console.log(line);
@@ -631,8 +631,8 @@ function tableCommand() {
   );
   cmd.command("delete <table> <sys_id>").description("Delete a record").option("-y, --yes", "Skip confirmation prompt").action(async (table, sysId, opts) => {
     if (!opts.yes) {
-      const { confirm: confirm2 } = await import("@inquirer/prompts");
-      const ok = await confirm2({
+      const { confirm: confirm6 } = await import("@inquirer/prompts");
+      const ok = await confirm6({
         message: `Delete ${table}/${sysId}?`,
         default: false
       });
@@ -663,82 +663,653 @@ init_client();
 import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
 import ora2 from "ora";
-function schemaCommand() {
-  return new Command3("schema").description("Retrieve the field schema for a ServiceNow table").argument("<table>", "Table name (e.g. incident, sys_user)").option("--format <fmt>", "Output format: table or json", "table").option("-f, --filter <text>", "Filter fields by name or label (case-insensitive)").action(
-    async (table, opts) => {
-      const instance = requireActiveInstance();
-      const client = new ServiceNowClient(instance);
-      const spinner = ora2(`Loading schema for ${table}...`).start();
-      try {
-        const res = await client.get(
-          "/api/now/table/sys_dictionary",
-          {
-            params: {
-              sysparm_query: `name=${table}^elementISNOTEMPTY`,
-              sysparm_fields: "element,column_label,internal_type,max_length,mandatory,read_only,reference,default_value,comments",
-              sysparm_display_value: "all",
-              sysparm_limit: 500,
-              sysparm_exclude_reference_link: true
-            }
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, resolve } from "path";
+
+// src/lib/llm.ts
+init_esm_shims();
+import axios2 from "axios";
+var OpenAIProvider = class {
+  constructor(apiKey, model, baseUrl = "https://api.openai.com/v1", name = "openai") {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.baseUrl = baseUrl;
+    this.providerName = name;
+  }
+  providerName;
+  async complete(messages) {
+    const res = await axios2.post(
+      `${this.baseUrl.replace(/\/$/, "")}/chat/completions`,
+      { model: this.model, messages },
+      {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 12e4
+      }
+    );
+    const content = res.data.choices[0]?.message.content;
+    if (!content) throw new Error("LLM returned an empty response");
+    return content;
+  }
+};
+var AnthropicProvider = class {
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  providerName = "anthropic";
+  async complete(messages) {
+    const system = messages.find((m) => m.role === "system")?.content;
+    const conversation = messages.filter((m) => m.role !== "system");
+    const res = await axios2.post(
+      "https://api.anthropic.com/v1/messages",
+      {
+        model: this.model,
+        max_tokens: 8192,
+        ...system ? { system } : {},
+        messages: conversation
+      },
+      {
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01",
+          "Content-Type": "application/json"
+        },
+        timeout: 12e4
+      }
+    );
+    const text = res.data.content.find((c) => c.type === "text")?.text;
+    if (!text) throw new Error("Anthropic returned an empty response");
+    return text;
+  }
+};
+var OllamaProvider = class {
+  constructor(model, baseUrl = "http://localhost:11434") {
+    this.model = model;
+    this.baseUrl = baseUrl;
+  }
+  providerName = "ollama";
+  async complete(messages) {
+    const res = await axios2.post(
+      `${this.baseUrl.replace(/\/$/, "")}/api/chat`,
+      { model: this.model, messages, stream: false },
+      { headers: { "Content-Type": "application/json" }, timeout: 3e5 }
+    );
+    const content = res.data.message.content;
+    if (!content) throw new Error("Ollama returned an empty response");
+    return content;
+  }
+};
+function buildProvider(name, model, apiKey, baseUrl) {
+  switch (name) {
+    case "anthropic":
+      if (!apiKey) throw new Error("Anthropic provider requires an API key (https://platform.claude.com/)");
+      return new AnthropicProvider(apiKey, model);
+    case "xai":
+      if (!apiKey) throw new Error("xAI provider requires an API key (https://platform.x.ai/)");
+      return new OpenAIProvider(
+        apiKey,
+        model,
+        baseUrl ?? "https://api.x.ai/v1",
+        "xai"
+      );
+    case "ollama":
+      return new OllamaProvider(model, baseUrl);
+    case "openai":
+    default:
+      if (!apiKey) throw new Error("OpenAI provider requires an API key (https://platform.openai.com/)");
+      return new OpenAIProvider(apiKey, model, baseUrl, name);
+  }
+}
+function extractJSON(raw) {
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenced) return fenced[1].trim();
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start !== -1 && end !== -1) return raw.slice(start, end + 1);
+  return raw.trim();
+}
+
+// src/commands/schema.ts
+async function fetchInboundReferences(client, tableName) {
+  const res = await client.get(
+    "/api/now/table/sys_dictionary",
+    {
+      params: {
+        sysparm_query: `internal_type=reference^reference=${tableName}^elementISNOTEMPTY`,
+        sysparm_fields: "name,element,column_label",
+        sysparm_display_value: "all",
+        sysparm_limit: 100,
+        sysparm_exclude_reference_link: true
+      }
+    }
+  );
+  return (res.result ?? []).map((e) => ({
+    refTable: e.name?.value ?? "",
+    fieldName: e.element?.value ?? "",
+    fieldLabel: e.column_label?.display_value ?? ""
+  })).filter((r) => r.refTable && r.fieldName);
+}
+async function fetchTableFields(client, tableName) {
+  const res = await client.get(
+    "/api/now/table/sys_dictionary",
+    {
+      params: {
+        sysparm_query: `name=${tableName}^elementISNOTEMPTY`,
+        sysparm_fields: "element,column_label,internal_type,max_length,mandatory,reference",
+        sysparm_display_value: "all",
+        sysparm_limit: 500,
+        sysparm_exclude_reference_link: true
+      }
+    }
+  );
+  return (res.result ?? []).map((e) => ({
+    name: e.element?.value ?? "",
+    label: e.column_label?.display_value ?? "",
+    type: e.internal_type?.value ?? "string",
+    maxLength: e.max_length?.value ? parseInt(e.max_length.value, 10) : void 0,
+    mandatory: e.mandatory?.value === "true",
+    reference: e.reference?.value || void 0
+  })).filter((f) => f.name);
+}
+async function fetchTableMeta(client, tableName) {
+  try {
+    const res = await client.get("/api/now/table/sys_db_object", {
+      params: {
+        sysparm_query: `name=${tableName}`,
+        sysparm_fields: "label,sys_scope",
+        sysparm_display_value: "all",
+        sysparm_limit: 1
+      }
+    });
+    if (res.result?.length > 0) {
+      return {
+        label: res.result[0].label?.display_value || tableName,
+        scope: res.result[0].sys_scope?.display_value || "Global"
+      };
+    }
+  } catch {
+  }
+  return { label: tableName, scope: "Global" };
+}
+async function crawlSchema(client, rootTable, maxDepth, showM2m, showInbound, onProgress) {
+  const tables = /* @__PURE__ */ new Map();
+  const edges = [];
+  const queue = [{ table: rootTable, depth: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { table, depth } = queue.shift();
+    if (visited.has(table)) continue;
+    visited.add(table);
+    onProgress(`  [depth ${depth}] ${table}`);
+    const [fields, { label, scope }] = await Promise.all([
+      fetchTableFields(client, table),
+      fetchTableMeta(client, table)
+    ]);
+    tables.set(table, { name: table, label, scope, fields });
+    if (depth < maxDepth) {
+      for (const field of fields) {
+        const isRef = field.type === "reference" && field.reference;
+        const isM2m = showM2m && field.type === "glide_list" && field.reference;
+        if (isRef || isM2m) {
+          const target = field.reference;
+          const alreadyEdge = edges.some((e) => e.from === table && e.field === field.name);
+          if (!alreadyEdge) {
+            edges.push({
+              from: table,
+              field: field.name,
+              fieldLabel: field.label,
+              to: target,
+              type: isRef ? "reference" : "glide_list"
+            });
+          }
+          if (!visited.has(target)) {
+            queue.push({ table: target, depth: depth + 1 });
           }
-        );
-        spinner.stop();
-        let entries = res.result ?? [];
-        if (opts.filter) {
-          const filterLower = opts.filter.toLowerCase();
-          entries = entries.filter(
-            (e) => e.element?.value?.toLowerCase().includes(filterLower) || e.column_label?.display_value?.toLowerCase().includes(filterLower)
-          );
         }
-        if (entries.length === 0) {
-          console.log(chalk3.dim(`No fields found for table "${table}".`));
-          return;
+      }
+      if (showInbound) {
+        const inbound = await fetchInboundReferences(client, table);
+        for (const { refTable, fieldName, fieldLabel } of inbound) {
+          const alreadyEdge = edges.some((e) => e.from === refTable && e.field === fieldName);
+          if (!alreadyEdge) {
+            edges.push({ from: refTable, field: fieldName, fieldLabel, to: table, type: "reference" });
+          }
+          if (!visited.has(refTable)) {
+            queue.push({ table: refTable, depth: depth + 1 });
+          }
         }
-        if (opts.format === "json") {
-          const mapped = entries.map((e) => ({
-            name: e.element?.value,
-            label: e.column_label?.display_value,
-            type: e.internal_type?.value,
-            maxLength: e.max_length?.value ? parseInt(e.max_length.value, 10) : void 0,
-            mandatory: e.mandatory?.value === "true",
-            readOnly: e.read_only?.value === "true",
-            reference: e.reference?.value || void 0,
-            defaultValue: e.default_value?.value || void 0,
-            comments: e.comments?.value || void 0
-          }));
-          console.log(JSON.stringify(mapped, null, 2));
-          return;
+      }
+    }
+  }
+  return { tables, edges, enums: /* @__PURE__ */ new Map() };
+}
+async function fetchChoiceValues(client, tableName, fieldName) {
+  try {
+    const res = await client.get("/api/now/table/sys_choice", {
+      params: {
+        sysparm_query: `name=${tableName}^element=${fieldName}^language=en^inactive=false`,
+        sysparm_fields: "value,label",
+        sysparm_display_value: "all",
+        sysparm_limit: 100,
+        sysparm_orderby: "sequence"
+      }
+    });
+    return (res.result ?? []).map((e) => ({ value: e.value?.value ?? "", label: e.label?.display_value ?? "" })).filter((e) => e.value !== "");
+  } catch {
+    return [];
+  }
+}
+async function fetchAllEnums(client, tables, onProgress) {
+  const pairs = [];
+  for (const [, node] of tables) {
+    for (const f of node.fields) {
+      if (f.type === "choice") pairs.push({ table: node.name, field: f.name });
+    }
+  }
+  onProgress(`  Fetching choices for ${pairs.length} choice field(s)\u2026`);
+  const enums = /* @__PURE__ */ new Map();
+  const CHUNK = 5;
+  for (let i = 0; i < pairs.length; i += CHUNK) {
+    const chunk = pairs.slice(i, i + CHUNK);
+    const results = await Promise.all(
+      chunk.map(({ table, field }) => fetchChoiceValues(client, table, field))
+    );
+    for (let j = 0; j < chunk.length; j++) {
+      if (results[j].length > 0) {
+        enums.set(`${chunk[j].table}__${chunk[j].field}`, results[j]);
+      }
+    }
+  }
+  return enums;
+}
+var MAX_EXPLAIN_CHARS = 12e3;
+async function explainSchema(graph, schemaContent, rootTable, fmt) {
+  const activeProvider = getActiveProvider();
+  if (!activeProvider) {
+    throw new Error("No AI provider configured. Run `snow provider set` to configure one.");
+  }
+  const llm = buildProvider(
+    activeProvider.name,
+    activeProvider.config.model,
+    activeProvider.config.apiKey,
+    activeProvider.config.baseUrl
+  );
+  const scopes = collectScopes(graph);
+  const scopeList = [...scopes.keys()].join(", ");
+  const truncated = schemaContent.length > MAX_EXPLAIN_CHARS;
+  const schemaSnippet = truncated ? schemaContent.slice(0, MAX_EXPLAIN_CHARS) + "\n... (truncated)" : schemaContent;
+  const messages = [
+    {
+      role: "system",
+      content: `You are a ServiceNow architect and data modeler. When given a schema map, provide a clear, practical explanation covering:
+1. The business domain this data model represents
+2. Key tables and their purpose (focus on the most important ones)
+3. Notable relationships \u2014 references, M2M links, self-referencing tables, hierarchies
+4. Any cross-scope dependencies that developers should be aware of
+5. A one-line summary suitable for documentation
+
+Be concise and practical. Assume the reader is a developer working with this schema. Format your response in Markdown.`
+    },
+    {
+      role: "user",
+      content: `Explain this ServiceNow schema map for table \`${rootTable}\` (${graph.tables.size} tables, scopes: ${scopeList}). Format: ${fmt.toUpperCase()}${truncated ? " [schema truncated]" : ""}
+
+\`\`\`
+${schemaSnippet}
+\`\`\``
+    }
+  ];
+  return llm.complete(messages);
+}
+var MERMAID_TYPES = {
+  integer: "int",
+  long: "bigint",
+  float: "float",
+  decimal: "float",
+  currency: "float",
+  boolean: "boolean",
+  date: "date",
+  glide_date: "date",
+  glide_date_time: "datetime",
+  reference: "string",
+  glide_list: "string"
+};
+var DBML_TYPES = {
+  integer: "int",
+  long: "bigint",
+  float: "float",
+  decimal: "decimal(15,4)",
+  currency: "decimal(15,2)",
+  boolean: "boolean",
+  date: "date",
+  glide_date: "date",
+  glide_date_time: "datetime",
+  reference: "varchar(32)",
+  glide_list: "text",
+  choice: "varchar(40)",
+  script: "text",
+  html: "text",
+  url: "varchar(1024)",
+  email: "varchar(255)",
+  phone_number: "varchar(40)"
+};
+function toMermaidType(t) {
+  return MERMAID_TYPES[t] ?? "string";
+}
+function toDBMLType(t) {
+  return DBML_TYPES[t] ?? "varchar(255)";
+}
+function collectScopes(graph) {
+  const scopes = /* @__PURE__ */ new Map();
+  for (const [, node] of graph.tables) {
+    const s = node.scope || "Global";
+    if (!scopes.has(s)) scopes.set(s, []);
+    scopes.get(s).push(node.name);
+  }
+  return scopes;
+}
+function collectStubTables(graph) {
+  const stubs = /* @__PURE__ */ new Set();
+  for (const [, node] of graph.tables) {
+    for (const f of node.fields) {
+      if (f.reference && !graph.tables.has(f.reference)) {
+        stubs.add(f.reference);
+      }
+    }
+  }
+  return stubs;
+}
+function renderMermaid(graph, rootTable) {
+  const scopes = collectScopes(graph);
+  const scopeSummary = [...scopes.entries()].map(([s, tables]) => `${s} (${tables.length})`).join(", ");
+  const lines = [
+    `---`,
+    `title: Schema map \u2014 ${rootTable}`,
+    `---`,
+    `erDiagram`,
+    ``,
+    `  %% Scopes: ${scopeSummary}`,
+    ...scopes.size > 1 ? [`  %% Warning: tables from ${scopes.size} scopes \u2014 cross-scope references present`] : []
+  ];
+  for (const [, node] of graph.tables) {
+    lines.push(`  ${node.name} {`);
+    for (const f of node.fields) {
+      if (f.type === "glide_list") continue;
+      const mType = toMermaidType(f.type);
+      const note = f.mandatory ? ' "M"' : "";
+      lines.push(`    ${mType} ${f.name}${note}`);
+    }
+    lines.push(`  }`);
+  }
+  lines.push("");
+  for (const edge of graph.edges) {
+    if (!graph.tables.has(edge.to)) continue;
+    const rel = edge.type === "glide_list" ? `}o--o{` : `}o--||`;
+    const safeLabel = edge.fieldLabel.replace(/"/g, "'");
+    lines.push(`  ${edge.from} ${rel} ${edge.to} : "${safeLabel}"`);
+  }
+  const stubs = collectStubTables(graph);
+  if (stubs.size > 0) {
+    lines.push("");
+    lines.push(`  %% Stub tables \u2014 referenced but not crawled (increase --depth to explore)`);
+    for (const stubName of [...stubs].sort()) {
+      lines.push(`  ${stubName} {`);
+      lines.push(`    string sys_id`);
+      lines.push(`  }`);
+    }
+    for (const [, node] of graph.tables) {
+      for (const f of node.fields) {
+        if (f.reference && stubs.has(f.reference)) {
+          const rel = f.type === "glide_list" ? `}o--o{` : `}o--||`;
+          const safeLabel = f.label.replace(/"/g, "'");
+          lines.push(`  ${node.name} ${rel} ${f.reference} : "${safeLabel}"`);
+        }
+      }
+    }
+  }
+  if (graph.enums.size > 0) {
+    lines.push("");
+    lines.push(`  %% Choice field enums`);
+    for (const [key, values] of graph.enums) {
+      const valStr = values.map((v) => `${v.value}=${v.label}`).join(", ");
+      lines.push(`  %% ${key}: ${valStr}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderDBML(graph, rootTable) {
+  const scopes = collectScopes(graph);
+  const scopeSummary = [...scopes.entries()].map(([s, tables]) => `${s} (${tables.length})`).join(", ");
+  const lines = [
+    `// Schema map \u2014 ${rootTable}`,
+    `// Generated by @syndicalt/snow-cli`,
+    `// Scopes: ${scopeSummary}`,
+    ...scopes.size > 1 ? [`// Warning: tables from ${scopes.size} scopes \u2014 cross-scope references present`] : [],
+    ""
+  ];
+  for (const [, node] of graph.tables) {
+    const safeLabel = node.label.replace(/'/g, "\\'");
+    const safeScope = node.scope.replace(/'/g, "\\'");
+    const safeNote = node.scope && node.scope !== "Global" ? `${safeLabel} | scope: ${safeScope}` : safeLabel;
+    lines.push(`Table ${node.name} [note: '${safeNote}'] {`);
+    for (const f of node.fields) {
+      const enumKey = `${node.name}__${f.name}`;
+      const dbType = f.type === "choice" && graph.enums.has(enumKey) ? enumKey : toDBMLType(f.type);
+      const annots = [];
+      if (f.name === "sys_id") annots.push("pk");
+      if (f.mandatory) annots.push("not null");
+      if (f.type === "reference" && f.reference) annots.push(`ref: > ${f.reference}.sys_id`);
+      const annotStr = annots.length ? ` [${annots.join(", ")}]` : "";
+      lines.push(`  ${f.name} ${dbType}${annotStr}`);
+    }
+    lines.push(`}`);
+    lines.push("");
+  }
+  for (const edge of graph.edges) {
+    if (edge.type === "glide_list" && graph.tables.has(edge.to)) {
+      lines.push(`Ref: ${edge.from}.${edge.field} <> ${edge.to}.sys_id // ${edge.fieldLabel}`);
+    }
+  }
+  const stubs = collectStubTables(graph);
+  if (stubs.size > 0) {
+    lines.push("");
+    lines.push(`// Placeholder tables \u2014 referenced but not crawled (increase --depth to explore)`);
+    for (const stubName of [...stubs].sort()) {
+      lines.push(`Table ${stubName} [note: 'not crawled'] {`);
+      lines.push(`  sys_id varchar(32) [pk]`);
+      lines.push(`}`);
+      lines.push("");
+    }
+  }
+  if (graph.enums.size > 0) {
+    lines.push("");
+    lines.push(`// Choice field enums`);
+    for (const [key, values] of graph.enums) {
+      lines.push(`Enum ${key} {`);
+      for (const v of values) {
+        const safeNote = v.label.replace(/'/g, "\\'");
+        lines.push(`  "${v.value}" [note: '${safeNote}']`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function schemaShowCommand() {
+  return new Command3("show").description("Show field schema for a ServiceNow table").argument("<table>", "Table name (e.g. incident, sys_user)").option("--format <fmt>", "Output format: table or json", "table").option("-f, --filter <text>", "Filter fields by name or label (case-insensitive)").action(async (table, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora2(`Loading schema for ${table}...`).start();
+    try {
+      const res = await client.get(
+        "/api/now/table/sys_dictionary",
+        {
+          params: {
+            sysparm_query: `name=${table}^elementISNOTEMPTY`,
+            sysparm_fields: "element,column_label,internal_type,max_length,mandatory,read_only,reference,default_value,comments",
+            sysparm_display_value: "all",
+            sysparm_limit: 500,
+            sysparm_exclude_reference_link: true
+          }
         }
-        console.log(chalk3.bold(`
+      );
+      spinner.stop();
+      let entries = res.result ?? [];
+      if (opts.filter) {
+        const filterLower = opts.filter.toLowerCase();
+        entries = entries.filter(
+          (e) => e.element?.value?.toLowerCase().includes(filterLower) || e.column_label?.display_value?.toLowerCase().includes(filterLower)
+        );
+      }
+      if (entries.length === 0) {
+        console.log(chalk3.dim(`No fields found for table "${table}".`));
+        return;
+      }
+      if (opts.format === "json") {
+        const mapped = entries.map((e) => ({
+          name: e.element?.value,
+          label: e.column_label?.display_value,
+          type: e.internal_type?.value,
+          maxLength: e.max_length?.value ? parseInt(e.max_length.value, 10) : void 0,
+          mandatory: e.mandatory?.value === "true",
+          readOnly: e.read_only?.value === "true",
+          reference: e.reference?.value || void 0,
+          defaultValue: e.default_value?.value || void 0,
+          comments: e.comments?.value || void 0
+        }));
+        console.log(JSON.stringify(mapped, null, 2));
+        return;
+      }
+      console.log(chalk3.bold(`
 Schema for ${chalk3.cyan(table)} (${entries.length} fields)
 `));
-        const colWidths = { name: 30, label: 30, type: 20, extra: 20 };
-        const header = [
-          "Field Name".padEnd(colWidths.name),
-          "Label".padEnd(colWidths.label),
-          "Type".padEnd(colWidths.type),
-          "Flags"
-        ].join("  ");
-        console.log(chalk3.bold(header));
-        console.log(chalk3.dim("-".repeat(header.length)));
-        for (const e of entries) {
-          const name = (e.element?.value ?? "").slice(0, colWidths.name).padEnd(colWidths.name);
-          const label = (e.column_label?.display_value ?? "").slice(0, colWidths.label).padEnd(colWidths.label);
-          const type = (e.internal_type?.value ?? "").slice(0, colWidths.type).padEnd(colWidths.type);
-          const flags = [];
-          if (e.mandatory?.value === "true") flags.push(chalk3.red("M"));
-          if (e.read_only?.value === "true") flags.push(chalk3.yellow("R"));
-          if (e.reference?.value) flags.push(chalk3.blue(`ref:${e.reference.value}`));
-          console.log(`${name}  ${label}  ${type}  ${flags.join(" ")}`);
+      const colWidths = { name: 30, label: 30, type: 20 };
+      const header = [
+        "Field Name".padEnd(colWidths.name),
+        "Label".padEnd(colWidths.label),
+        "Type".padEnd(colWidths.type),
+        "Flags"
+      ].join("  ");
+      console.log(chalk3.bold(header));
+      console.log(chalk3.dim("-".repeat(header.length)));
+      for (const e of entries) {
+        const name = (e.element?.value ?? "").slice(0, colWidths.name).padEnd(colWidths.name);
+        const label = (e.column_label?.display_value ?? "").slice(0, colWidths.label).padEnd(colWidths.label);
+        const type = (e.internal_type?.value ?? "").slice(0, colWidths.type).padEnd(colWidths.type);
+        const flags = [];
+        if (e.mandatory?.value === "true") flags.push(chalk3.red("M"));
+        if (e.read_only?.value === "true") flags.push(chalk3.yellow("R"));
+        if (e.reference?.value) flags.push(chalk3.blue(`ref:${e.reference.value}`));
+        console.log(`${name}  ${label}  ${type}  ${flags.join(" ")}`);
+      }
+      console.log(chalk3.dim("\nFlags: M=mandatory  R=read-only  ref=reference table"));
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+}
+function schemaMapCommand() {
+  return new Command3("map").description("Crawl table references and generate a Mermaid or DBML schema map").argument("<table>", "Root table to start from (e.g. incident, x_myapp_request)").option("-d, --depth <n>", "Levels of references to follow", "2").option("--show-m2m", "Include glide_list fields as M2M relationships", false).option("--format <fmt>", "Output format: mermaid or dbml", "mermaid").option("--out <dir>", "Directory to write the output file", ".").option("--name <name>", "Base filename for the output file (default: <table>-schema)").option("--inbound", "Also crawl tables that reference this table (inbound references)", false).option("--enums", "Fetch choice field values and emit Enum blocks (DBML) or comments (Mermaid)", false).option("--explain", "Use the active AI provider to explain the schema in plain English", false).action(async (table, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const depth = Math.max(0, parseInt(opts.depth, 10) || 2);
+    const fmt = opts.format === "dbml" ? "dbml" : "mermaid";
+    console.log(
+      chalk3.bold(`
+Building schema map for ${chalk3.cyan(table)}`),
+      chalk3.dim(`(depth: ${depth}, m2m: ${opts.showM2m}, inbound: ${opts.inbound}, format: ${fmt})
+`)
+    );
+    if (opts.inbound && depth > 1) {
+      console.log(chalk3.yellow(
+        `  Advisory: --inbound with depth ${depth} can produce very large graphs for highly-referenced tables. Consider --depth 1 if the result is too large.
+`
+      ));
+    }
+    const spinner = ora2("Crawling\u2026").start();
+    try {
+      const graph = await crawlSchema(
+        client,
+        table,
+        depth,
+        opts.showM2m,
+        opts.inbound,
+        (msg) => {
+          spinner.text = msg;
+        }
+      );
+      if (opts.enums) {
+        spinner.start("Fetching choice field values\u2026");
+        graph.enums = await fetchAllEnums(client, graph.tables, (msg) => {
+          spinner.text = msg;
+        });
+        spinner.stop();
+      } else {
+        spinner.stop();
+      }
+      const output = fmt === "dbml" ? renderDBML(graph, table) : renderMermaid(graph, table);
+      const ext = fmt === "dbml" ? ".dbml" : ".mmd";
+      const baseName = opts.name ?? `${table}-schema`;
+      const outDir = resolve(opts.out);
+      mkdirSync2(outDir, { recursive: true });
+      const outFile = join2(outDir, `${baseName}${ext}`);
+      writeFileSync2(outFile, output, "utf8");
+      const tableCount = graph.tables.size;
+      if (tableCount > 50) {
+        console.log(chalk3.yellow(
+          `
+  Warning: large graph (${tableCount} tables). Diagrams may be hard to read. Consider reducing --depth or scoping to a smaller root table.`
+        ));
+      }
+      const edgeCount = graph.edges.filter((e) => graph.tables.has(e.to)).length;
+      const m2mCount = graph.edges.filter((e) => e.type === "glide_list" && graph.tables.has(e.to)).length;
+      console.log(chalk3.green(`
+Schema map written to ${outFile}`));
+      const enumCount = graph.enums.size;
+      console.log(chalk3.dim(
+        `${tableCount} table${tableCount !== 1 ? "s" : ""}, ${edgeCount - m2mCount} reference${edgeCount - m2mCount !== 1 ? "s" : ""}` + (m2mCount ? `, ${m2mCount} M2M link${m2mCount !== 1 ? "s" : ""}` : "") + (enumCount ? `, ${enumCount} enum${enumCount !== 1 ? "s" : ""}` : "")
+      ));
+      if (fmt === "mermaid") {
+        console.log(chalk3.dim("\nOpen the .mmd file in any Mermaid viewer, or paste into https://mermaid.live"));
+      } else {
+        console.log(chalk3.dim("\nOpen the .dbml file in https://dbdiagram.io or any DBML-compatible tool"));
+      }
+      if (opts.explain) {
+        const explainSpinner = ora2("Generating AI explanation\u2026").start();
+        try {
+          const explanation = await explainSchema(graph, output, table, fmt);
+          explainSpinner.stop();
+          const explainFile = join2(outDir, `${baseName}.explanation.md`);
+          writeFileSync2(explainFile, explanation, "utf8");
+          console.log(chalk3.green(`
+Explanation saved to ${explainFile}`));
+          console.log("\n" + explanation);
+        } catch (err) {
+          explainSpinner.stop();
+          console.log(chalk3.yellow(
+            `
+Note: AI explanation failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+          ));
         }
-        console.log(chalk3.dim("\nFlags: M=mandatory  R=read-only  ref=reference table"));
-      } catch (err) {
-        spinner.fail();
-        console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
-        process.exit(1);
       }
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
     }
-  );
+  });
+}
+function schemaCommand() {
+  const cmd = new Command3("schema").description("Schema inspection and mapping");
+  cmd.addCommand(schemaShowCommand(), { isDefault: true });
+  cmd.addCommand(schemaMapCommand());
+  return cmd;
 }
 
 // src/commands/script.ts
@@ -746,12 +1317,23 @@ init_esm_shims();
 init_config();
 init_client();
 import { Command as Command4 } from "commander";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync2, readdirSync, statSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { spawnSync } from "child_process";
 import chalk4 from "chalk";
 import ora3 from "ora";
+import { confirm as confirm2 } from "@inquirer/prompts";
+var SCRIPT_TABLES = [
+  { table: "sys_script_include", field: "script", label: "Script Include" },
+  { table: "sys_script", field: "script", label: "Business Rule" },
+  { table: "sys_script_client", field: "script", label: "Client Script" },
+  { table: "sys_ui_action", field: "script", label: "UI Action" },
+  { table: "sys_ui_page", field: "html", label: "UI Page (HTML)" },
+  { table: "sys_ui_page", field: "client_script", label: "UI Page (Client)" },
+  { table: "sys_ui_page", field: "processing_script", label: "UI Page (Server)" },
+  { table: "sysauto_script", field: "script", label: "Scheduled Job" }
+];
 function extensionForField(fieldName, fieldType) {
   if (fieldType === "html" || fieldName.endsWith("_html")) return ".html";
   if (fieldType === "css" || fieldName === "css") return ".css";
@@ -797,12 +1379,12 @@ function scriptCommand() {
       if (opts.out) {
         filePath = opts.out;
       } else {
-        const dir = join2(homedir2(), ".snow", "scripts");
-        if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+        const dir = join3(homedir2(), ".snow", "scripts");
+        if (!existsSync2(dir)) mkdirSync3(dir, { recursive: true });
         const safeName = `${table}_${sysId}_${field}`.replace(/[^a-z0-9_-]/gi, "_");
-        filePath = join2(dir, `${safeName}${extensionForField(field)}`);
+        filePath = join3(dir, `${safeName}${extensionForField(field)}`);
       }
-      writeFileSync2(filePath, content, "utf-8");
+      writeFileSync3(filePath, content, "utf-8");
       console.log(chalk4.green(`Saved to: ${filePath}`));
       if (opts.open === false) return;
       const editor = resolveEditor(opts.editor);
@@ -815,8 +1397,8 @@ function scriptCommand() {
         console.error(chalk4.red(`Editor exited with code ${result.status ?? "?"}`));
         process.exit(result.status ?? 1);
       }
-      const { confirm: confirm2 } = await import("@inquirer/prompts");
-      const shouldPush = await confirm2({
+      const { confirm: confirm6 } = await import("@inquirer/prompts");
+      const shouldPush = await confirm6({
         message: `Push changes to ${instance.alias}?`,
         default: true
       });
@@ -834,9 +1416,9 @@ function scriptCommand() {
     if (file) {
       filePath = file;
     } else {
-      const dir = join2(homedir2(), ".snow", "scripts");
+      const dir = join3(homedir2(), ".snow", "scripts");
       const safeName = `${table}_${sysId}_${field}`.replace(/[^a-z0-9_-]/gi, "_");
-      filePath = join2(dir, `${safeName}${extensionForField(field)}`);
+      filePath = join3(dir, `${safeName}${extensionForField(field)}`);
     }
     if (!existsSync2(filePath)) {
       console.error(chalk4.red(`File not found: ${filePath}`));
@@ -846,7 +1428,7 @@ function scriptCommand() {
     await pushScript(client, table, sysId, field, filePath);
   });
   cmd.command("list").alias("ls").description("List locally cached script files").action(() => {
-    const dir = join2(homedir2(), ".snow", "scripts");
+    const dir = join3(homedir2(), ".snow", "scripts");
     if (!existsSync2(dir)) {
       console.log(chalk4.dim("No scripts cached yet. Run `snow script pull` first."));
       return;
@@ -857,18 +1439,160 @@ function scriptCommand() {
       return;
     }
     for (const f of files) {
-      const stat = statSync(join2(dir, f));
+      const stat = statSync(join3(dir, f));
       const modified = stat.mtime.toLocaleString();
       console.log(`${chalk4.cyan(f)}  ${chalk4.dim(modified)}`);
     }
   });
-  return cmd;
-}
-async function pushScript(client, table, sysId, field, filePath) {
-  const content = readFileSync2(filePath, "utf-8");
-  const spinner = ora3(`Pushing to ${table}/${sysId} field "${field}"...`).start();
-  try {
-    await client.updateRecord(table, sysId, { [field]: content });
+  cmd.command("search <scope>").description("Search for a pattern across script fields in an app scope").requiredOption("-c, --contains <pattern>", "Text or regex pattern to search for").option("-t, --tables <tables>", "Comma-separated list of tables to search (default: all script tables)").option("--regex", "Treat --contains as a JavaScript regex").option("-l, --limit <n>", "Max records to fetch per table (default: 500)", "500").action(async (scope, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const limit = parseInt(opts.limit, 10) || 500;
+    const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()).flatMap(
+      (t) => SCRIPT_TABLES.filter((st) => st.table === t)
+    ) : SCRIPT_TABLES;
+    let matcher;
+    if (opts.regex) {
+      const re = new RegExp(opts.contains, "g");
+      matcher = (s) => re.test(s);
+    } else {
+      matcher = (s) => s.includes(opts.contains);
+    }
+    let totalMatches = 0;
+    for (const { table, field, label } of tables) {
+      const spinner = ora3(`Searching ${label} (${table}.${field})...`).start();
+      let records;
+      try {
+        records = await client.queryTable(table, {
+          sysparmQuery: `sys_scope.scope=${scope}^${field}ISNOTEMPTY`,
+          sysparmFields: `sys_id,name,${field}`,
+          sysparmLimit: limit
+        });
+        spinner.stop();
+      } catch (err) {
+        spinner.fail(chalk4.red(`${label}: ${err instanceof Error ? err.message : String(err)}`));
+        continue;
+      }
+      const matches = records.filter((r) => matcher(r[field] ?? ""));
+      if (matches.length === 0) continue;
+      console.log(chalk4.bold(`
+${label} \u2014 ${matches.length} match(es):`));
+      for (const r of matches) {
+        const content = r[field] ?? "";
+        const lines = content.split("\n");
+        const matchingLines = lines.map((line, i) => ({ line, num: i + 1 })).filter(({ line }) => matcher(line));
+        console.log(`  ${chalk4.cyan(r["name"] ?? r["sys_id"])}  ${chalk4.dim(r["sys_id"])}`);
+        for (const { line, num } of matchingLines.slice(0, 5)) {
+          const trimmed = line.trim().slice(0, 120);
+          console.log(`    ${chalk4.dim(`L${num}:`)} ${trimmed}`);
+        }
+        if (matchingLines.length > 5) {
+          console.log(chalk4.dim(`    ... and ${matchingLines.length - 5} more line(s)`));
+        }
+        totalMatches++;
+      }
+    }
+    console.log();
+    if (totalMatches === 0) {
+      console.log(chalk4.yellow(`No matches found for "${opts.contains}" in scope "${scope}".`));
+    } else {
+      console.log(chalk4.green(`Found matches in ${totalMatches} record(s).`));
+    }
+  });
+  cmd.command("replace <scope>").description("Find and replace text across script fields in an app scope").requiredOption("-f, --find <pattern>", "Text to find").requiredOption("-r, --replace <text>", "Replacement text").option("-t, --tables <tables>", "Comma-separated list of tables to target (default: all script tables)").option("--regex", "Treat --find as a JavaScript regex").option("-l, --limit <n>", "Max records to fetch per table (default: 500)", "500").option("--dry-run", "Show what would change without writing to the instance").option("--yes", "Skip confirmation prompt").action(async (scope, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const limit = parseInt(opts.limit, 10) || 500;
+    const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()).flatMap(
+      (t) => SCRIPT_TABLES.filter((st) => st.table === t)
+    ) : SCRIPT_TABLES;
+    const pattern = opts.regex ? new RegExp(opts.find, "g") : opts.find;
+    const doReplace = (s) => typeof pattern === "string" ? s.split(pattern).join(opts.replace) : s.replace(pattern, opts.replace);
+    const hasMatch = (s) => typeof pattern === "string" ? s.includes(pattern) : pattern.test(s);
+    const candidates = [];
+    for (const { table, field, label } of tables) {
+      const spinner = ora3(`Scanning ${label} (${table}.${field})...`).start();
+      let records;
+      try {
+        records = await client.queryTable(table, {
+          sysparmQuery: `sys_scope.scope=${scope}^${field}ISNOTEMPTY`,
+          sysparmFields: `sys_id,name,${field}`,
+          sysparmLimit: limit
+        });
+        spinner.stop();
+      } catch (err) {
+        spinner.fail(chalk4.red(`${label}: ${err instanceof Error ? err.message : String(err)}`));
+        continue;
+      }
+      for (const r of records) {
+        if (pattern instanceof RegExp) pattern.lastIndex = 0;
+        const original = r[field] ?? "";
+        if (!hasMatch(original)) continue;
+        if (pattern instanceof RegExp) pattern.lastIndex = 0;
+        const updated = doReplace(original);
+        candidates.push({
+          table,
+          field,
+          label,
+          sysId: r["sys_id"],
+          name: r["name"] ?? r["sys_id"],
+          original,
+          updated
+        });
+      }
+    }
+    if (candidates.length === 0) {
+      console.log(chalk4.yellow(`No matches found for "${opts.find}" in scope "${scope}".`));
+      return;
+    }
+    console.log(chalk4.bold(`
+${candidates.length} record(s) will be modified:
+`));
+    for (const c of candidates) {
+      console.log(`  ${chalk4.cyan(c.name)}  ${chalk4.dim(`${c.label} \u2014 ${c.table}/${c.sysId}`)}`);
+    }
+    console.log();
+    if (opts.dryRun) {
+      console.log(chalk4.yellow("Dry run \u2014 no changes made."));
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm2({
+        message: `Replace "${opts.find}" \u2192 "${opts.replace}" in ${candidates.length} record(s) on ${instance.alias}?`,
+        default: false
+      });
+      if (!ok) {
+        console.log(chalk4.dim("Aborted."));
+        return;
+      }
+    }
+    let successCount = 0;
+    let failCount = 0;
+    for (const c of candidates) {
+      const spinner = ora3(`Updating ${c.name}...`).start();
+      try {
+        await client.updateRecord(c.table, c.sysId, { [c.field]: c.updated });
+        spinner.succeed(chalk4.green(`Updated: ${c.name}`));
+        successCount++;
+      } catch (err) {
+        spinner.fail(chalk4.red(`Failed ${c.name}: ${err instanceof Error ? err.message : String(err)}`));
+        failCount++;
+      }
+    }
+    console.log();
+    if (failCount === 0) {
+      console.log(chalk4.green(`Replaced in ${successCount} record(s) successfully.`));
+    } else {
+      console.log(chalk4.yellow(`Replaced in ${successCount} record(s). ${failCount} failed.`));
+    }
+  });
+  return cmd;
+}
+async function pushScript(client, table, sysId, field, filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const spinner = ora3(`Pushing to ${table}/${sysId} field "${field}"...`).start();
+  try {
+    await client.updateRecord(table, sysId, { [field]: content });
     spinner.succeed(chalk4.green(`Pushed successfully to ${table}/${sysId}.`));
   } catch (err) {
     spinner.fail();
@@ -883,114 +1607,6 @@ init_config();
 import { Command as Command5 } from "commander";
 import chalk5 from "chalk";
 import ora4 from "ora";
-
-// src/lib/llm.ts
-init_esm_shims();
-import axios2 from "axios";
-var OpenAIProvider = class {
-  constructor(apiKey, model, baseUrl = "https://api.openai.com/v1", name = "openai") {
-    this.apiKey = apiKey;
-    this.model = model;
-    this.baseUrl = baseUrl;
-    this.providerName = name;
-  }
-  providerName;
-  async complete(messages) {
-    const res = await axios2.post(
-      `${this.baseUrl.replace(/\/$/, "")}/chat/completions`,
-      { model: this.model, messages },
-      {
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json"
-        },
-        timeout: 12e4
-      }
-    );
-    const content = res.data.choices[0]?.message.content;
-    if (!content) throw new Error("LLM returned an empty response");
-    return content;
-  }
-};
-var AnthropicProvider = class {
-  constructor(apiKey, model) {
-    this.apiKey = apiKey;
-    this.model = model;
-  }
-  providerName = "anthropic";
-  async complete(messages) {
-    const system = messages.find((m) => m.role === "system")?.content;
-    const conversation = messages.filter((m) => m.role !== "system");
-    const res = await axios2.post(
-      "https://api.anthropic.com/v1/messages",
-      {
-        model: this.model,
-        max_tokens: 8192,
-        ...system ? { system } : {},
-        messages: conversation
-      },
-      {
-        headers: {
-          "x-api-key": this.apiKey,
-          "anthropic-version": "2023-06-01",
-          "Content-Type": "application/json"
-        },
-        timeout: 12e4
-      }
-    );
-    const text = res.data.content.find((c) => c.type === "text")?.text;
-    if (!text) throw new Error("Anthropic returned an empty response");
-    return text;
-  }
-};
-var OllamaProvider = class {
-  constructor(model, baseUrl = "http://localhost:11434") {
-    this.model = model;
-    this.baseUrl = baseUrl;
-  }
-  providerName = "ollama";
-  async complete(messages) {
-    const res = await axios2.post(
-      `${this.baseUrl.replace(/\/$/, "")}/api/chat`,
-      { model: this.model, messages, stream: false },
-      { headers: { "Content-Type": "application/json" }, timeout: 3e5 }
-    );
-    const content = res.data.message.content;
-    if (!content) throw new Error("Ollama returned an empty response");
-    return content;
-  }
-};
-function buildProvider(name, model, apiKey, baseUrl) {
-  switch (name) {
-    case "anthropic":
-      if (!apiKey) throw new Error("Anthropic provider requires an API key (https://platform.claude.com/)");
-      return new AnthropicProvider(apiKey, model);
-    case "xai":
-      if (!apiKey) throw new Error("xAI provider requires an API key (https://platform.x.ai/)");
-      return new OpenAIProvider(
-        apiKey,
-        model,
-        baseUrl ?? "https://api.x.ai/v1",
-        "xai"
-      );
-    case "ollama":
-      return new OllamaProvider(model, baseUrl);
-    case "openai":
-    default:
-      if (!apiKey) throw new Error("OpenAI provider requires an API key (https://platform.openai.com/)");
-      return new OpenAIProvider(apiKey, model, baseUrl, name);
-  }
-}
-function extractJSON(raw) {
-  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (fenced) return fenced[1].trim();
-  const start = raw.indexOf("{");
-  const end = raw.lastIndexOf("}");
-  if (start !== -1 && end !== -1) return raw.slice(start, end + 1);
-  return raw.trim();
-}
-
-// src/commands/provider.ts
 var PROVIDER_NAMES = ["openai", "anthropic", "xai", "ollama"];
 var PROVIDER_DEFAULTS = {
   openai: { model: "gpt-4o" },
@@ -1142,8 +1758,8 @@ init_esm_shims();
 init_config();
 import { Command as Command6 } from "commander";
 import * as readline from "readline";
-import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join3, dirname, basename } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join4, dirname, basename } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync2 } from "child_process";
 import chalk6 from "chalk";
@@ -2498,12 +3114,12 @@ function printBuildSummary(build, previous = null) {
 }
 function saveBuild(build, customDir) {
   const dir = customDir ?? slugify(build.name);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   const base = slugify(build.name);
-  const xmlFile = join3(dir, `${base}.xml`);
-  const manifestFile = join3(dir, `${base}.manifest.json`);
-  writeFileSync3(xmlFile, generateUpdateSetXML(build), "utf-8");
-  writeFileSync3(manifestFile, JSON.stringify(build, null, 2), "utf-8");
+  const xmlFile = join4(dir, `${base}.xml`);
+  const manifestFile = join4(dir, `${base}.manifest.json`);
+  writeFileSync4(xmlFile, generateUpdateSetXML(build), "utf-8");
+  writeFileSync4(manifestFile, JSON.stringify(build, null, 2), "utf-8");
   return dir;
 }
 function printSaveResult(dir, build) {
@@ -2547,8 +3163,8 @@ async function confirmPush(build, dir, autoPush) {
   let shouldPush = autoPush ?? false;
   if (!shouldPush) {
     console.log();
-    const { confirm: confirm2 } = await import("@inquirer/prompts");
-    shouldPush = await confirm2({
+    const { confirm: confirm6 } = await import("@inquirer/prompts");
+    shouldPush = await confirm6({
       message: `Push ${build.artifacts.length} artifact(s) to ${chalk6.cyan(instance.alias)} (${instance.url})?`,
       default: false
     });
@@ -2596,7 +3212,7 @@ function resolveManifestPath(path2) {
   }
   if (existsSync3(path2) && !path2.includes(".")) {
     const files = readdirSync2(path2).filter((f) => f.endsWith(".manifest.json"));
-    if (files.length > 0) return join3(path2, files[0]);
+    if (files.length > 0) return join4(path2, files[0]);
   }
   console.error(chalk6.red(`Cannot resolve build manifest from: ${path2}`));
   console.error(chalk6.dim("Pass a build directory, a .xml file, or a .manifest.json file."));
@@ -2613,7 +3229,7 @@ function printCodeBlock(code, label) {
   console.log(chalk6.dim("\u2500".repeat(width)));
 }
 async function runReview(build, buildDir) {
-  const { select: select2, confirm: confirm2 } = await import("@inquirer/prompts");
+  const { select: select2, confirm: confirm6 } = await import("@inquirer/prompts");
   const editor = resolveEditor2();
   let modified = false;
   console.log();
@@ -2659,10 +3275,10 @@ async function runReview(build, buildDir) {
     console.log();
     printCodeBlock(currentCode, `${artifactName} \u2014 ${fieldDef.label}`);
     console.log();
-    const shouldEdit = await confirm2({ message: "Open in editor to edit?", default: false });
+    const shouldEdit = await confirm6({ message: "Open in editor to edit?", default: false });
     if (shouldEdit) {
-      const tmpFile = join3(tmpdir2(), `snow-review-${Date.now()}${fieldDef.ext}`);
-      writeFileSync3(tmpFile, currentCode, "utf-8");
+      const tmpFile = join4(tmpdir2(), `snow-review-${Date.now()}${fieldDef.ext}`);
+      writeFileSync4(tmpFile, currentCode, "utf-8");
       const isWin = process.platform === "win32";
       spawnSync2(editor, [tmpFile], { stdio: "inherit", shell: isWin });
       const updatedCode = readFileSync3(tmpFile, "utf-8");
@@ -2670,10 +3286,10 @@ async function runReview(build, buildDir) {
         build.artifacts[selectedIndex].fields[fieldDef.field] = updatedCode;
         modified = true;
         const base = slugify(build.name);
-        const xmlFile = join3(buildDir, `${base}.xml`);
-        const manifestFile = join3(buildDir, `${base}.manifest.json`);
-        writeFileSync3(xmlFile, generateUpdateSetXML(build), "utf-8");
-        writeFileSync3(manifestFile, JSON.stringify(build, null, 2), "utf-8");
+        const xmlFile = join4(buildDir, `${base}.xml`);
+        const manifestFile = join4(buildDir, `${base}.manifest.json`);
+        writeFileSync4(xmlFile, generateUpdateSetXML(build), "utf-8");
+        writeFileSync4(manifestFile, JSON.stringify(build, null, 2), "utf-8");
         console.log(chalk6.green(`  \u2714 Saved changes to ${basename(manifestFile)}`));
       } else {
         console.log(chalk6.dim("  No changes made."));
@@ -2781,7 +3397,7 @@ function aiCommand() {
         console.error(chalk6.red(`No .manifest.json found in directory: ${path2}`));
         process.exit(1);
       }
-      manifestPath = join3(path2, files[0]);
+      manifestPath = join4(path2, files[0]);
     } else {
       console.error(chalk6.red(`Cannot resolve build from: ${path2}`));
       console.error(chalk6.dim("Pass a build directory, a .xml file, or a .manifest.json file."));
@@ -2960,52 +3576,1241 @@ ${chalk6.dim("Slash commands:")}
   return cmd;
 }
 
+// src/commands/bulk.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora6 from "ora";
+import { confirm as confirm3 } from "@inquirer/prompts";
+function parseSetArgs(setArgs) {
+  const fields = {};
+  for (const arg of setArgs) {
+    const eq = arg.indexOf("=");
+    if (eq === -1) {
+      console.error(chalk7.red(`Invalid --set value "${arg}": expected field=value`));
+      process.exit(1);
+    }
+    fields[arg.slice(0, eq)] = arg.slice(eq + 1);
+  }
+  return fields;
+}
+function renderPreviewTable(records, fields) {
+  const fieldNames = Object.keys(fields);
+  const headers = ["sys_id", "display_name", ...fieldNames.map((f) => `${f} (new)`)];
+  const rows = records.map((r) => {
+    const sysId = String(r["sys_id"] ?? "");
+    const displayName = String(r["name"] ?? r["short_description"] ?? r["number"] ?? r["sys_name"] ?? "");
+    return [sysId, displayName, ...fieldNames.map((f) => fields[f])];
+  });
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => r[i]?.length ?? 0))
+  );
+  const divider = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+  const fmt = (row2) => row2.map((cell, i) => ` ${cell.padEnd(colWidths[i])} `).join("|");
+  console.log(chalk7.bold(fmt(headers)));
+  console.log(divider);
+  for (const row2 of rows) {
+    console.log(fmt(row2));
+  }
+}
+function bulkCommand() {
+  const cmd = new Command7("bulk").description("Bulk operations on ServiceNow records");
+  cmd.command("update <table>").description("Update multiple records matching a query").requiredOption("-q, --query <query>", "ServiceNow encoded query to select records").option("-s, --set <field=value>", "Field to set (repeat for multiple fields)", (val, acc) => {
+    acc.push(val);
+    return acc;
+  }, []).option("-l, --limit <n>", "Max records to update (default: 200)", "200").option("--dry-run", "Preview which records would be updated without making changes").option("--yes", "Skip confirmation prompt").action(async (table, opts) => {
+    if (opts.set.length === 0) {
+      console.error(chalk7.red("At least one --set field=value is required."));
+      process.exit(1);
+    }
+    const fields = parseSetArgs(opts.set);
+    const limit = parseInt(opts.limit, 10);
+    if (isNaN(limit) || limit < 1) {
+      console.error(chalk7.red("--limit must be a positive integer"));
+      process.exit(1);
+    }
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const fetchSpinner = ora6(`Fetching records from ${table}...`).start();
+    let records;
+    try {
+      records = await client.queryTable(table, {
+        sysparmQuery: opts.query,
+        sysparmFields: `sys_id,name,short_description,number,sys_name`,
+        sysparmLimit: limit
+      });
+      fetchSpinner.stop();
+    } catch (err) {
+      fetchSpinner.fail();
+      console.error(chalk7.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (records.length === 0) {
+      console.log(chalk7.yellow("No records matched the query."));
+      return;
+    }
+    console.log(chalk7.bold(`
+${records.length} record(s) will be updated on ${chalk7.cyan(instance.alias)}:`));
+    renderPreviewTable(records, fields);
+    console.log();
+    if (opts.dryRun) {
+      console.log(chalk7.yellow("Dry run \u2014 no changes made."));
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm3({
+        message: `Update ${records.length} record(s) in ${table}?`,
+        default: false
+      });
+      if (!ok) {
+        console.log(chalk7.dim("Aborted."));
+        return;
+      }
+    }
+    let successCount = 0;
+    let failCount = 0;
+    const updateSpinner = ora6(`Updating 0/${records.length}...`).start();
+    for (let i = 0; i < records.length; i++) {
+      const sysId = String(records[i]["sys_id"]);
+      updateSpinner.text = `Updating ${i + 1}/${records.length}...`;
+      try {
+        await client.updateRecord(table, sysId, fields);
+        successCount++;
+      } catch (err) {
+        failCount++;
+        updateSpinner.stop();
+        console.error(chalk7.red(`  Failed ${sysId}: ${err instanceof Error ? err.message : String(err)}`));
+        updateSpinner.start(`Updating ${i + 1}/${records.length}...`);
+      }
+    }
+    updateSpinner.stop();
+    if (failCount === 0) {
+      console.log(chalk7.green(`
+Updated ${successCount} record(s) successfully.`));
+    } else {
+      console.log(chalk7.yellow(`
+Updated ${successCount} record(s). ${failCount} failed.`));
+    }
+  });
+  return cmd;
+}
+
+// src/commands/user.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora7 from "ora";
+import { confirm as confirm4 } from "@inquirer/prompts";
+async function resolveUser(client, query) {
+  const isSysId = /^[0-9a-f]{32}$/i.test(query);
+  const snQuery = isSysId ? `sys_id=${query}` : `user_name=${query}^ORemail=${query}^ORname=${query}`;
+  const res = await client.queryTable("sys_user", {
+    sysparmQuery: snQuery,
+    sysparmFields: "sys_id,name,user_name,email",
+    sysparmLimit: 2
+  });
+  if (res.length === 0) throw new Error(`User not found: ${query}`);
+  if (res.length > 1) throw new Error(`Ambiguous user query "${query}" \u2014 matched multiple users. Use sys_id or user_name.`);
+  return { sysId: res[0].sys_id, name: `${res[0].name} (${res[0].user_name})` };
+}
+async function resolveGroup(client, query) {
+  const isSysId = /^[0-9a-f]{32}$/i.test(query);
+  const snQuery = isSysId ? `sys_id=${query}` : `name=${query}`;
+  const res = await client.queryTable("sys_user_group", {
+    sysparmQuery: snQuery,
+    sysparmFields: "sys_id,name",
+    sysparmLimit: 2
+  });
+  if (res.length === 0) throw new Error(`Group not found: ${query}`);
+  if (res.length > 1) throw new Error(`Ambiguous group query "${query}" \u2014 matched multiple groups. Use sys_id or exact name.`);
+  return { sysId: res[0].sys_id, name: res[0].name };
+}
+async function resolveRole(client, query) {
+  const isSysId = /^[0-9a-f]{32}$/i.test(query);
+  const snQuery = isSysId ? `sys_id=${query}` : `name=${query}`;
+  const res = await client.queryTable("sys_user_role", {
+    sysparmQuery: snQuery,
+    sysparmFields: "sys_id,name",
+    sysparmLimit: 2
+  });
+  if (res.length === 0) throw new Error(`Role not found: ${query}`);
+  if (res.length > 1) throw new Error(`Ambiguous role "${query}" \u2014 use sys_id or exact name.`);
+  return { sysId: res[0].sys_id, name: res[0].name };
+}
+function userCommand() {
+  const cmd = new Command8("user").description("Manage ServiceNow users, groups, and roles");
+  cmd.command("add-to-group <user> <group>").description("Add a user to a group").option("--yes", "Skip confirmation").action(async (userQuery, groupQuery, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora7("Resolving user and group...").start();
+    let user;
+    let group;
+    try {
+      [user, group] = await Promise.all([
+        resolveUser(client, userQuery),
+        resolveGroup(client, groupQuery)
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const existing = await client.queryTable("sys_user_grmember", {
+      sysparmQuery: `user=${user.sysId}^group=${group.sysId}`,
+      sysparmFields: "sys_id",
+      sysparmLimit: 1
+    });
+    if (existing.length > 0) {
+      console.log(chalk8.yellow(`${user.name} is already a member of ${group.name}.`));
+      return;
+    }
+    console.log(`Add ${chalk8.cyan(user.name)} to group ${chalk8.cyan(group.name)} on ${chalk8.bold(instance.alias)}?`);
+    if (!opts.yes) {
+      const ok = await confirm4({ message: "Proceed?", default: true });
+      if (!ok) {
+        console.log(chalk8.dim("Aborted."));
+        return;
+      }
+    }
+    const addSpinner = ora7("Adding to group...").start();
+    try {
+      await client.createRecord("sys_user_grmember", { user: user.sysId, group: group.sysId });
+      addSpinner.succeed(chalk8.green(`Added ${user.name} to ${group.name}.`));
+    } catch (err) {
+      addSpinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  cmd.command("remove-from-group <user> <group>").description("Remove a user from a group").option("--yes", "Skip confirmation").action(async (userQuery, groupQuery, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora7("Resolving user and group...").start();
+    let user;
+    let group;
+    try {
+      [user, group] = await Promise.all([
+        resolveUser(client, userQuery),
+        resolveGroup(client, groupQuery)
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const members = await client.queryTable("sys_user_grmember", {
+      sysparmQuery: `user=${user.sysId}^group=${group.sysId}`,
+      sysparmFields: "sys_id",
+      sysparmLimit: 1
+    });
+    if (members.length === 0) {
+      console.log(chalk8.yellow(`${user.name} is not a member of ${group.name}.`));
+      return;
+    }
+    console.log(`Remove ${chalk8.cyan(user.name)} from group ${chalk8.cyan(group.name)} on ${chalk8.bold(instance.alias)}?`);
+    if (!opts.yes) {
+      const ok = await confirm4({ message: "Proceed?", default: false });
+      if (!ok) {
+        console.log(chalk8.dim("Aborted."));
+        return;
+      }
+    }
+    const removeSpinner = ora7("Removing from group...").start();
+    try {
+      await client.deleteRecord("sys_user_grmember", members[0].sys_id);
+      removeSpinner.succeed(chalk8.green(`Removed ${user.name} from ${group.name}.`));
+    } catch (err) {
+      removeSpinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  cmd.command("assign-role <user> <role>").description("Assign a role to a user").option("--yes", "Skip confirmation").action(async (userQuery, roleQuery, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora7("Resolving user and role...").start();
+    let user;
+    let role;
+    try {
+      [user, role] = await Promise.all([
+        resolveUser(client, userQuery),
+        resolveRole(client, roleQuery)
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const existing = await client.queryTable("sys_user_has_role", {
+      sysparmQuery: `user=${user.sysId}^role=${role.sysId}`,
+      sysparmFields: "sys_id",
+      sysparmLimit: 1
+    });
+    if (existing.length > 0) {
+      console.log(chalk8.yellow(`${user.name} already has role ${role.name}.`));
+      return;
+    }
+    console.log(`Assign role ${chalk8.cyan(role.name)} to ${chalk8.cyan(user.name)} on ${chalk8.bold(instance.alias)}?`);
+    if (!opts.yes) {
+      const ok = await confirm4({ message: "Proceed?", default: true });
+      if (!ok) {
+        console.log(chalk8.dim("Aborted."));
+        return;
+      }
+    }
+    const assignSpinner = ora7("Assigning role...").start();
+    try {
+      await client.createRecord("sys_user_has_role", { user: user.sysId, role: role.sysId });
+      assignSpinner.succeed(chalk8.green(`Assigned role ${role.name} to ${user.name}.`));
+    } catch (err) {
+      assignSpinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  cmd.command("remove-role <user> <role>").description("Remove a role from a user").option("--yes", "Skip confirmation").action(async (userQuery, roleQuery, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora7("Resolving user and role...").start();
+    let user;
+    let role;
+    try {
+      [user, role] = await Promise.all([
+        resolveUser(client, userQuery),
+        resolveRole(client, roleQuery)
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const existing = await client.queryTable("sys_user_has_role", {
+      sysparmQuery: `user=${user.sysId}^role=${role.sysId}`,
+      sysparmFields: "sys_id",
+      sysparmLimit: 1
+    });
+    if (existing.length === 0) {
+      console.log(chalk8.yellow(`${user.name} does not have role ${role.name}.`));
+      return;
+    }
+    console.log(`Remove role ${chalk8.cyan(role.name)} from ${chalk8.cyan(user.name)} on ${chalk8.bold(instance.alias)}?`);
+    if (!opts.yes) {
+      const ok = await confirm4({ message: "Proceed?", default: false });
+      if (!ok) {
+        console.log(chalk8.dim("Aborted."));
+        return;
+      }
+    }
+    const removeSpinner = ora7("Removing role...").start();
+    try {
+      await client.deleteRecord("sys_user_has_role", existing[0].sys_id);
+      removeSpinner.succeed(chalk8.green(`Removed role ${role.name} from ${user.name}.`));
+    } catch (err) {
+      removeSpinner.fail();
+      console.error(chalk8.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/attachment.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command9 } from "commander";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync4 } from "fs";
+import { join as join5, basename as basename2 } from "path";
+import { createReadStream, statSync as statSync2 } from "fs";
+import chalk9 from "chalk";
+import ora8 from "ora";
+function humanSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function listAttachments(client, table, sysId) {
+  const res = await client.get("/api/now/attachment", {
+    params: {
+      sysparm_query: `table_name=${table}^table_sys_id=${sysId}`,
+      sysparm_fields: "sys_id,file_name,content_type,size_bytes,table_name,table_sys_id",
+      sysparm_limit: 500
+    }
+  });
+  return res.result ?? [];
+}
+async function downloadAttachment(client, attSysId) {
+  const res = await client.getAxiosInstance().get(
+    `/api/now/attachment/${attSysId}/file`,
+    { responseType: "arraybuffer" }
+  );
+  return Buffer.from(res.data);
+}
+function attachmentCommand() {
+  const cmd = new Command9("attachment").alias("att").description("Manage ServiceNow record attachments");
+  cmd.command("list <table> <sys_id>").alias("ls").description("List attachments on a record").action(async (table, sysId) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora8("Fetching attachments...").start();
+    let attachments;
+    try {
+      attachments = await listAttachments(client, table, sysId);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (attachments.length === 0) {
+      console.log(chalk9.dim("No attachments found."));
+      return;
+    }
+    console.log(chalk9.bold(`
+${attachments.length} attachment(s) on ${table}/${sysId}:
+`));
+    const nameWidth = Math.max(9, ...attachments.map((a) => a.file_name.length));
+    const typeWidth = Math.max(12, ...attachments.map((a) => a.content_type.length));
+    console.log(
+      chalk9.bold(
+        `${"File name".padEnd(nameWidth)}  ${"Content-Type".padEnd(typeWidth)}  Size       sys_id`
+      )
+    );
+    console.log(`${"-".repeat(nameWidth)}  ${"-".repeat(typeWidth)}  ---------  ${"-".repeat(32)}`);
+    for (const att of attachments) {
+      const size = humanSize(parseInt(att.size_bytes, 10) || 0);
+      console.log(
+        `${chalk9.cyan(att.file_name.padEnd(nameWidth))}  ${att.content_type.padEnd(typeWidth)}  ${size.padStart(9)}  ${chalk9.dim(att.sys_id)}`
+      );
+    }
+  });
+  cmd.command("pull <table> <sys_id>").description("Download attachment(s) from a record").option("-a, --all", "Download all attachments").option("-n, --name <file_name>", "Download a specific attachment by file name").option("-o, --out <dir>", "Output directory (default: current directory)").action(async (table, sysId, opts) => {
+    if (!opts.all && !opts.name) {
+      console.error(chalk9.red("Specify --all to download all attachments, or --name <file_name> for one."));
+      process.exit(1);
+    }
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const outDir = opts.out ?? ".";
+    if (!existsSync4(outDir)) mkdirSync5(outDir, { recursive: true });
+    const spinner = ora8("Fetching attachment list...").start();
+    let attachments;
+    try {
+      attachments = await listAttachments(client, table, sysId);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (attachments.length === 0) {
+      console.log(chalk9.dim("No attachments found."));
+      return;
+    }
+    let targets = attachments;
+    if (opts.name) {
+      targets = attachments.filter((a) => a.file_name === opts.name);
+      if (targets.length === 0) {
+        console.error(chalk9.red(`No attachment named "${opts.name}" found.`));
+        process.exit(1);
+      }
+    }
+    let downloaded = 0;
+    for (const att of targets) {
+      const dlSpinner = ora8(`Downloading ${att.file_name}...`).start();
+      try {
+        const buf = await downloadAttachment(client, att.sys_id);
+        const dest = join5(outDir, att.file_name);
+        writeFileSync5(dest, buf);
+        dlSpinner.succeed(chalk9.green(`Saved: ${dest} (${humanSize(buf.length)})`));
+        downloaded++;
+      } catch (err) {
+        dlSpinner.fail(chalk9.red(`Failed ${att.file_name}: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    if (targets.length > 1) {
+      console.log(chalk9.bold(`
+${downloaded}/${targets.length} downloaded to ${outDir}`));
+    }
+  });
+  cmd.command("push <table> <sys_id> <file>").description("Upload a file as an attachment to a record").option("-t, --type <content-type>", "Override Content-Type (auto-detected by default)").action(async (table, sysId, file, opts) => {
+    if (!existsSync4(file)) {
+      console.error(chalk9.red(`File not found: ${file}`));
+      process.exit(1);
+    }
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const fileName = basename2(file);
+    const stat = statSync2(file);
+    const contentType = opts.type ?? guessContentType(fileName);
+    const spinner = ora8(`Uploading ${fileName} (${humanSize(stat.size)})...`).start();
+    try {
+      const stream = createReadStream(file);
+      const res = await client.getAxiosInstance().post(
+        "/api/now/attachment/file",
+        stream,
+        {
+          params: {
+            table_name: table,
+            table_sys_id: sysId,
+            file_name: fileName
+          },
+          headers: {
+            "Content-Type": contentType,
+            "Content-Length": stat.size
+          },
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity
+        }
+      );
+      const created = res.data.result;
+      spinner.succeed(
+        chalk9.green(`Uploaded: ${created.file_name} (${humanSize(parseInt(created.size_bytes, 10))}) \u2014 sys_id: ${created.sys_id}`)
+      );
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+function guessContentType(fileName) {
+  const ext = fileName.slice(fileName.lastIndexOf(".")).toLowerCase();
+  const map = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".json": "application/json",
+    ".zip": "application/zip",
+    ".js": "application/javascript",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".md": "text/markdown",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/commands/updateset.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command10 } from "commander";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import chalk10 from "chalk";
+import ora9 from "ora";
+import { confirm as confirm5 } from "@inquirer/prompts";
+async function resolveUpdateSet(client, query) {
+  const isSysId = /^[0-9a-f]{32}$/i.test(query);
+  const snQuery = isSysId ? `sys_id=${query}` : `nameCONTAINS${query}`;
+  const res = await client.queryTable("sys_update_set", {
+    sysparmQuery: snQuery,
+    sysparmFields: "sys_id,name,description,state,application,is_default,sys_created_by,sys_created_on",
+    sysparmDisplayValue: "true",
+    sysparmLimit: isSysId ? 1 : 5
+  });
+  if (res.length === 0) throw new Error(`Update set not found: "${query}"`);
+  if (res.length > 1) {
+    const names = res.map((s) => `  ${chalk10.cyan(s.name)}  (${s.sys_id})`).join("\n");
+    throw new Error(`Ambiguous update set name "${query}" \u2014 matched ${res.length}:
+${names}
+Use sys_id or a more specific name.`);
+  }
+  return res[0];
+}
+async function getCurrentUpdateSet(client) {
+  const prefs = await client.queryTable("sys_user_preference", {
+    sysparmQuery: "name=sys_update_set^userISEMPTY^ORuser.user_name=javascript:gs.getUserName()",
+    sysparmFields: "value",
+    sysparmLimit: 1
+  });
+  const prefSysId = prefs[0]?.value;
+  if (prefSysId) {
+    const sets = await client.queryTable("sys_update_set", {
+      sysparmQuery: `sys_id=${prefSysId}`,
+      sysparmFields: "sys_id,name,description,state,application,is_default,sys_created_by,sys_created_on",
+      sysparmDisplayValue: "true",
+      sysparmLimit: 1
+    });
+    if (sets.length > 0) return sets[0];
+  }
+  const defaults = await client.queryTable("sys_update_set", {
+    sysparmQuery: "state=in progress^is_default=true",
+    sysparmFields: "sys_id,name,description,state,application,is_default,sys_created_by,sys_created_on",
+    sysparmDisplayValue: "true",
+    sysparmLimit: 1
+  });
+  return defaults[0] ?? null;
+}
+async function setCurrentUpdateSet(client, updateSetSysId) {
+  const existing = await client.queryTable("sys_user_preference", {
+    sysparmQuery: "name=sys_update_set^userISEMPTY",
+    sysparmFields: "sys_id",
+    sysparmLimit: 1
+  });
+  if (existing.length > 0) {
+    await client.updateRecord("sys_user_preference", existing[0].sys_id, { value: updateSetSysId });
+  } else {
+    await client.createRecord("sys_user_preference", { name: "sys_update_set", value: updateSetSysId });
+  }
+}
+function displaySet(set) {
+  const app = typeof set.application === "object" ? set.application.display_value : set.application;
+  const isDefault = set.is_default === "true" || set.is_default === "1";
+  const stateColor = set.state === "in progress" ? chalk10.green : set.state === "complete" ? chalk10.blue : chalk10.dim;
+  console.log(`${chalk10.bold(set.name)}${isDefault ? chalk10.yellow("  \u2605 active") : ""}`);
+  console.log(`  sys_id:   ${chalk10.dim(set.sys_id)}`);
+  console.log(`  state:    ${stateColor(set.state)}`);
+  console.log(`  app:      ${app || chalk10.dim("Global")}`);
+  console.log(`  created:  ${set.sys_created_on} by ${set.sys_created_by}`);
+  if (set.description) console.log(`  desc:     ${set.description}`);
+}
+function updatesetCommand() {
+  const cmd = new Command10("updateset").alias("us").description("Manage ServiceNow update sets");
+  cmd.command("list").alias("ls").description("List update sets on the instance").option("-s, --state <state>", 'Filter by state: "in progress", "complete", "ignore" (default: all)').option("-l, --limit <n>", "Max results (default: 50)", "50").action(async (opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const limit = parseInt(opts.limit, 10) || 50;
+    const query = opts.state ? `state=${opts.state}` : "state!=ignore";
+    const spinner = ora9("Fetching update sets...").start();
+    let sets;
+    try {
+      sets = await client.queryTable("sys_update_set", {
+        sysparmQuery: `${query}^ORDERBYDESCsys_created_on`,
+        sysparmFields: "sys_id,name,state,application,is_default,sys_created_by,sys_created_on",
+        sysparmDisplayValue: "true",
+        sysparmLimit: limit
+      });
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (sets.length === 0) {
+      console.log(chalk10.dim("No update sets found."));
+      return;
+    }
+    const appLabel = (s) => (typeof s.application === "object" ? s.application.display_value : s.application) || "Global";
+    const nameWidth = Math.max(4, ...sets.map((s) => s.name.length));
+    const stateWidth = Math.max(5, ...sets.map((s) => s.state.length));
+    const appWidth = Math.max(11, ...sets.map((s) => appLabel(s).length));
+    console.log(chalk10.bold(
+      `${"Name".padEnd(nameWidth)}  ${"State".padEnd(stateWidth)}  ${"Application".padEnd(appWidth)}  ${"Created by".padEnd(16)}  Created on`
+    ));
+    console.log(`${"-".repeat(nameWidth)}  ${"-".repeat(stateWidth)}  ${"-".repeat(appWidth)}  ${"-".repeat(16)}  ${"-".repeat(19)}`);
+    for (const s of sets) {
+      const isDefault = s.is_default === "true" || s.is_default === "1";
+      const stateStr = s.state === "in progress" ? chalk10.green(s.state.padEnd(stateWidth)) : chalk10.dim(s.state.padEnd(stateWidth));
+      const marker = isDefault ? chalk10.yellow(" \u2605") : "  ";
+      const app = appLabel(s);
+      console.log(`${chalk10.cyan(s.name.padEnd(nameWidth))}${marker}  ${stateStr}  ${app.padEnd(appWidth)}  ${s.sys_created_by.padEnd(16)}  ${s.sys_created_on}`);
+    }
+  });
+  cmd.command("current").description("Show the currently active update set").action(async () => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora9("Fetching current update set...").start();
+    let current;
+    try {
+      current = await getCurrentUpdateSet(client);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (!current) {
+      console.log(chalk10.yellow("No active update set found. Use `snow updateset set <name>` to activate one."));
+      return;
+    }
+    displaySet(current);
+  });
+  cmd.command("set <name>").description("Set the active update set (stored in sys_user_preference)").action(async (nameOrId) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora9("Resolving update set...").start();
+    let set;
+    try {
+      set = await resolveUpdateSet(client, nameOrId);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const setSpinner = ora9(`Activating "${set.name}"...`).start();
+    try {
+      await setCurrentUpdateSet(client, set.sys_id);
+      setSpinner.succeed(chalk10.green(`Active update set: ${set.name}`));
+    } catch (err) {
+      setSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  cmd.command("show <name>").description("Show details and captured items for an update set").option("-l, --limit <n>", "Max captured items to show (default: 100)", "100").action(async (nameOrId, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const limit = parseInt(opts.limit, 10) || 100;
+    const spinner = ora9("Fetching update set...").start();
+    let set;
+    try {
+      set = await resolveUpdateSet(client, nameOrId);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    displaySet(set);
+    const itemSpinner = ora9("Fetching captured items...").start();
+    let items;
+    try {
+      items = await client.queryTable("sys_update_xml", {
+        sysparmQuery: `update_set=${set.sys_id}^ORDERBYtype`,
+        sysparmFields: "sys_id,name,type,target_name,action,sys_created_on",
+        sysparmLimit: limit
+      });
+      itemSpinner.stop();
+    } catch (err) {
+      itemSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (items.length === 0) {
+      console.log(chalk10.dim("\n  No captured items."));
+      return;
+    }
+    console.log(chalk10.bold(`
+  ${items.length} captured item(s):
+`));
+    const typeWidth = Math.max(4, ...items.map((i) => i.type.length));
+    const actionWidth = Math.max(6, ...items.map((i) => i.action.length));
+    console.log(chalk10.bold(`  ${"Type".padEnd(typeWidth)}  ${"Action".padEnd(actionWidth)}  Target`));
+    console.log(`  ${"-".repeat(typeWidth)}  ${"-".repeat(actionWidth)}  ${"-".repeat(40)}`);
+    for (const item of items) {
+      const actionColor = item.action === "INSERT_OR_UPDATE" ? chalk10.green : item.action === "DELETE" ? chalk10.red : chalk10.dim;
+      console.log(`  ${item.type.padEnd(typeWidth)}  ${actionColor(item.action.padEnd(actionWidth))}  ${item.target_name}`);
+    }
+    if (items.length === limit) {
+      console.log(chalk10.dim(`
+  (showing first ${limit} items \u2014 use --limit to increase)`));
+    }
+  });
+  cmd.command("capture <name>").description("Capture specific records into an update set by temporarily making it active").requiredOption("-a, --add <table:sys_id>", "Record to capture as table:sys_id (repeat for multiple)", (val, acc) => {
+    acc.push(val);
+    return acc;
+  }, []).option("--yes", "Skip confirmation").action(async (nameOrId, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const records = [];
+    for (const entry of opts.add) {
+      const colon = entry.indexOf(":");
+      if (colon === -1) {
+        console.error(chalk10.red(`Invalid format "${entry}" \u2014 expected table:sys_id`));
+        process.exit(1);
+      }
+      records.push({ table: entry.slice(0, colon), sysId: entry.slice(colon + 1) });
+    }
+    const spinner = ora9("Resolving update set...").start();
+    let set;
+    let previousSet;
+    try {
+      [set, previousSet] = await Promise.all([
+        resolveUpdateSet(client, nameOrId),
+        getCurrentUpdateSet(client)
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    console.log(chalk10.bold(`Capture into update set: ${set.name}`));
+    for (const r of records) console.log(`  ${chalk10.cyan(r.table)}  ${chalk10.dim(r.sysId)}`);
+    console.log(chalk10.dim("\n  Method: temporarily activates the update set, patches each record (no-op), then restores."));
+    if (!opts.yes) {
+      const ok = await confirm5({ message: "Proceed?", default: true });
+      if (!ok) {
+        console.log(chalk10.dim("Aborted."));
+        return;
+      }
+    }
+    const activateSpinner = ora9(`Activating "${set.name}"...`).start();
+    try {
+      await setCurrentUpdateSet(client, set.sys_id);
+      activateSpinner.succeed();
+    } catch (err) {
+      activateSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    let captureFailures = 0;
+    for (const { table, sysId } of records) {
+      const captureSpinner = ora9(`Capturing ${table}/${sysId}...`).start();
+      try {
+        const record = await client.getRecord(table, sysId, { sysparmFields: "sys_id" });
+        await client.updateRecord(table, record.sys_id, { sys_mod_count: record["sys_mod_count"] });
+        captureSpinner.succeed(chalk10.green(`Captured: ${table}/${sysId}`));
+      } catch (err) {
+        captureSpinner.fail(chalk10.red(`Failed ${table}/${sysId}: ${err instanceof Error ? err.message : String(err)}`));
+        captureFailures++;
+      }
+    }
+    if (previousSet) {
+      const restoreSpinner = ora9(`Restoring active update set to "${previousSet.name}"...`).start();
+      try {
+        await setCurrentUpdateSet(client, previousSet.sys_id);
+        restoreSpinner.succeed();
+      } catch {
+        restoreSpinner.fail(chalk10.yellow("Could not restore previous update set \u2014 run `snow updateset set` manually."));
+      }
+    }
+    if (captureFailures === 0) {
+      console.log(chalk10.green(`
+Captured ${records.length} record(s) into "${set.name}".`));
+    } else {
+      console.log(chalk10.yellow(`
+Captured ${records.length - captureFailures}/${records.length} record(s).`));
+    }
+  });
+  cmd.command("export <name>").description("Export an update set as an XML file").option("-o, --out <dir>", "Output directory (default: current directory)", ".").action(async (nameOrId, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const resolveSpinner = ora9("Resolving update set...").start();
+    let set;
+    try {
+      set = await resolveUpdateSet(client, nameOrId);
+      resolveSpinner.stop();
+    } catch (err) {
+      resolveSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const exportSpinner = ora9(`Exporting "${set.name}"...`).start();
+    let xmlContent;
+    try {
+      const res = await client.getAxiosInstance().get(
+        "/export_update_set.do",
+        {
+          params: { type: "XML", sys_id: set.sys_id },
+          responseType: "text"
+        }
+      );
+      xmlContent = res.data;
+      exportSpinner.stop();
+    } catch (err) {
+      exportSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (!existsSync5(opts.out)) mkdirSync6(opts.out, { recursive: true });
+    const safeName = set.name.replace(/[^a-z0-9_-]/gi, "_");
+    const outPath = join6(opts.out, `${safeName}.xml`);
+    writeFileSync6(outPath, xmlContent, "utf-8");
+    console.log(chalk10.green(`Exported to: ${outPath}`));
+  });
+  cmd.command("apply <xml-file>").description("Import an update set XML into an instance (creates a Retrieved Update Set record)").option("-t, --target <alias>", "Target instance alias (default: active instance)").option("--yes", "Skip confirmation").action(async (xmlFile, opts) => {
+    if (!existsSync5(xmlFile)) {
+      console.error(chalk10.red(`File not found: ${xmlFile}`));
+      process.exit(1);
+    }
+    const xmlContent = readFileSync5(xmlFile, "utf-8");
+    const nameMatch = xmlContent.match(/<update_set[^>]*>[\s\S]*?<name>([^<]+)<\/name>/);
+    const xmlName = nameMatch ? nameMatch[1] : xmlFile;
+    let instance;
+    if (opts.target) {
+      const config = loadConfig();
+      instance = config.instances[opts.target];
+      if (!instance) {
+        console.error(chalk10.red(`Instance alias not found: ${opts.target}`));
+        process.exit(1);
+      }
+    } else {
+      instance = requireActiveInstance();
+    }
+    console.log(`Import ${chalk10.cyan(xmlName)} \u2192 ${chalk10.bold(instance.alias)} (${instance.url})`);
+    if (!opts.yes) {
+      const ok = await confirm5({ message: "Proceed?", default: true });
+      if (!ok) {
+        console.log(chalk10.dim("Aborted."));
+        return;
+      }
+    }
+    const client = new ServiceNowClient(instance);
+    const importSpinner = ora9("Uploading update set XML...").start();
+    let remoteSetSysId;
+    try {
+      const res = await client.createRecord("sys_remote_update_set", {
+        name: xmlName,
+        payload: xmlContent,
+        state: "loaded"
+      });
+      remoteSetSysId = res.sys_id;
+      importSpinner.succeed(chalk10.green(`Created retrieved update set: ${remoteSetSysId}`));
+    } catch (err) {
+      importSpinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    console.log();
+    console.log(chalk10.bold("Next steps in ServiceNow:"));
+    console.log(`  1. Navigate to ${chalk10.cyan("System Update Sets \u2192 Retrieved Update Sets")}`);
+    console.log(`  2. Open ${chalk10.cyan(xmlName)}`);
+    console.log(`  3. Click ${chalk10.cyan("Preview Update Set")} \u2192 resolve any conflicts`);
+    console.log(`  4. Click ${chalk10.cyan("Commit Update Set")}`);
+    console.log();
+    console.log(chalk10.dim(`  Direct link: ${instance.url}/sys_remote_update_set.do?sys_id=${remoteSetSysId}`));
+  });
+  cmd.command("diff <set1> <set2>").description("Compare captured items between two update sets").option("-l, --limit <n>", "Max captured items per set (default: 500)", "500").action(async (nameOrId1, nameOrId2, opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const limit = parseInt(opts.limit, 10) || 500;
+    const spinner = ora9("Fetching both update sets...").start();
+    let set1, set2;
+    let items1, items2;
+    try {
+      [set1, set2] = await Promise.all([
+        resolveUpdateSet(client, nameOrId1),
+        resolveUpdateSet(client, nameOrId2)
+      ]);
+      const fetchItems = (sysId) => client.queryTable("sys_update_xml", {
+        sysparmQuery: `update_set=${sysId}`,
+        sysparmFields: "sys_id,name,type,target_name,action,sys_created_on",
+        sysparmLimit: limit
+      });
+      [items1, items2] = await Promise.all([fetchItems(set1.sys_id), fetchItems(set2.sys_id)]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk10.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const map1 = new Map(items1.map((i) => [i.target_name, i]));
+    const map2 = new Map(items2.map((i) => [i.target_name, i]));
+    const onlyIn1 = [];
+    const onlyIn2 = [];
+    const inBoth = [];
+    for (const [key, item] of map1) {
+      if (map2.has(key)) inBoth.push({ item1: item, item2: map2.get(key) });
+      else onlyIn1.push(item);
+    }
+    for (const [key, item] of map2) {
+      if (!map1.has(key)) onlyIn2.push(item);
+    }
+    console.log(chalk10.bold(`
+Diff: ${chalk10.cyan(set1.name)} \u2190 \u2192 ${chalk10.cyan(set2.name)}
+`));
+    console.log(`  Items in ${chalk10.cyan(set1.name)}: ${items1.length}`);
+    console.log(`  Items in ${chalk10.cyan(set2.name)}: ${items2.length}`);
+    console.log();
+    if (onlyIn1.length > 0) {
+      console.log(chalk10.red(`  Only in "${set1.name}" (${onlyIn1.length}):`));
+      for (const i of onlyIn1) {
+        console.log(`    ${chalk10.red("\u2212")} ${i.type.padEnd(30)} ${i.target_name}`);
+      }
+      console.log();
+    }
+    if (onlyIn2.length > 0) {
+      console.log(chalk10.green(`  Only in "${set2.name}" (${onlyIn2.length}):`));
+      for (const i of onlyIn2) {
+        console.log(`    ${chalk10.green("+")} ${i.type.padEnd(30)} ${i.target_name}`);
+      }
+      console.log();
+    }
+    if (inBoth.length > 0) {
+      console.log(chalk10.dim(`  In both (${inBoth.length}):`));
+      for (const { item1, item2 } of inBoth) {
+        const actionChanged = item1.action !== item2.action;
+        const marker = actionChanged ? chalk10.yellow("~") : chalk10.dim("=");
+        const detail = actionChanged ? chalk10.yellow(` [action: ${item1.action} \u2192 ${item2.action}]`) : "";
+        console.log(`    ${marker} ${item1.type.padEnd(30)} ${item1.target_name}${detail}`);
+      }
+      console.log();
+    }
+    const summary = [
+      onlyIn1.length > 0 ? chalk10.red(`${onlyIn1.length} removed`) : "",
+      onlyIn2.length > 0 ? chalk10.green(`${onlyIn2.length} added`) : "",
+      inBoth.filter(({ item1, item2 }) => item1.action !== item2.action).length > 0 ? chalk10.yellow(`${inBoth.filter(({ item1, item2 }) => item1.action !== item2.action).length} changed`) : "",
+      chalk10.dim(`${inBoth.filter(({ item1, item2 }) => item1.action === item2.action).length} unchanged`)
+    ].filter(Boolean).join("  ");
+    console.log(`  ${summary}`);
+  });
+  return cmd;
+}
+
+// src/commands/status.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+import ora10 from "ora";
+async function countRecords(client, table, query) {
+  const res = await client.get(
+    `/api/now/stats/${table}`,
+    { params: { sysparm_count: true, sysparm_query: query } }
+  );
+  return parseInt(res.result?.stats?.count ?? "0", 10);
+}
+var DIVIDER = chalk11.dim("\u2500".repeat(52));
+var NA = chalk11.dim("N/A");
+function section(title) {
+  console.log();
+  console.log(chalk11.bold.cyan(`  ${title}`));
+  console.log(chalk11.dim(`  ${"\u2500".repeat(title.length)}`));
+}
+function row(label, value, width = 22) {
+  console.log(`  ${label.padEnd(width)}${value}`);
+}
+async function fetchVersion(client, debug = false) {
+  const props = await client.queryTable("sys_properties", {
+    sysparmQuery: "nameSTARTSWITHglide.build",
+    sysparmFields: "name,value",
+    sysparmLimit: 50
+  });
+  if (debug) {
+    console.log(chalk11.dim(`  [debug] glide.build.* properties returned (${props.length}):`));
+    for (const p of props) {
+      console.log(chalk11.dim(`    ${p.name} = ${JSON.stringify(p.value)}`));
+    }
+  }
+  if (props.length === 0) throw new Error("No glide.build.* properties accessible");
+  const val = (key) => {
+    const p = props.find((r) => r.name === key);
+    const raw = p?.value;
+    if (!raw) return "";
+    if (typeof raw === "object" && raw !== null) {
+      return raw["value"] ?? raw["display_value"] ?? "";
+    }
+    return String(raw).trim();
+  };
+  const buildtag = val("glide.buildtag.last");
+  const date = val("glide.build.date");
+  if (!buildtag) throw new Error("glide.buildtag.last is empty or not accessible");
+  const dateShort = date.match(/^(\d{2})-(\d{2})-(\d{4})/) ? `${date.slice(6, 10)}-${date.slice(0, 2)}-${date.slice(3, 5)}` : date.replace(/_\d+$/, "");
+  return { version: buildtag, date: dateShort };
+}
+async function fetchNodes(client) {
+  const nodes = await client.queryTable("sys_cluster_state", {
+    sysparmFields: "node_name,status",
+    sysparmLimit: 50
+  });
+  const active = nodes.filter((n) => n.status === "Online" || n.status === "online").length;
+  return { active: active || nodes.length, total: nodes.length };
+}
+async function fetchActiveUsers(client) {
+  return countRecords(client, "sys_user", "active=true");
+}
+async function fetchCustomApps(client) {
+  return countRecords(client, "sys_app", "active=true^scopeSTARTSWITHx_");
+}
+async function fetchCustomTables(client) {
+  return countRecords(client, "sys_db_object", "nameSTARTSWITHx_");
+}
+async function fetchInProgressUpdateSets(client) {
+  return client.queryTable("sys_update_set", {
+    sysparmQuery: "state=in progress^ORDERBYDESCsys_created_on",
+    sysparmFields: "name,sys_created_by",
+    sysparmLimit: 5
+  });
+}
+async function fetchSyslogErrors(client) {
+  const [count, recent] = await Promise.all([
+    countRecords(client, "syslog", "level=error^sys_created_on>javascript:gs.hoursAgo(1)"),
+    client.queryTable("syslog", {
+      sysparmQuery: "level=error^sys_created_on>javascript:gs.hoursAgo(1)^ORDERBYDESCsys_created_on",
+      sysparmFields: "sys_created_on,message",
+      sysparmLimit: 3
+    })
+  ]);
+  return { count, recent };
+}
+async function fetchSchedulerErrors(client) {
+  const [count, recent] = await Promise.all([
+    countRecords(client, "syslog", "level=error^sys_created_on>javascript:gs.hoursAgo(24)^source=SCHEDULER"),
+    client.queryTable("syslog", {
+      sysparmQuery: "level=error^sys_created_on>javascript:gs.hoursAgo(24)^source=SCHEDULER^ORDERBYDESCsys_created_on",
+      sysparmFields: "message",
+      sysparmLimit: 3
+    })
+  ]);
+  return { count, recent };
+}
+function statusCommand() {
+  const cmd = new Command11("status").description("Show a health and stats overview of the active instance").option("--no-errors", "Skip the syslog error sections (faster for restricted users)").option("--debug", "Print raw property values to help diagnose N/A sections").action(async (opts) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora10("Fetching instance stats...").start();
+    const [
+      versionResult,
+      nodesResult,
+      activeUsersResult,
+      customAppsResult,
+      customTablesResult,
+      updateSetsResult,
+      syslogResult,
+      schedulerResult
+    ] = await Promise.allSettled([
+      fetchVersion(client, opts.debug),
+      fetchNodes(client),
+      fetchActiveUsers(client),
+      fetchCustomApps(client),
+      fetchCustomTables(client),
+      fetchInProgressUpdateSets(client),
+      opts.errors ? fetchSyslogErrors(client) : Promise.reject(new Error("skipped")),
+      opts.errors ? fetchSchedulerErrors(client) : Promise.reject(new Error("skipped"))
+    ]);
+    spinner.stop();
+    console.log();
+    console.log(DIVIDER);
+    console.log(`  ${chalk11.bold("snow-cli")}  \xB7  ${chalk11.cyan(instance.alias)}  ${chalk11.dim(instance.url)}`);
+    console.log(DIVIDER);
+    section("Instance");
+    if (versionResult.status === "fulfilled") {
+      row("Version", chalk11.white(versionResult.value.version));
+      if (versionResult.value.date) {
+        row("Last updated", chalk11.dim(versionResult.value.date));
+      }
+    } else {
+      const reason = opts.debug ? NA + chalk11.dim(`  (${versionResult.reason?.message ?? "unknown error"})`) : NA;
+      row("Version", reason);
+    }
+    if (nodesResult.status === "fulfilled") {
+      const { active, total } = nodesResult.value;
+      const nodeStr = total === 0 ? NA : total === 1 ? chalk11.white("1 (single-node)") : `${chalk11.white(String(active))} active / ${total} total`;
+      row("Cluster nodes", nodeStr);
+    } else {
+      row("Cluster nodes", NA);
+    }
+    section("Users");
+    if (activeUsersResult.status === "fulfilled") {
+      row("Active users", chalk11.white(activeUsersResult.value.toLocaleString()));
+    } else {
+      row("Active users", NA);
+    }
+    section("Development");
+    if (customAppsResult.status === "fulfilled") {
+      row("Custom apps", chalk11.white(String(customAppsResult.value)));
+    } else {
+      row("Custom apps", NA);
+    }
+    if (customTablesResult.status === "fulfilled") {
+      row("Custom tables", chalk11.white(String(customTablesResult.value)));
+    } else {
+      row("Custom tables", NA);
+    }
+    if (updateSetsResult.status === "fulfilled") {
+      const sets = updateSetsResult.value;
+      const countStr = sets.length === 0 ? chalk11.dim("none") : sets.length === 5 ? chalk11.yellow(`${sets.length}+ in progress`) : chalk11.white(`${sets.length} in progress`);
+      row("Update sets", countStr);
+      for (const s of sets) {
+        const truncName = s.name.length > 32 ? s.name.slice(0, 31) + "\u2026" : s.name;
+        console.log(`  ${"".padEnd(22)}${chalk11.dim("\u2022 ")}${truncName}  ${chalk11.dim(s.sys_created_by)}`);
+      }
+    } else {
+      row("Update sets", NA);
+    }
+    if (!opts.errors) {
+      console.log();
+      console.log(chalk11.dim("  (error sections skipped \u2014 pass --errors to include)"));
+    } else {
+      section("Syslog errors  (last hour)");
+      if (syslogResult.status === "fulfilled") {
+        const { count, recent } = syslogResult.value;
+        const countColor = count === 0 ? chalk11.green : count < 10 ? chalk11.yellow : chalk11.red;
+        row("Error count", countColor(String(count)));
+        for (const e of recent) {
+          const time = e.sys_created_on.slice(11, 19);
+          const msg = e.message.replace(/\s+/g, " ").trim().slice(0, 60);
+          console.log(`  ${"".padEnd(22)}${chalk11.dim(`[${time}]`)} ${msg}`);
+        }
+      } else {
+        row("Error count", NA + chalk11.dim("  (no access to syslog)"));
+      }
+      section("Scheduler errors  (last 24h)");
+      if (schedulerResult.status === "fulfilled") {
+        const { count, recent } = schedulerResult.value;
+        const countColor = count === 0 ? chalk11.green : count < 5 ? chalk11.yellow : chalk11.red;
+        row("Failed jobs", countColor(String(count)));
+        for (const e of recent) {
+          const msg = e.message.replace(/\s+/g, " ").trim().slice(0, 60);
+          console.log(`  ${"".padEnd(22)}${chalk11.dim("\u2022 ")}${msg}`);
+        }
+      } else {
+        row("Failed jobs", NA + chalk11.dim("  (no access to syslog)"));
+      }
+    }
+    console.log();
+    console.log(DIVIDER);
+    console.log();
+  });
+  return cmd;
+}
+
 // src/index.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join7, dirname as dirname2 } from "path";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 function getVersion() {
   try {
     const pkg = JSON.parse(
-      readFileSync4(join4(__dirname2, "..", "package.json"), "utf-8")
+      readFileSync6(join7(__dirname2, "..", "package.json"), "utf-8")
     );
     return pkg.version;
   } catch {
     return "0.0.0";
   }
 }
-var program = new Command7();
-program.name("snow").description(chalk7.bold("snow") + " \u2014 ServiceNow CLI: query tables, edit scripts, and generate apps with AI").version(getVersion(), "-v, --version", "Output the current version").addHelpText(
+var program = new Command12();
+program.name("snow").description(chalk12.bold("snow") + " \u2014 ServiceNow CLI: query tables, edit scripts, and generate apps with AI").version(getVersion(), "-v, --version", "Output the current version").addHelpText(
   "after",
   `
-${chalk7.bold("Examples:")}
-  ${chalk7.dim("# Add a ServiceNow instance")}
+${chalk12.bold("Examples:")}
+  ${chalk12.dim("# Add a ServiceNow instance")}
   snow instance add
 
-  ${chalk7.dim("# Query records from a table")}
+  ${chalk12.dim("# Query records from a table")}
   snow table get incident -q "active=true" -l 10
 
-  ${chalk7.dim("# View the schema for a table")}
+  ${chalk12.dim("# View the schema for a table")}
   snow schema incident
 
-  ${chalk7.dim("# Pull a script field, edit it, and push back")}
+  ${chalk12.dim("# Pull a script field, edit it, and push back")}
   snow script pull sys_script_include <sys_id> script
 
-  ${chalk7.dim("# Configure an LLM provider (OpenAI, Anthropic, xAI/Grok, or Ollama)")}
+  ${chalk12.dim("# Configure an LLM provider (OpenAI, Anthropic, xAI/Grok, or Ollama)")}
   snow provider set openai
   snow provider set anthropic
   snow provider set xai
   snow provider set ollama --model llama3
 
-  ${chalk7.dim("# Generate a ServiceNow app and export as an update set XML")}
+  ${chalk12.dim("# Generate a ServiceNow app and export as an update set XML")}
   snow ai build "Create a script include that auto-routes incidents by category"
 
-  ${chalk7.dim("# Generate and immediately push artifacts to the active instance")}
+  ${chalk12.dim("# Generate and immediately push artifacts to the active instance")}
   snow ai build "Create a business rule that sets priority on incident insert" --push
 
-  ${chalk7.dim("# Interactive multi-turn app builder")}
+  ${chalk12.dim("# Interactive multi-turn app builder")}
   snow ai chat
 `
 );
@@ -3013,6 +4818,11 @@ program.addCommand(instanceCommand());
 program.addCommand(tableCommand());
 program.addCommand(schemaCommand());
 program.addCommand(scriptCommand());
+program.addCommand(bulkCommand());
+program.addCommand(userCommand());
+program.addCommand(attachmentCommand());
+program.addCommand(updatesetCommand());
+program.addCommand(statusCommand());
 program.addCommand(providerCommand());
 program.addCommand(aiCommand());
 program.command("instances", { hidden: true }).description("Alias for `snow instance list`").action(() => {
@@ -3020,6 +4830,6 @@ program.command("instances", { hidden: true }).description("Alias for `snow inst
   sub.parse(["node", "snow", "list"]);
 });
 program.parseAsync(process.argv).catch((err) => {
-  console.error(chalk7.red(err instanceof Error ? err.message : String(err)));
+  console.error(chalk12.red(err instanceof Error ? err.message : String(err)));
   process.exit(1);
 });