@iowarp/clio-coder 0.3.6 → 0.3.7

package/dist/{chunk-ZXF4XRKW.js → chunk-XEGB6BCN.js}

@@ -10,10 +10,10 @@ import {
 } from "./chunk-WHGPSPT5.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-XXQNGV4M.js";
+} from "./chunk-CEYBNUGC.js";
 import {
   taskBoardCounts
-} from "./chunk-43AOLP7E.js";
+} from "./chunk-5FR74PWO.js";
 import {
   SKILL_SUGGESTION_ANCHOR,
   SKILL_SUGGESTION_PREFIX
@@ -25,13 +25,13 @@ import {
 import {
   ToolNames
 } from "./chunk-CGKSTWHD.js";
-import {
-  reportCommitAttributionDiagnostic,
-  withManagedGitCommitAttributionEnvironment
-} from "./chunk-VEZEGCGW.js";
 import {
   ceilChars
 } from "./chunk-GEYXPTRF.js";
+import {
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-D4MDIG46.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -2097,6 +2097,153 @@ function createMiddlewareToolChoiceControl() {
   };
 }
 
+// src/domains/middleware/watchdog.ts
+init_esm_shims();
+var WATCHDOG_REGISTRATION_ID = "observer.watchdog";
+var WATCHDOG_DIFF_MAX_BYTES = 12 * 1024;
+var WATCHDOG_PATHS_MAX = 40;
+var WATCHDOG_TRUNCATION_MARKER = "\n[diff truncated]";
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([ToolNames.Write, ToolNames.Edit, ToolNames.Artifact]);
+var NO_EFFECTS4 = [];
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function firstPath(details) {
+  const paths = details?.paths;
+  if (!Array.isArray(paths)) return null;
+  for (const entry of paths) {
+    const path = stringValue2(entry);
+    if (path !== null) return path;
+  }
+  return null;
+}
+function coalesceTurnDiff(byPath, maxBytes = WATCHDOG_DIFF_MAX_BYTES) {
+  const blocks = [];
+  let index = 0;
+  for (const [path, diff] of byPath) {
+    if (index >= WATCHDOG_PATHS_MAX) {
+      blocks.push(`[${byPath.size - WATCHDOG_PATHS_MAX} more changed path(s) omitted]`);
+      break;
+    }
+    blocks.push(`--- ${path}
+${diff}`);
+    index += 1;
+  }
+  const whole = blocks.join("\n\n");
+  if (Buffer.byteLength(whole, "utf8") <= maxBytes) return whole;
+  const room = Math.max(0, maxBytes - Buffer.byteLength(WATCHDOG_TRUNCATION_MARKER, "utf8"));
+  const buffer = Buffer.from(whole, "utf8");
+  let cut = Math.min(room, buffer.byteLength);
+  while (cut > 0) {
+    const next = buffer[cut];
+    if (next === void 0 || (next & 192) !== 128) break;
+    cut -= 1;
+  }
+  return `${buffer.subarray(0, cut).toString("utf8")}${WATCHDOG_TRUNCATION_MARKER}`;
+}
+var WATCHDOG_TASK = "Review the coalesced diff in the briefing against the scope it names. Report one check per concern: a change outside the stated scope, a change the scope required that the diff does not make, or a defect visible in the diff itself. Run no commands and change nothing.";
+function watchdogBriefing(trigger) {
+  const scope = trigger.scope === null ? "(no task board; scope is unstated)" : trigger.scope;
+  const paths = trigger.paths.length === 0 ? "(none)" : trigger.paths.join("\n");
+  return [
+    "## Current scope",
+    scope,
+    "",
+    "## Changed paths",
+    paths,
+    "",
+    "## Coalesced diff for this turn",
+    trigger.diff
+  ].join("\n");
+}
+function createWatchdogRegistration(deps) {
+  const diffByPath = /* @__PURE__ */ new Map();
+  let toolCalls = 0;
+  let dropped = 0;
+  let inFlight = false;
+  let outstanding = Promise.resolve();
+  const active = () => {
+    if (deps.firesOnThisSurface === false) return null;
+    let settings;
+    try {
+      settings = deps.getSettings();
+    } catch {
+      return null;
+    }
+    return settings.enabled ? settings : null;
+  };
+  const resetTurn = () => {
+    diffByPath.clear();
+    toolCalls = 0;
+  };
+  const fire = (reason) => {
+    if (diffByPath.size === 0) return;
+    if (inFlight) {
+      dropped += 1;
+      return;
+    }
+    const trigger = {
+      reason,
+      diff: coalesceTurnDiff(diffByPath),
+      paths: [...diffByPath.keys()].slice(0, WATCHDOG_PATHS_MAX),
+      scope: scopeNow(),
+      toolCalls
+    };
+    inFlight = true;
+    let started;
+    try {
+      started = deps.run(trigger);
+    } catch {
+      inFlight = false;
+      return;
+    }
+    outstanding = started.catch(() => {
+    }).finally(() => {
+      inFlight = false;
+    });
+  };
+  const scopeNow = () => {
+    try {
+      return deps.getScope?.() ?? null;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    id: WATCHDOG_REGISTRATION_ID,
+    description: "review a mutating turn's coalesced diff against the board scope with a read-only verifier run",
+    hooks: ["after_tool", "turn_end"],
+    evaluate(input) {
+      const settings = active();
+      if (settings === null) {
+        if (input.hook === "turn_end") resetTurn();
+        return NO_EFFECTS4;
+      }
+      if (input.hook === "after_tool") {
+        toolCalls += 1;
+        recordMutation(input);
+        const cadence = settings.cadenceToolCalls;
+        if (cadence !== void 0 && cadence >= 1 && toolCalls % cadence === 0) fire("cadence");
+        return NO_EFFECTS4;
+      }
+      if (input.hook !== "turn_end") return NO_EFFECTS4;
+      fire("turn_end");
+      resetTurn();
+      return NO_EFFECTS4;
+    },
+    droppedTriggers: () => dropped,
+    runInFlight: () => inFlight,
+    whenIdle: () => outstanding
+  };
+  function recordMutation(input) {
+    if (input.metadata?.resultKind !== "ok") return;
+    if (input.toolName === void 0 || !MUTATING_TOOL_NAMES.has(input.toolName)) return;
+    const diff = stringValue2(input.toolResultDetails?.diff);
+    if (diff === null) return;
+    diffByPath.set(firstPath(input.toolResultDetails) ?? input.toolName, diff);
+  }
+}
+
 // src/domains/middleware/index.ts
 init_esm_shims();
 
@@ -2252,6 +2399,9 @@ export {
   createTaskBoardReminderRegistration,
   createTaskNudgeRegistration,
   createMiddlewareToolChoiceControl,
+  WATCHDOG_TASK,
+  watchdogBriefing,
+  createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-ZXF4XRKW.js.map
+//# sourceMappingURL=chunk-XEGB6BCN.js.map

package/dist/{chunk-E25LMLRW.js → chunk-YD734TPH.js}

@@ -5,7 +5,7 @@ import {
   settingsPath,
   updateSavedSettingsDocument,
   validateSettings
-} from "./chunk-AD2SYQYC.js";
+} from "./chunk-UHXRNZ2J.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -226,4 +226,4 @@ export {
   updateLayeredSettings,
   settingsSourceFor
 };
-//# sourceMappingURL=chunk-E25LMLRW.js.map
+//# sourceMappingURL=chunk-YD734TPH.js.map

package/dist/{verifiers-NCBTHHN2.js → chunk-YTYFXUI3.js}

@@ -4,52 +4,34 @@ import {
   tomlTableAt
 } from "./chunk-LCGCVYZ4.js";
 import {
-  discoverDeclaredChecksAtRoot,
   verifyTool
-} from "./chunk-PCZJO5TI.js";
-import "./chunk-NILBFAPG.js";
+} from "./chunk-UFQ3F4FW.js";
+import {
+  discoverDeclaredChecksAtRoot,
+  discoverDeclaredProjectEntriesAtRoot
+} from "./chunk-PD3MESLB.js";
 import {
   PROJECT_VERIFIER_CATALOG_CAPS,
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   PROJECT_VERIFIER_CATALOG_VERSION,
   compareCodepoints,
-  loadProjectVerifierCatalog,
   parseProjectVerifierCatalogText
-} from "./chunk-FYYLNIL5.js";
+} from "./chunk-GH5622CP.js";
 import {
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
-import "./chunk-VG7TBQIY.js";
-import "./chunk-OQE5J4C6.js";
-import "./chunk-ECH6PKUQ.js";
-import "./chunk-6XLNIQDB.js";
-import "./chunk-5B2AEOW5.js";
-import "./chunk-CGKSTWHD.js";
-import {
-  printError,
-  printOk
-} from "./chunk-PPAMZ32Z.js";
-import "./chunk-5TSRNF4G.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-VEZEGCGW.js";
-import "./chunk-FQ4SKYE4.js";
-import "./chunk-FCSXB6T2.js";
+} from "./chunk-D4MDIG46.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
-import "./chunk-YXLYO42X.js";
-import "./chunk-BNAZZHFG.js";
-import "./chunk-6EJMN2Y3.js";
 import {
   __toESM,
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/cli/verifiers.ts
-init_esm_shims();
-
 // src/tools/verify/authoring.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
@@ -259,7 +241,7 @@ function pythonProposals(workspaceRoot, diagnostics) {
     if (document === null) {
       diagnostics.push(`${pyprojectPath}: invalid TOML; Python discovery skipped.`);
     } else {
-      for (const [path2, section, module, id, description, tags2] of [
+      for (const [path2, section, module, id, description, tags] of [
         [
           ["tool", "pytest", "ini_options"],
           "tool.pytest.ini_options",
@@ -278,7 +260,7 @@ function pythonProposals(workspaceRoot, diagnostics) {
           command: ["python", "-m", module],
           cwd: ".",
           timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
-          tags: [...tags2],
+          tags: [...tags],
           provenance: {
             kind: "python-runner",
             path: pyprojectPath,
@@ -343,6 +325,52 @@ function pythonProposals(workspaceRoot, diagnostics) {
   }
   return proposals;
 }
+function discoverDeclaredProjectCommands(workspaceRoot = process.cwd()) {
+  const commands = [];
+  const add = (id, command, pathValue, detail, kind) => {
+    commands.push({
+      id,
+      command,
+      provenance: { kind, path: pathValue, detail, authority: "project-declared" }
+    });
+  };
+  for (const entry of discoverDeclaredProjectEntriesAtRoot(workspaceRoot)) {
+    add(entry.id, entry.command, entry.path, entry.detail, entry.kind);
+  }
+  const pyprojectText = regularFileText(path.join(workspaceRoot, "pyproject.toml"), workspaceRoot);
+  if (typeof pyprojectText === "string") {
+    const document = parseTomlDocument(pyprojectText);
+    if (document !== null) {
+      for (const [tablePath, label] of [
+        [["project", "scripts"], "project.scripts"],
+        [["tool", "poetry", "scripts"], "tool.poetry.scripts"]
+      ]) {
+        const scripts = tomlTableAt(document, tablePath);
+        if (scripts === null) continue;
+        for (const [name, target] of Object.entries(scripts).sort(([left], [right]) => compareCodepoints(left, right))) {
+          if (typeof target === "string") add(name, [name], "pyproject.toml", `[${label}] entry '${name}'`, "python-runner");
+        }
+      }
+      for (const [tablePath, module, id, label] of [
+        [["tool", "pytest", "ini_options"], "pytest", "pytest", "tool.pytest.ini_options"],
+        [["tool", "tox"], "tox", "tox", "tool.tox"],
+        [["tool", "nox"], "nox", "nox", "tool.nox"]
+      ]) {
+        if (tomlTableAt(document, tablePath) !== null)
+          add(id, ["python", "-m", module], "pyproject.toml", `[${label}]`, "python-runner");
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return commands.filter((entry) => {
+    let id = slug(entry.id, "command");
+    let suffix = 2;
+    while (seen.has(id)) id = `${slug(entry.id, "command")}-${suffix++}`;
+    seen.add(id);
+    entry.id = id;
+    return true;
+  });
+}
 function goProposals(workspaceRoot, diagnostics) {
   const relative = "go.mod";
   const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
@@ -506,14 +534,14 @@ function validationContractProposals(workspaceRoot, diagnostics) {
       const description = typeof record?.description === "string" ? record.description : `Run validation contract command ${JSON.stringify(argv)}`;
       const cwd = typeof record?.cwd === "string" ? record.cwd : ".";
       const timeoutMs = typeof record?.timeoutMs === "number" ? record.timeoutMs : SAFE_EXEC_DEFAULT_TIMEOUT_MS;
-      const tags2 = Array.isArray(record?.tags) ? record.tags.filter((tag) => typeof tag === "string") : [];
+      const tags = Array.isArray(record?.tags) ? record.tags.filter((tag) => typeof tag === "string") : [];
       proposals.push({
         preferredId: declaredId,
         description,
         command: argv,
         cwd,
         timeoutMs,
-        tags: tags2.length > 0 ? tags2 : ["scientific", "validation"],
+        tags: tags.length > 0 ? tags : ["scientific", "validation"],
         provenance: {
           kind: "validation-contract",
           path: relative,
@@ -640,8 +668,8 @@ function createVerifierDraft(discovery, options = {}) {
     ...discovery.catalogText === void 0 ? {} : { catalogText: discovery.catalogText }
   };
 }
-function catalogEntry({ id, description, command, cwd, timeoutMs, tags: tags2 }) {
-  return { id, description, command: [...command], cwd, timeoutMs, tags: [...tags2] };
+function catalogEntry({ id, description, command, cwd, timeoutMs, tags }) {
+  return { id, description, command: [...command], cwd, timeoutMs, tags: [...tags] };
 }
 function serializeVerifierDraft(draft) {
   const checks = [...draft.checks].sort((left, right) => compareCodepoints(left.id, right.id));
@@ -925,296 +953,11 @@ async function runVerifierAuthoringWorkflow(options) {
   };
 }
 
-// src/cli/verifiers.ts
-var HELP = `Project verifier authoring
-
-Usage:
-  clio-coder verifiers discover
-  clio-coder verifiers author [--exclude <id>] [--rename <old>=<new>] [--dry-run <id>] [--yes]
-  clio-coder verifiers validate
-  clio-coder verifiers dry-run <id>
-  clio-coder verifiers add --id <id> --description <text> --command <json-argv> [fields] [--yes]
-  clio-coder verifiers edit <id> [--description <text>] [--command <json-argv>] [fields] [--yes]
-  clio-coder verifiers rename <old> <new> [--yes]
-  clio-coder verifiers remove <id> [--yes]
-
-Fields:
-  --cwd <path>            repository-relative working directory (default .)
-  --timeout-ms <number>   bounded timeout in milliseconds (default 120000)
-  --tags <a,b>            comma-separated catalog tags
-
-Discovery and every preview are read-only. Mutating commands write only with
---yes after printing the exact argv, cwd, timeout, tags, source provenance, and
-effective execution authority. dry-run invokes the production verify path.
-`;
-var VALUE_OPTIONS = /* @__PURE__ */ new Set([
-  "--id",
-  "--description",
-  "--command",
-  "--cwd",
-  "--timeout-ms",
-  "--tags",
-  "--exclude",
-  "--rename",
-  "--dry-run"
-]);
-function parseAuthoringArgs(argv) {
-  const positional = [];
-  const values = /* @__PURE__ */ new Map();
-  let yes = false;
-  let help = false;
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "--yes") {
-      yes = true;
-      continue;
-    }
-    if (arg === "--help" || arg === "-h") {
-      help = true;
-      continue;
-    }
-    if (arg?.startsWith("--") === true) {
-      if (!VALUE_OPTIONS.has(arg)) return { yes, help, positional, values, error: `unknown option: ${arg}` };
-      const value = argv[index + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        return { yes, help, positional, values, error: `${arg} requires a value` };
-      }
-      const prior = values.get(arg) ?? [];
-      prior.push(value);
-      values.set(arg, prior);
-      index += 1;
-      continue;
-    }
-    if (arg !== void 0) positional.push(arg);
-  }
-  return { yes, help, positional, values };
-}
-function oneValue(parsed, option) {
-  return parsed.values.get(option)?.at(-1);
-}
-function parseCommand(value) {
-  if (value === void 0) return new Error("--command is required and must be a JSON argv array");
-  let parsed;
-  try {
-    parsed = JSON.parse(value);
-  } catch (error) {
-    return new Error(`--command must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some((entry) => typeof entry !== "string")) {
-    return new Error("--command must be a non-empty JSON string array");
-  }
-  return parsed;
-}
-function parseTimeout(value) {
-  if (value === void 0) return SAFE_EXEC_DEFAULT_TIMEOUT_MS;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) return new Error("--timeout-ms must be a positive integer");
-  return parsed;
-}
-function tags(value) {
-  return value === void 0 ? [] : value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-}
-function requiredValue(parsed, option) {
-  const value = oneValue(parsed, option);
-  return value === void 0 || value.length === 0 ? new Error(`${option} is required`) : value;
-}
-function authorRevisions(parsed) {
-  const revisions = [];
-  for (const id of parsed.values.get("--exclude") ?? []) revisions.push({ kind: "remove", id });
-  for (const rename of parsed.values.get("--rename") ?? []) {
-    const separator = rename.indexOf("=");
-    if (separator <= 0 || separator === rename.length - 1) {
-      return new Error("--rename must use <old>=<new>");
-    }
-    revisions.push({ kind: "rename", id: rename.slice(0, separator), newId: rename.slice(separator + 1) });
-  }
-  return revisions;
-}
-function addRevision(parsed) {
-  const id = requiredValue(parsed, "--id");
-  if (id instanceof Error) return id;
-  const description = requiredValue(parsed, "--description");
-  if (description instanceof Error) return description;
-  const command = parseCommand(oneValue(parsed, "--command"));
-  if (command instanceof Error) return command;
-  const timeoutMs = parseTimeout(oneValue(parsed, "--timeout-ms"));
-  if (timeoutMs instanceof Error) return timeoutMs;
-  return {
-    kind: "add",
-    check: {
-      id,
-      description,
-      command,
-      cwd: oneValue(parsed, "--cwd") ?? ".",
-      timeoutMs,
-      tags: tags(oneValue(parsed, "--tags"))
-    }
-  };
-}
-function editRevision(parsed) {
-  const id = parsed.positional[1];
-  if (id === void 0) return new Error("edit requires a check ID");
-  const changes = {};
-  const description = oneValue(parsed, "--description");
-  if (description !== void 0) changes.description = description;
-  const commandValue = oneValue(parsed, "--command");
-  if (commandValue !== void 0) {
-    const command = parseCommand(commandValue);
-    if (command instanceof Error) return command;
-    changes.command = command;
-  }
-  const cwd = oneValue(parsed, "--cwd");
-  if (cwd !== void 0) changes.cwd = cwd;
-  const timeoutValue = oneValue(parsed, "--timeout-ms");
-  if (timeoutValue !== void 0) {
-    const timeoutMs = parseTimeout(timeoutValue);
-    if (timeoutMs instanceof Error) return timeoutMs;
-    changes.timeoutMs = timeoutMs;
-  }
-  const tagValue = oneValue(parsed, "--tags");
-  if (tagValue !== void 0) changes.tags = tags(tagValue);
-  if (Object.keys(changes).length === 0) return new Error("edit requires at least one changed field");
-  return { kind: "edit", id, changes };
-}
-function mutationRevision(parsed) {
-  const command = parsed.positional[0];
-  if (command === "add") return addRevision(parsed);
-  if (command === "edit") return editRevision(parsed);
-  if (command === "rename") {
-    const id = parsed.positional[1];
-    const newId = parsed.positional[2];
-    if (id === void 0 || newId === void 0) return new Error("rename requires <old> and <new> IDs");
-    return { kind: "rename", id, newId };
-  }
-  if (command === "remove") {
-    const id = parsed.positional[1];
-    if (id === void 0) return new Error("remove requires a check ID");
-    return { kind: "remove", id };
-  }
-  return new Error(`unknown verifiers command: ${command ?? "(none)"}`);
-}
-function printDryRun(id, result) {
-  if (result.kind === "error") {
-    printError(`dry-run '${id}' failed: ${result.message}`);
-    return 1;
-  }
-  process.stdout.write(`Dry run '${id}':
-${result.output}${result.output.endsWith("\n") ? "" : "\n"}`);
-  return 0;
-}
-async function executeWorkflow(parsed, options) {
-  let printedPreview = false;
-  const dryRunCheckIds = parsed.values.get("--dry-run") ?? [];
-  const result = await runVerifierAuthoringWorkflow({
-    includeProposals: options.includeProposals,
-    initialRevisions: options.revisions,
-    confirmed: parsed.yes,
-    decide(context) {
-      process.stdout.write(`${context.preview}
-`);
-      printedPreview = true;
-      if (!parsed.yes || context.draft.checks.length === 0 && options.revisions.length === 0) {
-        return { kind: "reject" };
-      }
-      return { kind: "confirm", dryRunCheckIds };
-    }
-  });
-  if (result.status === "invalid") {
-    if (!printedPreview && result.preview !== void 0) process.stdout.write(`${result.preview}
-`);
-    printError(result.reason);
-    if (result.wrote && result.path !== void 0) {
-      process.stderr.write(`  ${result.path} was written; repair or remove it before running a check.
-`);
-    }
-    return 1;
-  }
-  if (result.status === "rejected") {
-    if (!parsed.yes) {
-      process.stdout.write("Review complete. Nothing changed; rerun the same command with --yes to write this preview.\n");
-    } else {
-      process.stdout.write(
-        "Nothing changed because the preview contains no catalog checks. Package checks remain active; unsupported commands can be added with `clio-coder verifiers add`.\n"
-      );
-    }
-    return 0;
-  }
-  printOk(`wrote ${result.path}; production parser accepted the catalog`);
-  let code = 0;
-  for (const dryRun of result.dryRuns) code = Math.max(code, printDryRun(dryRun.id, dryRun.result));
-  return code;
-}
-async function discoverCommand() {
-  const discovery = discoverVerifierAuthoring();
-  if (!discovery.ok) {
-    printError(discovery.reason);
-    process.stderr.write(`${discovery.manualEntry}
-`);
-    return 1;
-  }
-  process.stdout.write(`${previewVerifierDraft(createVerifierDraft(discovery))}
-`);
-  return 0;
-}
-function validateCommand() {
-  const loaded = loadProjectVerifierCatalog(process.cwd());
-  if (!loaded.ok) {
-    printError(`production catalog parser rejected ${loaded.reason}`);
-    return 1;
-  }
-  if (loaded.source === null) {
-    process.stdout.write(`No ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} exists. Run \`clio-coder verifiers author\`.
-`);
-    return 0;
-  }
-  printOk(
-    `production catalog parser accepted ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} (${loaded.source.checks.length} check${loaded.source.checks.length === 1 ? "" : "s"})`
-  );
-  return 0;
-}
-async function runVerifiersCommand(argv) {
-  const parsed = parseAuthoringArgs(argv);
-  if (parsed.error !== void 0) {
-    printError(parsed.error);
-    process.stderr.write(HELP);
-    return 2;
-  }
-  if (parsed.help || parsed.positional.length === 0) {
-    process.stdout.write(HELP);
-    return 0;
-  }
-  const command = parsed.positional[0];
-  if (command === "discover") return discoverCommand();
-  if (command === "validate") return validateCommand();
-  if (command === "dry-run") {
-    const id = parsed.positional[1];
-    if (id === void 0) {
-      printError("dry-run requires a check ID");
-      return 2;
-    }
-    return printDryRun(id, await verifyTool.run({ check: id }));
-  }
-  if (command === "author") {
-    const revisions = authorRevisions(parsed);
-    if (revisions instanceof Error) {
-      printError(revisions.message);
-      return 2;
-    }
-    return executeWorkflow(parsed, { includeProposals: true, revisions });
-  }
-  if (["add", "edit", "rename", "remove"].includes(command ?? "")) {
-    const revision = mutationRevision(parsed);
-    if (revision instanceof Error) {
-      printError(revision.message);
-      return 2;
-    }
-    return executeWorkflow(parsed, { includeProposals: false, revisions: [revision] });
-  }
-  printError(`unknown verifiers command: ${command}`);
-  process.stderr.write(HELP);
-  return 2;
-}
 export {
-  runVerifiersCommand
+  discoverDeclaredProjectCommands,
+  discoverVerifierAuthoring,
+  createVerifierDraft,
+  previewVerifierDraft,
+  runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=verifiers-NCBTHHN2.js.map
+//# sourceMappingURL=chunk-YTYFXUI3.js.map