@stndrds/cli 1.0.0-alpha.261 → 1.0.0-alpha.264

package/dist/bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/program.ts
-import chalk9 from "chalk";
+import chalk7 from "chalk";
 import { Command } from "commander";
 
 // src/client.ts
@@ -216,25 +216,6 @@ function formatOutput(data, format) {
 `);
 }
 
-// src/commands/autofill.ts
-function registerAutofillCommand(program) {
-  const autofill = program.command("autofill").description("AI attribute autofill (backfill empty record fields)");
-  autofill.command("backfill").description("Dry-run estimate (default) or enqueue an autofill backfill job").requiredOption("--objects <ids>", "comma-separated object IDs to backfill").option("--max-records <n>", "cap the number of records processed").option("--confirm", "enqueue the job instead of returning a dry-run estimate").action(
-    async (opts, cmd) => {
-      const objectIds = parseCsvList(opts.objects);
-      if (objectIds.length === 0) {
-        throw new Error("--objects requires at least one object ID");
-      }
-      const client = getClientFromCommand(cmd);
-      const body = { objectIds };
-      if (opts.maxRecords) body.maxRecords = Number(opts.maxRecords);
-      if (opts.confirm) body.confirm = true;
-      const result = await client.post("/autofill/backfill", body);
-      formatOutput(result, getFormat(cmd));
-    }
-  );
-}
-
 // src/commands/bundles.ts
 function registerBundlesCommand(program) {
   const bundles = program.command("bundles").description("Manage system bundles assigned to the current tenant (admin)");
@@ -305,354 +286,6 @@ function registerConnectorsCommand(program) {
   });
 }
 
-// src/commands/diff.ts
-import chalk4 from "chalk";
-
-// src/drift/engine.ts
-import { createHash } from "crypto";
-import { ValidationError, canonicalStringify, viewSyncPayload } from "@stndrds/schema";
-var SUPPORTED_HASH_VERSION = 1;
-var CONFIG_SUBKEYS = ["tabs", "defaultFilters", "sidePanel"];
-function viewSyncHashOf(view) {
-  return createHash("sha256").update(canonicalStringify(viewSyncPayload(view))).digest("hex");
-}
-function viewKey(object, name, type) {
-  return `${object}:${name}:${type}`;
-}
-function classifyViewDrift(input2) {
-  const { codeHash, dbHash, baselineHash, resolutions } = input2;
-  if (baselineHash === null) {
-    return codeHash === dbHash ? "in-sync" : "runtime-diverged";
-  }
-  const codeMoved = codeHash !== baselineHash;
-  const dbMoved = dbHash !== baselineHash;
-  if (!(codeMoved || dbMoved)) {
-    return "in-sync";
-  }
-  if (codeMoved && !dbMoved) {
-    return "code-changed";
-  }
-  if (!codeMoved && dbMoved) {
-    return "runtime-diverged";
-  }
-  const hasExactResolution = resolutions.some(
-    (resolution) => resolution.codeHash === codeHash && resolution.dbHash === dbHash
-  );
-  return hasExactResolution ? "conflict-resolved" : "conflict";
-}
-function computeChangedFields(localView, entry) {
-  const changedFields = [];
-  if (canonicalStringify(localView.label) !== canonicalStringify(entry.label)) {
-    changedFields.push("label");
-  }
-  if ((localView.description ?? null) !== entry.description) {
-    changedFields.push("description");
-  }
-  if ((localView.icon ?? null) !== entry.icon) {
-    changedFields.push("icon");
-  }
-  if ((localView.default ?? false) !== entry.default) {
-    changedFields.push("default");
-  }
-  if (canonicalStringify(localView.metadata ?? null) !== canonicalStringify(entry.metadata)) {
-    changedFields.push("metadata");
-  }
-  const localConfig = localView.config;
-  const dbConfig = entry.config;
-  for (const key of CONFIG_SUBKEYS) {
-    const localValue = localConfig[key] ?? null;
-    const dbValue = dbConfig[key] ?? null;
-    if (canonicalStringify(localValue) !== canonicalStringify(dbValue)) {
-      changedFields.push(`config.${key}`);
-    }
-  }
-  return changedFields;
-}
-function computeDriftReport(local, state) {
-  if (state.hashVersion !== SUPPORTED_HASH_VERSION) {
-    throw new ValidationError(
-      `Server hash version ${state.hashVersion} is not supported by this CLI (expected ${SUPPORTED_HASH_VERSION}). Upgrade the CLI or the server so both sides compute comparable hashes.`,
-      []
-    );
-  }
-  const stateByKey = /* @__PURE__ */ new Map();
-  for (const entry of state.views) {
-    stateByKey.set(viewKey(entry.object, entry.name, entry.type), entry);
-  }
-  const localKeys = /* @__PURE__ */ new Set();
-  const views = [];
-  const created = [];
-  for (const localView of local.views) {
-    const key = viewKey(localView.object, localView.name, localView.type);
-    localKeys.add(key);
-    const entry = stateByKey.get(key);
-    if (!entry) {
-      created.push({ key, object: localView.object, name: localView.name, type: localView.type });
-      continue;
-    }
-    const codeHash = viewSyncHashOf(localView);
-    const driftState = classifyViewDrift({
-      codeHash,
-      dbHash: entry.dbHash,
-      baselineHash: entry.baselineHash,
-      resolutions: entry.resolutions
-    });
-    views.push({
-      key,
-      type: localView.type,
-      state: driftState,
-      viewId: entry.viewId,
-      codeHash,
-      dbHash: entry.dbHash,
-      changedFields: computeChangedFields(localView, entry)
-    });
-  }
-  const orphans = state.views.filter((entry) => !localKeys.has(viewKey(entry.object, entry.name, entry.type))).map((entry) => ({
-    key: viewKey(entry.object, entry.name, entry.type),
-    viewId: entry.viewId,
-    object: entry.object,
-    name: entry.name,
-    type: entry.type
-  }));
-  const hasUnresolvedConflict = views.some((view) => view.state === "conflict");
-  const exitCode = hasUnresolvedConflict || state.drift.hasUnexpectedDrift ? 1 : 0;
-  return { views, created, orphans, schema: state.drift, exitCode };
-}
-
-// src/schema-loader.ts
-import { dirname, resolve } from "path";
-import { ValidationError as ValidationError2 } from "@stndrds/schema";
-import * as esbuild from "esbuild";
-async function loadLocalRegistry(entryPath) {
-  const absoluteEntryPath = resolve(entryPath);
-  const virtualEntry = [
-    `import ${JSON.stringify(absoluteEntryPath)};`,
-    `export { registry, viewRegistry } from "@stndrds/schema";`
-  ].join("\n");
-  let bundledCode;
-  try {
-    const result = await esbuild.build({
-      stdin: {
-        contents: virtualEntry,
-        resolveDir: dirname(absoluteEntryPath),
-        loader: "ts",
-        sourcefile: "standards-diff-virtual-entry.ts"
-      },
-      bundle: true,
-      platform: "node",
-      format: "esm",
-      write: false,
-      external: ["node:*"],
-      logLevel: "silent"
-    });
-    const outputFile = result.outputFiles[0];
-    if (!outputFile) {
-      throw entryLoadError(absoluteEntryPath, new Error("esbuild produced no output"));
-    }
-    bundledCode = outputFile.text;
-  } catch (error) {
-    throw entryLoadError(absoluteEntryPath, error);
-  }
-  let loadedModule;
-  try {
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(bundledCode, "utf-8").toString("base64")}`;
-    loadedModule = await import(dataUrl);
-  } catch (error) {
-    throw entryLoadError(absoluteEntryPath, error);
-  }
-  return {
-    objects: loadedModule.registry.getAll(),
-    views: loadedModule.viewRegistry.getAll()
-  };
-}
-function entryLoadError(entryPath, cause) {
-  if (cause instanceof ValidationError2) {
-    return cause;
-  }
-  const causeMessage = cause instanceof Error ? cause.message : String(cause);
-  return new ValidationError2(
-    `Schema entry failed to load in isolation: ${entryPath}
-${causeMessage}`,
-    []
-  );
-}
-
-// src/standards-config.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { ValidationError as ValidationError3 } from "@stndrds/schema";
-
-// src/standards-dir.ts
-import { existsSync } from "fs";
-import { join } from "path";
-function resolveStandardsDir(startDir = process.cwd()) {
-  let dir = startDir;
-  while (true) {
-    if (existsSync(join(dir, "package.json"))) {
-      return join(dir, ".standards");
-    }
-    const parent = join(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return join(startDir, ".standards");
-}
-
-// src/standards-config.ts
-function readStandardsProjectConfig(startDir = process.cwd()) {
-  const standardsDir = resolveStandardsDir(startDir);
-  const projectRoot = dirname2(standardsDir);
-  const configPath = join2(standardsDir, "config.json");
-  if (!existsSync2(configPath)) {
-    throw new ValidationError3(
-      `No Standards project config found at ${configPath}. Run "standards init" to create one.`,
-      []
-    );
-  }
-  const raw = readFileSync(configPath, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    const causeMessage = error instanceof Error ? error.message : String(error);
-    throw new ValidationError3(`${configPath} is not valid JSON: ${causeMessage}`, []);
-  }
-  if (typeof parsed.schemaEntry !== "string" || parsed.schemaEntry.length === 0) {
-    throw new ValidationError3(
-      `${configPath} is missing required "schemaEntry" field. Run "standards init" to (re)create it.`,
-      []
-    );
-  }
-  return {
-    schemaEntry: resolve2(projectRoot, parsed.schemaEntry)
-  };
-}
-
-// src/commands/diff.ts
-async function runDiffCommand(deps) {
-  const loadRegistry = deps.loadRegistry ?? loadLocalRegistry;
-  let local;
-  let state;
-  try {
-    local = await loadRegistry(deps.schemaEntry);
-    state = await deps.client.get("/schema/state");
-  } catch (error) {
-    return { exitCode: 2, errorMessage: messageOf(error) };
-  }
-  try {
-    const report = computeDriftReport(local, state);
-    return { exitCode: report.exitCode, report, state };
-  } catch (error) {
-    return { exitCode: 2, errorMessage: messageOf(error) };
-  }
-}
-function renderCreatedLine(view) {
-  return chalk4.dim(`+ view ${view.key} \u2014 will be created`);
-}
-function renderOrphanLine(view) {
-  return chalk4.dim(`\u25CB view ${view.key} \u2014 removed from code, still in DB`);
-}
-function renderViewLine(entry) {
-  const fields = entry.changedFields.join(", ");
-  if (entry.state === "code-changed") {
-    return chalk4.green(`~ view ${entry.key} \u2014 will apply on next deploy (code changed: ${fields})`);
-  }
-  if (entry.state === "runtime-diverged") {
-    return chalk4.yellow(
-      `\u2260 view ${entry.key} \u2014 runtime divergence (users changed: ${fields}) \u2014 promote or leave`
-    );
-  }
-  if (entry.state === "conflict") {
-    return chalk4.red(
-      `\u26A0 CONFLICT view ${entry.key} \u2014 next deploy WOULD DESTROY runtime changes (${fields}) \u2014 run "standards pull"`
-    );
-  }
-  return chalk4.green(`\u2713 resolved conflict view ${entry.key} \u2014 code will apply on next deploy`);
-}
-function relationTag(attr) {
-  return attr.isRelation ? " [relation]" : "";
-}
-function attrInline(attr) {
-  const suffix = attr.tolerated ? ", tolerated" : `${relationTag(attr)}, label: "${attr.label}"`;
-  return `   \xB7 ${attr.name} (${attr.type}${suffix})`;
-}
-function renderSchemaDriftLines(schema) {
-  const lines = [];
-  for (const obj of schema.customObjects) {
-    lines.push(chalk4.yellow(`\u26A0  ${obj.name} (${obj.label}) \u2014 custom object, not in code`));
-    lines.push(chalk4.dim('   \u2192 Run "standards pull" to promote or leave.'));
-  }
-  for (const entry of schema.systemObjectDrift) {
-    const unexpected = entry.sealed ? entry.customAttributes.filter((a) => !a.tolerated) : [];
-    const tolerated = entry.customAttributes.filter((a) => a.tolerated);
-    if (entry.sealed && unexpected.length > 0) {
-      lines.push(
-        chalk4.red(
-          `\u2717  ${entry.objectName} \u2014 ${unexpected.length} unexpected custom attribute(s) (sealed object)`
-        )
-      );
-      for (const a of unexpected) lines.push(chalk4.red(attrInline(a)));
-      lines.push(chalk4.dim('   \u2192 Run "standards pull" to promote or tolerate these attributes.'));
-      if (tolerated.length > 0) {
-        lines.push(chalk4.dim(`   Also tolerated: ${tolerated.length} attribute(s)`));
-        for (const a of tolerated) lines.push(chalk4.dim(attrInline(a)));
-      }
-      continue;
-    }
-    const okAttrs = entry.sealed ? tolerated : entry.customAttributes;
-    if (okAttrs.length === 0) continue;
-    const okSuffix = entry.sealed ? "tolerated custom attribute(s) (sealed)" : "custom attribute(s) (extensible)";
-    lines.push(chalk4.green(`\u2713  ${entry.objectName} \u2014 ${okAttrs.length} ${okSuffix}`));
-    for (const a of okAttrs) lines.push(chalk4.dim(attrInline(a)));
-  }
-  return lines;
-}
-function renderDiffLines(report) {
-  const lines = [];
-  for (const view of report.created) lines.push(renderCreatedLine(view));
-  for (const view of report.views) {
-    if (view.state === "in-sync") continue;
-    lines.push(renderViewLine(view));
-  }
-  for (const view of report.orphans) lines.push(renderOrphanLine(view));
-  lines.push(...renderSchemaDriftLines(report.schema));
-  return lines;
-}
-function formatDiffReport(report, format) {
-  if (format === "json") {
-    return JSON.stringify(report, null, 2);
-  }
-  const lines = renderDiffLines(report);
-  return lines.length > 0 ? lines.join("\n") : chalk4.green("\u2713 No drift detected \u2014 next deploy is a no-op.");
-}
-function resolveEffectiveFormat(cmd) {
-  const format = getFormat(cmd);
-  const formatExplicit = cmd.getOptionValueSourceWithGlobals("format") !== "default";
-  return format === "json" && !formatExplicit ? "table" : format;
-}
-function registerDiffCommand(program) {
-  program.command("diff").description("Show what the next deploy will do to the runtime schema and views").action(async (_opts, cmd) => {
-    let client;
-    let schemaEntry;
-    try {
-      client = getClientFromCommand(cmd);
-      schemaEntry = readStandardsProjectConfig().schemaEntry;
-    } catch (error) {
-      console.error(chalk4.red(`\u2717 ${messageOf(error)}`));
-      process.exit(2);
-      return;
-    }
-    const result = await runDiffCommand({ client, schemaEntry });
-    if (result.exitCode === 2) {
-      console.error(chalk4.red(`\u2717 ${result.errorMessage}`));
-      process.exit(2);
-      return;
-    }
-    console.info(formatDiffReport(result.report, resolveEffectiveFormat(cmd)));
-    process.exit(result.exitCode);
-  });
-}
-
 // src/commands/documents.ts
 var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"];
 function formatFileSize(bytes) {
@@ -770,101 +403,8 @@ function registerFoldersCommand(program) {
   });
 }
 
-// src/commands/init.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname as dirname3, join as join3, relative, resolve as resolve3 } from "path";
-import { fileURLToPath } from "url";
-import { ValidationError as ValidationError4 } from "@stndrds/schema";
-import chalk5 from "chalk";
-var PROMOTIONS_GITIGNORE_LINE = ".standards/promotions/";
-function resolveAssetPath(filename) {
-  const moduleDir = dirname3(fileURLToPath(import.meta.url));
-  const candidates = [
-    join3(moduleDir, "..", "assets", filename),
-    join3(moduleDir, "assets", filename)
-  ];
-  const found = candidates.find((candidate) => existsSync3(candidate));
-  if (!found) {
-    throw new ValidationError4(
-      `Could not locate bundled asset "${filename}" (checked: ${candidates.join(", ")}). This is a packaging bug in @stndrds/cli.`,
-      []
-    );
-  }
-  return found;
-}
-async function runInitCommand(options, deps = {}) {
-  const cwd = deps.cwd ?? process.cwd();
-  await loadLocalRegistry(options.entry);
-  const standardsDir = resolveStandardsDir(cwd);
-  const projectRoot = dirname3(standardsDir);
-  const entryAbsolute = resolve3(cwd, options.entry);
-  const schemaEntry = relative(projectRoot, entryAbsolute);
-  mkdirSync(standardsDir, { recursive: true });
-  const configPath = join3(standardsDir, "config.json");
-  writeFileSync(configPath, `${JSON.stringify({ schemaEntry }, null, 2)}
-`, "utf-8");
-  const gitignorePath = join3(projectRoot, ".gitignore");
-  const gitignore = updateGitignore(gitignorePath);
-  const skillDir = join3(projectRoot, ".claude", "skills", "standards-pull");
-  mkdirSync(skillDir, { recursive: true });
-  const skillPath = join3(skillDir, "SKILL.md");
-  copyFileSync(resolveAssetPath("standards-pull-skill.md"), skillPath);
-  let workflowPath;
-  if (options.ci) {
-    const workflowDir = join3(projectRoot, ".github", "workflows");
-    mkdirSync(workflowDir, { recursive: true });
-    workflowPath = join3(workflowDir, "standards-drift.yml");
-    copyFileSync(resolveAssetPath("standards-drift.yml"), workflowPath);
-  }
-  return { standardsDir, configPath, skillPath, gitignore, workflowPath };
-}
-function updateGitignore(gitignorePath) {
-  if (!existsSync3(gitignorePath)) {
-    return "not-found";
-  }
-  const content = readFileSync2(gitignorePath, "utf-8");
-  const alreadyPresent = content.split("\n").some((line) => line.trim() === PROMOTIONS_GITIGNORE_LINE);
-  if (alreadyPresent) {
-    return "already-present";
-  }
-  const withTrailingNewline = content.length === 0 || content.endsWith("\n") ? content : `${content}
-`;
-  writeFileSync(gitignorePath, `${withTrailingNewline}${PROMOTIONS_GITIGNORE_LINE}
-`, "utf-8");
-  return "updated";
-}
-function registerInitCommand(program) {
-  program.command("init").description(
-    "Bootstrap this project: .standards/config.json, the standards-pull skill, and (optionally) a CI drift check. Re-running restores the managed skill/workflow assets verbatim (overwriting local edits to them); .gitignore is the only step that's merge-safe."
-  ).requiredOption("--entry <path>", "Path to the schema entry file (e.g. src/schema/index.ts)").option("--ci", "Also write .github/workflows/standards-drift.yml").action(async (opts) => {
-    let result;
-    try {
-      result = await runInitCommand({ entry: opts.entry, ci: opts.ci });
-    } catch (error) {
-      console.error(chalk5.red(`\u2717 ${messageOf(error)}`));
-      process.exit(2);
-      return;
-    }
-    console.info(chalk5.green(`\u2713 Wrote ${result.configPath}`));
-    console.info(chalk5.green(`\u2713 Installed skill at ${result.skillPath}`));
-    if (result.gitignore === "updated") {
-      console.info(chalk5.green(`\u2713 Added "${PROMOTIONS_GITIGNORE_LINE}" to .gitignore`));
-    } else if (result.gitignore === "not-found") {
-      console.info(
-        chalk5.dim(
-          `  No .gitignore found \u2014 remember to ignore "${PROMOTIONS_GITIGNORE_LINE}" yourself.`
-        )
-      );
-    }
-    if (result.workflowPath) {
-      console.info(chalk5.green(`\u2713 Wrote ${result.workflowPath}`));
-    }
-    console.info(chalk5.dim('Run "standards diff" to check for drift.'));
-  });
-}
-
 // src/commands/keys.ts
-import chalk6 from "chalk";
+import chalk4 from "chalk";
 function registerKeysCommand(program) {
   const keys = program.command("keys").description("Manage Standards API keys");
   keys.command("list").description("List API keys").action(async (_opts, cmd) => {
@@ -891,267 +431,120 @@ function registerKeysCommand(program) {
     }
     const client = getClientFromCommand(cmd);
     await client.delete(`/api-keys/${id}`);
-    process.stdout.write(`${chalk6.green("\u2713")} API key ${id} revoked.
+    process.stdout.write(`${chalk4.green("\u2713")} API key ${id} revoked.
 `);
   });
 }
 
 // src/commands/pull.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4, join as join4 } from "path";
-import * as prompts from "@clack/prompts";
-import chalk7 from "chalk";
-function handlePromote(entry, ctx) {
-  const viewState = ctx.viewStateByKey.get(entry.key);
-  if (!viewState) {
-    return {
-      ok: false,
-      message: `No runtime state found for view "${entry.key}" \u2014 cannot promote. The pull context must be built from the same schema state as the drift report.`
-    };
-  }
-  try {
-    const runtimeConfig = {
-      object: viewState.object,
-      name: viewState.name,
-      type: viewState.type,
-      label: viewState.label,
-      description: viewState.description,
-      icon: viewState.icon,
-      default: viewState.default,
-      metadata: viewState.metadata,
-      config: viewState.config
-    };
-    const builderHint = findBuilderFileHint(
-      ctx.schemaEntry,
-      viewState.object,
-      viewState.name,
-      viewState.type
-    );
-    const promotionsDir = join4(ctx.standardsDir, "promotions");
-    mkdirSync2(promotionsDir, { recursive: true });
-    const filePath = join4(
-      promotionsDir,
-      `${viewState.object}-${viewState.name}-${viewState.type}.md`
-    );
-    const content = [
-      `# Promote view \`${entry.key}\``,
-      "",
-      "Runtime users changed this view since it was last synced from code. To keep",
-      "their changes, fold this configuration into the view's builder call below.",
-      "",
-      "## Runtime config",
-      "",
-      "```json",
-      JSON.stringify(runtimeConfig, null, 2),
-      "```",
-      "",
-      "## Builder file",
-      "",
-      builderHint,
-      "",
-      "---",
-      "",
-      "Hand this file to your agent, then re-run `standards diff`.",
-      ""
-    ].join("\n");
-    writeFileSync2(filePath, content, "utf-8");
-    return { ok: true, filePath };
-  } catch (error) {
-    return {
-      ok: false,
-      message: `Failed to write promotion file for ${entry.key}: ${messageOf(error)}`
-    };
-  }
-}
-async function handleOverwrite(entry, _ctx, client) {
-  try {
-    await client.post("/schema/resolutions", {
-      viewId: entry.viewId,
-      codeHash: entry.codeHash,
-      dbHash: entry.dbHash
-    });
-    return { ok: true };
-  } catch (error) {
-    if (error instanceof ApiClientError && error.statusCode === 400) {
-      return {
-        ok: false,
-        reason: "stale",
-        message: `View ${entry.key} changed since the diff \u2014 re-run "standards diff".`
-      };
-    }
-    return {
-      ok: false,
-      reason: "infra",
-      message: `Failed to overwrite ${entry.key}: ${messageOf(error)}`
-    };
-  }
-}
-var BUILDER_SOURCE_EXTENSIONS = [".ts", ".tsx"];
-var BUILDER_SEARCH_IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
-function collectSourceFiles(dir) {
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    if (BUILDER_SEARCH_IGNORED_DIRS.has(entry.name)) continue;
-    const fullPath = join4(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectSourceFiles(fullPath));
-    } else if (BUILDER_SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findBuilderFileHint(schemaEntry, object, name, type) {
-  const builderCall = type === "detail" ? "detailView" : "listView";
-  const pattern = new RegExp(`${builderCall}\\(\\s*["'\`]${escapeRegExp(name)}["'\`]`);
-  const searchDir = dirname4(schemaEntry);
-  for (const filePath of collectSourceFiles(searchDir)) {
-    const lines = readFileSync3(filePath, "utf-8").split("\n");
-    const lineIndex = lines.findIndex((line) => pattern.test(line));
-    if (lineIndex !== -1) {
-      return `\`${filePath}:${lineIndex + 1}\`
+import chalk5 from "chalk";
 
-\`\`\`ts
-${lines[lineIndex]?.trim()}
-\`\`\``;
-    }
-  }
-  return `No \`${builderCall}("${name}", ...)\` call found under ${searchDir} \u2014 search manually for the "${object}" object's view builders.`;
-}
-function entriesNeedingDecisionOf(result) {
-  if (result.exitCode === 2) return [];
-  const conflicts = result.report.views.filter((view) => view.state === "conflict");
-  const diverged = result.report.views.filter((view) => view.state === "runtime-diverged");
-  return [...conflicts, ...diverged];
+// src/drift/reconciliation-prompt.ts
+var PREAMBLE = [
+  "# Standards schema reconciliation",
+  "",
+  "The deployed runtime has drifted from code. Walk each item **with the developer**,",
+  "then edit the fluent builders. The pre-deploy gate (STANDARDS_SYNC_CHECK=1) applies",
+  "your choices at deploy. Loop until the gate reports clean. Never make a destructive",
+  "choice without the developer's explicit confirmation.",
+  ""
+].join("\n");
+function isViewDiverged(view) {
+  return view.baselineHash !== null && view.dbHash !== view.baselineHash;
+}
+function hasReconcilableDrift(state) {
+  return state.drift.customObjects.length > 0 || state.drift.systemObjectDrift.length > 0 || state.views.some(isViewDiverged);
+}
+function renderAttribute(objectName, sealed, attr) {
+  const action = attr.tolerated ? "Already tolerated \u2014 declare it in the builder to make it a system attribute, or leave tolerated." : `Choose: **declare** \`${attr.name}\` on the \`${objectName}\` builder (\u2192 becomes system on next sync), OR **tolerate** it \u2014 add \`.tolerate(["${attr.name}"])\`${sealed ? " (required: the object is sealed)" : ""}.`;
+  return `- \`${objectName}.${attr.name}\` (${attr.type})
+  ${action}`;
+}
+function renderView(view) {
+  const d = view.delta;
+  const lines = [`### view \`${view.object}:${view.name}:${view.type}\``];
+  if (d) {
+    if (d.tabsAdded.length) lines.push(`- tabs added at runtime: ${d.tabsAdded.join(", ")}`);
+    if (d.tabsRemoved.length) lines.push(`- tabs removed at runtime: ${d.tabsRemoved.join(", ")}`);
+    for (const t of d.tabsChanged)
+      lines.push(`- tab "${t.name}" changed: ${t.changedKeys.join(", ")}`);
+    if (d.topLevelChanged.length) lines.push(`- changed: ${d.topLevelChanged.join(", ")}`);
+  }
+  lines.push(
+    "",
+    "Runtime config to fold into the builder call (or record an explicit resolution to let code win):",
+    "```json",
+    JSON.stringify(view.config, null, 2),
+    "```"
+  );
+  return lines.join("\n");
 }
-async function runPullCommand(deps, decide) {
-  const initial = await runDiffCommand(deps);
-  if (initial.exitCode === 2) {
-    return { initial, outcomes: [], residual: initial };
+function renderReconciliationPrompt(state) {
+  if (!hasReconcilableDrift(state))
+    return `${PREAMBLE}
+No drift to reconcile \u2014 the runtime matches code.
+`;
+  const parts = [PREAMBLE];
+  for (const obj of state.drift.customObjects) {
+    parts.push(
+      `## Custom object \`${obj.name}\` (runtime-only)
+Add an \`object("${obj.name}")\` builder, then its attributes:`
+    );
+    for (const a of obj.attributes) parts.push(renderAttribute(obj.name, false, a));
   }
-  const entriesNeedingDecision = entriesNeedingDecisionOf(initial);
-  const viewStateByKey = new Map(
-    initial.state.views.map((entry) => [viewKey(entry.object, entry.name, entry.type), entry])
-  );
-  const ctx = {
-    viewStateByKey,
-    schemaEntry: deps.schemaEntry,
-    standardsDir: deps.standardsDir
-  };
-  const outcomes = [];
-  for (const entry of entriesNeedingDecision) {
-    const decision = await decide(entry);
-    if (decision === "promote") {
-      const promote = handlePromote(entry, ctx);
-      outcomes.push({ entry, decision, promote });
-      if (!promote.ok) {
-        return { initial, outcomes, residual: { exitCode: 2, errorMessage: promote.message } };
-      }
-      continue;
-    }
-    if (decision === "overwrite") {
-      const overwrite = await handleOverwrite(entry, ctx, deps.client);
-      outcomes.push({ entry, decision, overwrite });
-      if (!overwrite.ok && overwrite.reason === "infra") {
-        return { initial, outcomes, residual: { exitCode: 2, errorMessage: overwrite.message } };
-      }
-      continue;
-    }
-    outcomes.push({ entry, decision: "skip" });
+  for (const entry of state.drift.systemObjectDrift) {
+    parts.push(`## \`${entry.objectName}\`${entry.sealed ? " (sealed)" : ""} \u2014 custom attributes`);
+    for (const a of entry.customAttributes)
+      parts.push(renderAttribute(entry.objectName, entry.sealed, a));
   }
-  const residual = await runDiffCommand(deps);
-  return { initial, outcomes, residual };
-}
-function decisionOptionsFor(entry) {
-  const options = [
-    {
-      value: "promote",
-      label: "Promote",
-      hint: "write the runtime config to .standards/promotions/"
-    }
-  ];
-  if (entry.state === "conflict") {
-    options.push({
-      value: "overwrite",
-      label: "Overwrite",
-      hint: "accept the code version, discard the runtime change"
-    });
+  const divergedViews = state.views.filter(isViewDiverged);
+  if (divergedViews.length) {
+    parts.push("## Drifted views");
+    for (const v of divergedViews) parts.push(renderView(v));
   }
-  options.push({ value: "skip", label: "Skip", hint: "leave this view as-is for now" });
-  return options;
+  return `${parts.join("\n\n")}
+`;
 }
-async function promptDecision(entry) {
-  const label = entry.state === "conflict" ? "CONFLICT" : "runtime divergence";
-  const answer = await prompts.select({
-    message: `${entry.key} \u2014 ${label} (${entry.changedFields.join(", ")})`,
-    options: decisionOptionsFor(entry)
-  });
-  if (prompts.isCancel(answer)) {
-    return "skip";
+
+// src/commands/pull.ts
+async function runPullCommand(client) {
+  let state;
+  try {
+    state = await client.get("/schema/state");
+  } catch (error) {
+    return { exitCode: 2, errorMessage: messageOf(error) };
   }
-  return answer;
+  return { exitCode: 0, prompt: renderReconciliationPrompt(state) };
 }
 function registerPullCommand(program) {
-  program.command("pull").description("Interactively resolve view drift: promote runtime changes or overwrite them").action(async (_opts, cmd) => {
+  program.command("pull").description("Emit a self-contained reconciliation prompt for the current runtime drift").option("--json", "Emit the raw /schema/state JSON instead of the prompt").action(async (opts, cmd) => {
     let client;
-    let schemaEntry;
-    let standardsDir;
     try {
       client = getClientFromCommand(cmd);
-      schemaEntry = readStandardsProjectConfig().schemaEntry;
-      standardsDir = resolveStandardsDir();
     } catch (error) {
-      console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
-      process.exit(2);
-      return;
-    }
-    let result;
-    try {
-      result = await runPullCommand({ client, schemaEntry, standardsDir }, promptDecision);
-    } catch (error) {
-      console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
-      process.exit(2);
-      return;
-    }
-    if (result.initial.exitCode === 2) {
-      console.error(chalk7.red(`\u2717 ${result.initial.errorMessage}`));
+      console.error(chalk5.red(`\u2717 ${messageOf(error)}`));
       process.exit(2);
       return;
     }
-    if (result.outcomes.length === 0) {
-      console.info(chalk7.dim("No conflicts or runtime-diverged views need a decision."));
-    }
-    for (const outcome of result.outcomes) {
-      if (outcome.decision === "promote") {
-        if (outcome.promote.ok) {
-          console.info(chalk7.green(`\u2713 Wrote ${outcome.promote.filePath}`));
-        } else {
-          console.error(chalk7.red(`\u2717 ${outcome.promote.message}`));
-        }
-      } else if (outcome.decision === "overwrite") {
-        if (outcome.overwrite.ok) {
-          console.info(chalk7.green(`\u2713 Overwrote ${outcome.entry.key}`));
-        } else {
-          console.error(chalk7.red(`\u2717 ${outcome.overwrite.message}`));
-        }
+    if (opts.json) {
+      try {
+        const state = await client.get("/schema/state");
+        console.info(JSON.stringify(state, null, 2));
+        process.exit(0);
+      } catch (error) {
+        console.error(chalk5.red(`\u2717 ${messageOf(error)}`));
+        process.exit(2);
       }
+      return;
     }
-    if (result.residual.exitCode === 2) {
-      console.error(chalk7.red(`\u2717 ${result.residual.errorMessage}`));
+    const result = await runPullCommand(client);
+    if (result.exitCode === 2) {
+      console.error(chalk5.red(`\u2717 ${result.errorMessage}`));
       process.exit(2);
       return;
     }
-    console.info(formatDiffReport(result.residual.report, resolveEffectiveFormat(cmd)));
-    process.exit(result.residual.exitCode);
+    console.info(result.prompt);
+    process.exit(0);
   });
 }
 
@@ -1162,6 +555,11 @@ function parseSortFlag(sort) {
   const [attribute, direction = "asc"] = sort.split(":");
   return [{ attribute, direction }];
 }
+var COUNT_MODES = ["none", "estimated", "exact"];
+function parseCountFlag(count) {
+  if (COUNT_MODES.includes(count)) return count;
+  throw new Error(`Invalid --count value "${count}". Expected one of: ${COUNT_MODES.join(", ")}.`);
+}
 function buildQueryBody(opts) {
   const body = {};
   if (opts.limit) body.limit = Number(opts.limit);
@@ -1169,14 +567,16 @@ function buildQueryBody(opts) {
   if (opts.sort) body.sorts = parseSortFlag(opts.sort);
   if (opts.filter) body.filters = JSON.parse(opts.filter);
   if (opts.fields !== void 0) body.fields = parseCsvList(opts.fields);
+  if (opts.count) body.countMode = parseCountFlag(opts.count);
   return body;
 }
+var COUNT_OPTION_DESCRIPTION = "total count mode (none, estimated, exact); omit for no total in page.total";
 function registerRecordsCommand(program) {
   const records = program.command("records").description("Manage records (CRUD + search)");
   records.command("list").description("List records for an object").argument("<object>", "object name (e.g. contacts)").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").option(
     "--fields <names>",
     "comma-separated reference attributes to hydrate (empty for none, omit for all)"
-  ).action(async (objectName, opts, cmd) => {
+  ).option("--count <mode>", COUNT_OPTION_DESCRIPTION).action(async (objectName, opts, cmd) => {
     const client = getClientFromCommand(cmd);
     const body = buildQueryBody(opts);
     const result = await client.post(`/records/${objectName}/list`, body);
@@ -1208,7 +608,7 @@ function registerRecordsCommand(program) {
   records.command("search").description("Full-text search records").argument("<object>", "object name").requiredOption("--query <q>", "search query string").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").option(
     "--fields <names>",
     "comma-separated reference attributes to hydrate (empty for none, omit for all)"
-  ).action(async (objectName, opts, cmd) => {
+  ).option("--count <mode>", COUNT_OPTION_DESCRIPTION).action(async (objectName, opts, cmd) => {
     const client = getClientFromCommand(cmd);
     const body = { q: opts.query, ...buildQueryBody(opts) };
     const result = await client.post(`/records/${objectName}/search`, body);
@@ -1235,20 +635,20 @@ function registerRecordsCommand(program) {
 // src/commands/root.ts
 import { stdin as input, stdout as output } from "process";
 import { createInterface } from "readline/promises";
-import chalk8 from "chalk";
+import chalk6 from "chalk";
 
 // src/config.ts
 import { mkdir, readFile as readFile3, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname5, join as join5 } from "path";
+import { dirname, join } from "path";
 var DEFAULT_API_URL = "http://localhost:4100/v1";
 var ENV_PROFILE_NAME = "sandbox";
 function getDefaultApiUrl() {
   return DEFAULT_API_URL;
 }
 function getConfigPath() {
-  const configDir = process.env.STANDARDS_CONFIG_DIR ?? join5(homedir(), ".standards");
-  return join5(configDir, "config.json");
+  const configDir = process.env.STANDARDS_CONFIG_DIR ?? join(homedir(), ".standards");
+  return join(configDir, "config.json");
 }
 async function readConfig() {
   try {
@@ -1267,7 +667,7 @@ async function readConfig() {
 }
 async function writeConfig(config) {
   const path = getConfigPath();
-  await mkdir(dirname5(path), { recursive: true, mode: 448 });
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
   await writeFile(path, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
 }
@@ -1375,7 +775,7 @@ function registerRootCommands(program) {
     await client.get("/api-keys");
     await upsertProfile({ name: opts.name, apiUrl: opts.url, apiKey });
     process.stdout.write(
-      `${chalk8.green("\u2713")} Standards instance "${opts.name}" saved and selected.
+      `${chalk6.green("\u2713")} Standards instance "${opts.name}" saved and selected.
 `
     );
     process.stdout.write(`  API URL: ${opts.url}
@@ -1387,7 +787,7 @@ function registerRootCommands(program) {
   });
   program.command("use").description("Select the active Standards instance").argument("<name>", "instance name").action(async (name) => {
     await setCurrentProfile(name);
-    process.stdout.write(`${chalk8.green("\u2713")} Standards instance "${name}" selected.
+    process.stdout.write(`${chalk6.green("\u2713")} Standards instance "${name}" selected.
 `);
   });
   program.command("instances").description("List configured Standards instances").action(async (_opts, cmd) => {
@@ -1406,7 +806,7 @@ function registerRootCommands(program) {
   });
   program.command("logout").description("Remove a Standards instance from local CLI config").argument("[name]", "instance name, defaults to current").action(async (name) => {
     await removeProfile(name);
-    process.stdout.write(`${chalk8.green("\u2713")} Standards instance removed.
+    process.stdout.write(`${chalk6.green("\u2713")} Standards instance removed.
 `);
   });
 }
@@ -1427,7 +827,7 @@ function registerSchemaCommand(program) {
 }
 
 // src/program.ts
-var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help", "init"]);
+var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help"]);
 function isPublicCommand(actionCommand) {
   if (PUBLIC_COMMANDS.has(actionCommand.name())) return true;
   return actionCommand.parent?.name() === "auth" && actionCommand.name() === "help";
@@ -1438,14 +838,11 @@ function createProgram() {
   registerRootCommands(program);
   registerRecordsCommand(program);
   registerSchemaCommand(program);
-  registerDiffCommand(program);
   registerPullCommand(program);
-  registerInitCommand(program);
   registerDocumentsCommand(program);
   registerFoldersCommand(program);
   registerKeysCommand(program);
   registerAuthCommand(program);
-  registerAutofillCommand(program);
   registerBundlesCommand(program);
   registerConnectorsCommand(program);
   program.hook("preAction", async (_thisCommand, actionCommand) => {
@@ -1461,7 +858,7 @@ function createProgram() {
     program.setOptionValue("tenant", raw.tenant);
     if (!(resolved.apiKey || isPublicCommand(actionCommand))) {
       console.error(
-        chalk9.red(
+        chalk7.red(
           `\u2717 Error: No Standards instance configured. Run "standards login" or pass --api-key.`
         )
       );
@@ -1475,12 +872,12 @@ async function runProgram(argv = process.argv) {
   await program.parseAsync(argv).catch((error) => {
     if (error instanceof ApiClientError) {
       if (error.statusCode > 0) {
-        console.error(chalk9.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
+        console.error(chalk7.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
       } else {
-        console.error(chalk9.red(`\u2717 Error: ${error.message}`));
+        console.error(chalk7.red(`\u2717 Error: ${error.message}`));
       }
     } else if (error instanceof Error) {
-      console.error(chalk9.red(`\u2717 Error: ${error.message}`));
+      console.error(chalk7.red(`\u2717 Error: ${error.message}`));
     }
     process.exit(1);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stndrds/cli",
-  "version": "1.0.0-alpha.261",
+  "version": "1.0.0-alpha.264",
   "description": "CLI tool to interact with Standards API",
   "type": "module",
   "bin": {
@@ -10,12 +10,10 @@
     "dist"
   ],
   "dependencies": {
-    "@clack/prompts": "^1.7.0",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
     "commander": "^13.1.0",
-    "esbuild": "^0.25.0",
-    "@stndrds/schema": "1.0.0-alpha.261"
+    "@stndrds/schema": "1.0.0-alpha.264"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/dist/assets/standards-drift.yml

@@ -1,242 +0,0 @@
-name: Standards schema/view drift
-
-# Runs "standards diff" against the deployed (prod) Standards instance on every
-# PR, so schema/view drift that would be silently overwritten or destroyed on
-# the next deploy is caught at review time instead of after rollout.
-on:
-  pull_request:
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  standards-drift:
-    name: standards diff
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-
-      - name: Enable corepack (pnpm)
-        run: corepack enable
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      # `standards diff` reads its credentials the same way every other CLI
-      # command does (see packages/cli/src/config.ts:resolveCliConfig /
-      # getEnvProfile): STANDARDS_API_URL + STANDARDS_API_KEY. These are the
-      # exact env var names the client reads — do not rename without updating
-      # both the CLI and this workflow.
-      #
-      # `--format json` is captured for the PR comment step below; the human-
-      # readable table is still what a developer sees if they run the same
-      # command locally without --format. Stderr is captured separately
-      # (`standards diff` prints its exit-2 failure message via
-      # `console.error`, i.e. to stderr, never into the JSON stdout) so the
-      # comment step has something to show for an infra failure instead of an
-      # empty code block.
-      - name: Run standards diff
-        id: standards-diff
-        env:
-          STANDARDS_API_URL: ${{ secrets.STANDARDS_API_URL }}
-          STANDARDS_API_KEY: ${{ secrets.STANDARDS_API_KEY }}
-        run: |
-          set +e
-          pnpm exec standards diff --format json > standards-diff.json 2> standards-diff.err
-          echo "exit_code=$?" >> "$GITHUB_OUTPUT"
-          cat standards-diff.json
-          cat standards-diff.err >&2
-          exit 0
-
-      # Fork PRs run with a read-only GITHUB_TOKEN (no `pull-requests: write`),
-      # so `github.rest.issues.createComment`/`updateComment` below would 403.
-      # Skip the comment (not the check itself — "Fail the job" below still
-      # runs and still gates the merge) for PRs from forks. See the maintainer
-      # note at the bottom of this file.
-      - name: Comment drift report on PR
-        if: github.event.pull_request.head.repo.full_name == github.repository
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const fs = require("fs");
-            const exitCode = Number("${{ steps.standards-diff.outputs.exit_code }}");
-            const marker = "<!-- standards-drift-report -->";
-
-            const stdout = fs.existsSync("standards-diff.json") ? fs.readFileSync("standards-diff.json", "utf-8") : "";
-            const stderr = fs.existsSync("standards-diff.err") ? fs.readFileSync("standards-diff.err", "utf-8") : "";
-
-            let report = null;
-            if (stdout.trim().length > 0) {
-              try {
-                report = JSON.parse(stdout);
-              } catch {
-                // exit code 2 (infra failure) can leave non-JSON stdout (e.g.
-                // the process never got far enough to print a report) — the
-                // stderr capture above is what carries the actual message then.
-              }
-            }
-
-            // `state !== "in-sync"` on its own would lump `code-changed`/
-            // `conflict-resolved` (informational — will simply apply, nothing
-            // blocking) in with `conflict`/`runtime-diverged` (blocking,
-            // needs a developer decision). Keep them in separate tables so
-            // the "needs a decision" table is true of every row it lists.
-            function renderTable(rows) {
-              if (rows.length === 0) return "_None._";
-              const header = "| View | State | Changed fields |\n| --- | --- | --- |";
-              const body = rows
-                .map((v) => `| \`${v.key}\` | ${v.state} | ${(v.changedFields ?? []).join(", ") || "—"} |`)
-                .join("\n");
-              return `${header}\n${body}`;
-            }
-
-            function renderDecisionViewsTable(views) {
-              return renderTable(views.filter((v) => v.state === "conflict" || v.state === "runtime-diverged"));
-            }
-
-            function renderInformationalViewsTable(views) {
-              return renderTable(views.filter((v) => v.state === "code-changed" || v.state === "conflict-resolved"));
-            }
-
-            function renderSchemaTable(schema) {
-              const lines = [];
-              for (const obj of schema?.customObjects ?? []) {
-                lines.push(`| \`${obj.name}\` | custom object, not in code |`);
-              }
-              for (const entry of schema?.systemObjectDrift ?? []) {
-                const unexpected = entry.sealed
-                  ? entry.customAttributes.filter((a) => !a.tolerated)
-                  : [];
-                if (entry.sealed && unexpected.length > 0) {
-                  lines.push(
-                    `| \`${entry.objectName}\` | ${unexpected.length} unexpected attribute(s) (sealed) |`
-                  );
-                }
-              }
-              if (lines.length === 0) return "_No object/attribute drift._";
-              return `| Object | Note |\n| --- | --- |\n${lines.join("\n")}`;
-            }
-
-            let body;
-            if (exitCode === 2) {
-              const details = stderr.trim().length > 0 ? stderr.trim() : stdout.trim().length > 0 ? stdout.trim() : "(no output captured)";
-              body = [
-                marker,
-                "## ⚠️ standards diff — could not run (exit code 2)",
-                "",
-                "This is an **infra/configuration failure**, not schema or view drift —",
-                "the check itself did not complete. Common causes: a missing or invalid",
-                "`STANDARDS_API_URL` / `STANDARDS_API_KEY` secret, an unreachable API, or a",
-                "schema entry file that fails to load in isolation.",
-                "",
-                "```",
-                details,
-                "```",
-              ].join("\n");
-            } else if (exitCode === 0) {
-              body = [marker, "## ✅ standards diff — no blocking drift", "", "Next deploy is a no-op for schema/views."].join(
-                "\n"
-              );
-            } else {
-              body = [
-                marker,
-                "## 🚫 standards diff — unresolved drift (exit code 1)",
-                "",
-                "### Needs a decision",
-                "",
-                "These views WOULD have their runtime change overwritten or destroyed by",
-                "the next deploy. Run `standards pull` locally to resolve each one (promote",
-                "the runtime change into code, or explicitly overwrite it), then push again.",
-                "",
-                renderDecisionViewsTable(report?.views ?? []),
-                "",
-                "### Will apply automatically (informational, no action needed)",
-                "",
-                renderInformationalViewsTable(report?.views ?? []),
-                "",
-                "### Schema (objects/attributes)",
-                "",
-                renderSchemaTable(report?.schema ?? {}),
-              ].join("\n");
-            }
-
-            const { data: comments } = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-            });
-            const existing = comments.find((c) => c.body?.includes(marker));
-
-            if (existing) {
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: existing.id,
-                body,
-              });
-            } else {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.issue.number,
-                body,
-              });
-            }
-
-      - name: Fail the job on unresolved drift or infra failure
-        if: steps.standards-diff.outputs.exit_code != '0'
-        run: |
-          echo "standards diff exited with code ${{ steps.standards-diff.outputs.exit_code }}"
-          exit 1
-
-# ---------------------------------------------------------------------------
-# Notes for whoever maintains this workflow
-# ---------------------------------------------------------------------------
-#
-# 1. Deploy-time re-check (close the merge -> deploy TOCTOU window):
-#    A PR can be green here and still go stale — a runtime user can edit a
-#    view in the time between "this PR merged" and "this commit actually
-#    deployed". Copy the "Run standards diff" step (same env vars, same
-#    command) into your deploy pipeline immediately BEFORE the rollout step,
-#    and treat a non-zero exit there as a deploy abort:
-#      - exit 1 -> abort the deploy, drift must be resolved first (the exact
-#        same resolution flow as above: `standards pull`, or hand this off to
-#        the `standards-pull` agent skill).
-#      - exit 2 -> abort the deploy, this is an infra failure (bad
-#        credentials, unreachable API), not a drift decision.
-#    Without this second check, this PR-time gate only protects the instant
-#    of merge, not the instant of deploy.
-#
-# 2. v1 assumes single-tenant consumer deployments: one STANDARDS_API_KEY
-#    maps to exactly one tenant. If your deployment serves multiple tenants
-#    per Standards instance, this workflow (and `standards diff`/`standards
-#    pull` generally) only checks the one tenant reachable with the configured
-#    key — repeat the job (or the deploy-time re-check) once per tenant.
-#
-# 3. Exit codes, spelled out (see packages/cli/src/commands/diff.ts):
-#      0 = no blocking drift, next deploy is a no-op for schema/views.
-#      1 = blocking drift found (an unresolved conflict, or unexpected sealed-
-#          object drift) — the next deploy WOULD destroy runtime changes.
-#      2 = infra failure: network/auth error, missing/invalid
-#          STANDARDS_API_URL / STANDARDS_API_KEY, or the schema entry failed
-#          to load in isolation. This is NOT drift — do not treat it as "no
-#          drift" (it is not 0) and do not treat it as a conflict to resolve
-#          (editing schema code will not fix a missing secret).
-#
-# 4. Fork PRs: GitHub gives a `pull_request` run triggered from a fork a
-#    read-only GITHUB_TOKEN (no `pull-requests: write`), so the "Comment
-#    drift report on PR" step is guarded with
-#    `if: github.event.pull_request.head.repo.full_name == github.repository`
-#    and is simply skipped for fork PRs — it would otherwise fail with a 403
-#    trying to post the comment. The "Fail the job on unresolved drift or
-#    infra failure" step is NOT guarded — it doesn't call the GitHub API, so
-#    it still gates the merge for fork PRs; the developer just won't get the
-#    rendered table, only the job's own log output (which still contains the
-#    exit code and, on exit 2, the captured stderr).

package/dist/assets/standards-pull-skill.md

@@ -1,101 +0,0 @@
----
-name: standards-pull
-description: Resolve Standards schema/view drift between the code-defined schema and the deployed runtime — walks each conflicting or runtime-diverged view with the developer, promotes runtime changes into builder code, and only stops once "standards diff" reports no drift. Use when "standards diff" exits 1, when a PR's standards-drift CI check fails, or when the developer asks to resolve/promote/reconcile schema or view drift.
----
-
-# standards-pull — resolve schema/view drift
-
-## What drift means here
-
-Standards is schema-driven: the code-defined schema (`object()`/`view()` builders) is
-the source of truth, and it gets synced into the runtime database on deploy. Between
-deploys, runtime users can edit views (labels, tabs, field layout) through the product
-UI. `standards diff` compares the two and classifies every view into one of:
-
-- `code-changed` — only code changed since the last sync; the next deploy will simply
-  apply it. Nothing to do.
-- `runtime-diverged` — a runtime user changed the view and code has NOT changed it;
-  the next deploy would silently overwrite their change. Needs a decision.
-- `conflict` — BOTH code and the runtime changed the same view since the last sync.
-  The next deploy WOULD DESTROY the runtime change. Blocking (exit code 1).
-- `conflict-resolved` — a conflict that a developer already acknowledged via
-  `standards pull`'s "overwrite" decision; code will apply cleanly.
-- `in-sync` — no drift, no line printed.
-
-Exit codes (`standards diff` / `standards pull`): `0` = nothing blocking, `1` = at
-least one `conflict` or sealed-object drift is unresolved, `2` = infra failure
-(network error, the schema entry failed to load, misconfigured/missing credentials).
-**Exit code 2 is not drift** — it means the check itself could not run (e.g. a CI job
-with a missing `STANDARDS_API_KEY` secret). Never treat a `2` as "no drift" or as a
-conflict to resolve; fix the underlying infra/config problem and re-run.
-
-## Your job, precisely
-
-You are invoked either because a developer asked you to resolve drift, or because a
-CI check (`standards-drift.yml`) is failing on a PR. In both cases:
-
-1. Run `standards diff --format json` and parse the JSON report. This is the ONLY
-   source of truth for what has drifted — never guess from reading builder files
-   alone, and never rely on a stale report from earlier in the conversation.
-2. If the exit code is `2`, STOP and report the infra error message to the developer
-   verbatim — this is not something you can resolve by editing schema code (missing
-   `STANDARDS_API_KEY`/`STANDARDS_API_URL`, unreachable API, a schema entry that fails
-   to load in isolation). Fix what's actually broken (e.g. a bad import in the entry
-   file) and re-run `standards diff` before doing anything else.
-3. If the exit code is `0`, there is nothing to do — say so and stop.
-4. Otherwise, walk every item in the report **with the developer** — do not
-   silently decide on their behalf for anything destructive:
-   - `conflict` and `runtime-diverged` views are what need a decision. For each one,
-     tell the developer what changed on each side (the report's `changedFields`) and
-     ask: **promote** the runtime change into code, or (for `conflict` only)
-     **overwrite** it by running `standards pull` and choosing "Overwrite" for that
-     view (accepts the code version, discards the runtime change — only do this with
-     explicit developer confirmation, it is destructive to the runtime edit).
-   - `customObjects` / unexpected `systemObjectDrift` attributes: tell the developer
-     these exist only in the runtime, not in code, and ask whether to promote them
-     into the builder (add the attribute/object in code) or leave them as runtime-only
-     extensions.
-5. To **promote**: run `standards pull` and choose "Promote" for the relevant view.
-   This writes `.standards/promotions/<object>-<name>-<type>.md`, containing:
-   - the view's current **runtime config** (the JSON to fold into the builder call —
-     tabs, fields, label, icon, etc.)
-   - a **builder file hint**: the file path and line of the existing
-     `listView(...)`/`detailView(...)` call for that view, when one is found
-   Read that file, then edit the builder call in the hinted file so the fluent
-   builder chain (`.tab(...)`, `.form(...)`, `.label(...)`, etc.) produces the same
-   shape as the runtime config in the promotion file. This is a translation task —
-   the promotion file gives you the target *data*, you write the target *code*.
-6. **Loop `standards diff` until it exits 0.** After every edit (a promotion applied,
-   an overwrite decided, a builder file changed), re-run `standards diff --format
-   json` and re-parse it. Do not stop after one pass over the report — new drift can
-   surface (e.g. an edit that doesn't fully match the promoted config still shows as
-   `runtime-diverged`), and the loop is the only thing that proves you actually closed
-   every gap. **Never declare success without a green (`exitCode: 0`) `standards
-   diff` run.** A clean-looking diff of your own code edits is not sufficient — the
-   deterministic tool is what closes the loop, not your judgment about whether the
-   edits "look right".
-
-## Guardrails
-
-- Never run `standards pull`'s "Overwrite" decision without explicit developer
-  confirmation for that specific view — it discards real runtime user edits.
-- Never hand-edit `.standards/config.json` or `.standards/promotions/*.md` — those
-  are written by the CLI (`standards init` / `standards pull`); editing them by hand
-  does not change what the runtime actually has and will desync your mental model
-  from `standards diff`'s next run.
-- If a promotion file's builder hint says "No `listView`/`detailView` call found",
-  search the schema entry's directory yourself for where that object's other views
-  are declared — the view may be newly created at runtime and have no code
-  counterpart yet; promoting it means adding a NEW builder call, not editing one.
-- If `standards diff` keeps reporting the same drift after an edit you believe is
-  correct, re-read the promotion file's runtime config carefully — a mismatched field
-  name, tab id, or attribute list is the most common cause, not a tooling bug.
-
-## Related: deploy-time re-check
-
-The merge of a PR and the actual deploy of that code are two different moments in
-time — a runtime user can edit a view in the window between them. Projects that wired
-`standards init --ci` should also run `standards diff` as a gate immediately before
-the deploy step in their deploy pipeline (exit code `1` aborts the rollout), so this
-skill's job — reconciling runtime drift — never gets skipped by that gap. If asked to
-set that up, see the comment block at the end of `.github/workflows/standards-drift.yml`.