faberun 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Faberun is a development orchestration system that turns intent into verified software: harness- and model-agnostic, it keeps the intent, coordinates the work, verifies the result and decides what happens next.",
   "type": "module",
   "bin": {
@@ -27,6 +27,8 @@
     "check": "for f in bin/*.mjs .claude/hooks/*.mjs src/*.mjs src/*/*.mjs src/*/*/*.mjs evals/*.mjs test/*.mjs test/*/*.mjs; do node --check \"$f\" || exit 1; done",
     "typecheck": "tsc",
     "test": "node --test test/*.test.mjs test/*/*.test.mjs",
+    "docs": "node src/cli/manual.mjs --write",
+    "docs:check": "node src/cli/manual.mjs --check",
     "prepare": "husky"
   },
   "devDependencies": {

package/skills/faberun/SKILL.md

@@ -10,6 +10,7 @@ Read [rules](references/rules.md) first.
 
 | Action | Read |
 | --- | --- |
+| Write or validate a spec | [spec-format](references/spec-format.md) |
 | Author a contract (fallback) | [contract](references/contract.md), [engineering](references/engineering.md) |
 | Launch and resume | [workflow](references/workflow.md), [operations](references/operations.md) |
 | Dispatch a node | [handoffs](references/handoffs.md) |

package/skills/faberun/references/spec-format.md

@@ -0,0 +1,87 @@
+# Spec format reference
+
+Format version `1`. A spec is the free-form input the operator hands the
+planner; this is the structured shape it validates against
+(`faberun spec validate`, no model invoked). A document without the front
+matter below is classified `legacy` and accepted, not rejected — the
+validator says so explicitly, so old campaign records keep working.
+
+## Front matter
+
+```yaml
+---
+id: kebab-case-campaign-id
+title: "Human-readable title"
+version: 1.1.0
+status: draft
+date: 2026-09-17
+owner: Author Name
+target: org/repo
+baseline: <git sha the spec was measured against>
+---
+```
+
+`id`, `title`, `version`, `status`, `date`, `owner`, `target`, `baseline` are
+required. `derived_from` and `followed_by` are optional cross-references to
+other spec ids (a prior spec this one revises, or the campaign meant to
+follow it).
+
+## Sections
+
+Mandatory, in order: **Intent**, **Requirements**, **Non-goals**. The
+reference proposal
+(`docs/campaigns/spec-format-and-planning-stages/spec/PROPOSAL.md`) writes
+these as `Intenção`, `Requisitos`, `Não-objetivos` — the section role is what
+matters, not the language of the heading text.
+
+- **Intent** — prose: why this work, what problem, what it unblocks.
+- **Requirements** — one `### R<n>. <title>` block per requirement (see
+  below).
+- **Non-goals** — a bullet list of what this spec explicitly excludes, so a
+  planner never infers scope from silence.
+
+Optional sections, any subset, any order after Non-goals:
+
+- **Constraints** — bullets binding every requirement at once (e.g. "no node
+  runs the full suite").
+- **Success criteria** — a table with at least a `Baseline` column, so
+  validation can catch a metric nobody measured before claiming a delta.
+- **Risks** — a table of risk / impact / mitigation.
+
+## Requirement shape
+
+```markdown
+### R7. Repo facts are deterministic and carry measured duration
+
+- **statement:** the target repo inventory is generated without invoking a
+  model, is identical across two runs at the same HEAD, and every candidate
+  verification command carries a duration measured by
+  `preflight --time-verification`.
+- **proof:** command: node --test --test-name-pattern="repo facts"
+```
+
+`R<n>` is a stable id — never renumbered once referenced elsewhere (a
+comparative arm, a follow-up spec). `statement` is the testable claim.
+`proof` is exactly one of:
+
+- `command: <shell command>` — re-run it, exit zero proves the requirement.
+- `path: <repo-relative path>` — the file or directory must exist.
+- `judgment: true` — no deterministic check; a reviewer decides.
+
+A requirement may add its own `- **constraints:** ...` line for a rule
+scoped to it alone, distinct from the spec-wide Constraints section.
+
+## What `faberun spec validate` checks
+
+Deterministic, no model call. Rejects:
+
+- a requirement without a stable id, or without a `proof` line;
+- a spec with no Non-goals section;
+- a Success criteria table row with no Baseline value;
+- a `target` or `baseline` that does not resolve to a real commit.
+
+These are **advisory** by default — recorded as findings, spec still
+validates — and become **blocking** under `--strict-traceability`, which
+fails validation on any of the above. A `legacy`-class document (no front
+matter) is exempt from every check above; it is accepted and labeled, never
+scored against these rules.

package/src/campaign/index.mjs

@@ -1,4 +1,5 @@
 import {
+  copyFileSync,
   existsSync,
   mkdirSync,
   readFileSync,
@@ -9,7 +10,7 @@ import { join, resolve } from "node:path";
 import { writeJsonAtomic } from "../run/store.mjs";
 import { requireId, requirePacketHash, requireString, requireTimestamp } from "../contract/assert.mjs";
 import { promoteRun } from "../repo/integrate.mjs";
-import { CAMPAIGN_FILE, GOAL_TEXT_BYTES, PROJECTION_FILE, campaignDir, campaignsDir } from "./layout.mjs";
+import { CAMPAIGN_FILE, GOAL_TEXT_BYTES, JOURNAL_FILE, PROJECTION_FILE, campaignDir, campaignsDir } from "./layout.mjs";
 import { readCampaign } from "./record.mjs";
 import { appendJournal, normalizeText, readJournalForDedupe } from "./journal.mjs";
 import { readProjectionState } from "./projection.mjs";
@@ -122,7 +123,7 @@ export function resolveCampaign(runsDir, campaignId) {
 /**
  * @param {string} campaignPath
  * @param {{at?: string, eventId?: string}} options
- * @returns {{path: string, campaign: Campaign}}
+ * @returns {{path: string, campaign: Campaign, ledgerFiles: string[]}}
  */
 export function closeCampaign(campaignPath, { at = new Date().toISOString(), eventId = randomUUID() } = {}) {
   requireTimestamp(at, "at");
@@ -131,10 +132,52 @@ export function closeCampaign(campaignPath, { at = new Date().toISOString(), eve
   if (!readJournalForDedupe(campaignPath).some((entry) => entry.type === "retrospective")) {
     throw new Error(`campaign ${campaign.id} has no recorded retrospective; record one with note --kind retrospective before close`);
   }
+  const repoRoot = resolve(campaignPath, "..", "..", "..");
+  const ledgerFiles = preserveCampaignLedger(campaignPath, repoRoot);
   const closed = /** @type {Campaign} */ ({ ...campaign, status: "closed", closedAt: at, updatedAt: at });
   writeJsonAtomic(join(campaignPath, CAMPAIGN_FILE), closed);
   appendJournal(campaignPath, { type: "campaign.closed", at, eventId });
-  return { path: campaignPath, campaign: closed };
+  return { path: campaignPath, campaign: closed, ledgerFiles };
+}
+
+/**
+ * Copy a campaign's journal, record and each linked run's usage into
+ * `<repoRoot>/docs/campaigns/<id>/ledger/` so the comparative arm of the
+ * planner has a session-side baseline even after `.runs/` (gitignored) is
+ * pruned. Nothing in this tree redacts token counts, costs or operator notes
+ * before this point, so the copy is verbatim; the pre-commit secret scan is
+ * the guard against anything that should not land in git.
+ *
+ * Idempotent: re-running it (a second `close` on an already-closed campaign
+ * cannot reach this, but a direct call can) overwrites the same destination
+ * files rather than duplicating them. A linked run without a `usage.jsonl`
+ * (never launched, or pruned) is skipped rather than thrown.
+ *
+ * @param {string} campaignPath
+ * @param {string} repoRoot
+ * @returns {string[]}
+ */
+export function preserveCampaignLedger(campaignPath, repoRoot) {
+  const campaign = readCampaign(campaignPath);
+  const runsDir = resolve(campaignPath, "..", "..");
+  const ledgerDir = join(repoRoot, "docs", "campaigns", campaign.id, "ledger");
+  mkdirSync(ledgerDir, { recursive: true });
+  const written = [];
+  for (const name of [JOURNAL_FILE, CAMPAIGN_FILE]) {
+    const source = join(campaignPath, name);
+    if (!existsSync(source)) continue;
+    const destination = join(ledgerDir, name);
+    copyFileSync(source, destination);
+    written.push(destination);
+  }
+  for (const runId of campaign.linkedRunIds) {
+    const source = join(runsDir, runId, "usage.jsonl");
+    if (!existsSync(source)) continue;
+    const destination = join(ledgerDir, `${runId}.usage.jsonl`);
+    copyFileSync(source, destination);
+    written.push(destination);
+  }
+  return written;
 }
 
 /**

package/src/cli/brand.mjs

@@ -195,6 +195,8 @@ export function renderUsage() {
     "next [--cwd <dir>] [--json]",
     "bulk-read --question <text> --paths <a,b,c> [--json]",
     "contract validate <contract.json>",
+    "spec validate <file> [--strict-traceability] [--json]",
+    "spec scaffold <path> [--id <id>]",
     "metrics <campaign-id> [--cwd <dir>] [--json]",
     "campaign <init|watch|attach|note|resolve|close|supervise|show|list|sync|ack> ...",
     "seat <start|attach|status|stop> [<campaign-id>] [--cwd <dir>] ...",

package/src/cli/campaign.mjs

@@ -447,6 +447,7 @@ function close(campaignId, values) {
   const closed = closeCampaign(path, { eventId: values.eventId ?? randomUUID() });
   renderHandoff(path, runsDir);
   process.stdout.write(`[campaign] ${closed.campaign.id} closed\n`);
+  process.stdout.write(`[campaign] ledger · docs/campaigns/${closed.campaign.id}/ledger · ${closed.ledgerFiles.length} files\n`);
   if (syncAgentSignal(runsDir)) process.stdout.write(`[campaign] AGENTS.md signal updated\n`);
 }
 
@@ -728,3 +729,5 @@ function usage() {
   );
   process.exitCode = 2;
 }
+
+export default OPERATION_OPTIONS;

package/src/cli/contract.mjs

@@ -65,3 +65,5 @@ function usage() {
   process.stderr.write("usage: faberun contract validate <contract.json>\n");
   process.exitCode = 2;
 }
+
+export default OPERATION_OPTIONS;

package/src/cli/manual.mjs

@@ -0,0 +1,343 @@
+/**
+ * Regenerates the derivable parts of docs/COMMANDS.md — verb and operation
+ * headings, synopsis lines and flag-table rows — from the option tables the
+ * CLI itself dispatches on. Every other line (description paragraphs,
+ * reads/writes prose, examples, Related lines, and the four fixed sections)
+ * is copied through unchanged, so the manual's prose stays hand-authored
+ * while its command surface cannot drift from the code silently.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { COMMAND_OPTIONS } from "../cli.mjs";
+import CAMPAIGN_OPERATIONS from "./campaign.mjs";
+import SEAT_OPERATIONS from "./seat.mjs";
+import CONTRACT_OPERATIONS from "./contract.mjs";
+import SKILLS_OPERATIONS from "./skills.mjs";
+import SPEC_OPERATIONS from "./spec.mjs";
+
+/** @typedef {{type: "string"|"boolean", multiple?: boolean}} FlagSpec */
+/** @typedef {{flags?: Record<string, FlagSpec>, operations?: Record<string, Record<string, FlagSpec>>}} VerbSurface */
+/** @typedef {{verbs: Record<string, VerbSurface>}} Surface */
+
+const MANUAL_PATH = fileURLToPath(new URL("../../docs/COMMANDS.md", import.meta.url));
+
+/**
+ * `campaign`, `seat`, `contract`, `skills` and `spec` are dispatched before
+ * `COMMAND_OPTIONS` is ever consulted (`cli.mjs` routes them by `argv[0]`), so
+ * they carry no flags of their own — only the operations their own module
+ * declares. Their top-level `## faberun <verb>` section is therefore never
+ * regenerated; it is hand-authored overview prose, preserved verbatim.
+ *
+ * @type {Record<string, Record<string, Record<string, FlagSpec>>>}
+ */
+const CONTAINER_OPERATIONS = {
+  campaign: CAMPAIGN_OPERATIONS,
+  seat: SEAT_OPERATIONS,
+  contract: CONTRACT_OPERATIONS,
+  skills: SKILLS_OPERATIONS,
+  spec: SPEC_OPERATIONS,
+};
+
+/**
+ * The real command surface, read from the same option tables `cli.mjs`
+ * parses argv against. `supervise campaign` is `campaign.mjs`'s `supervise`
+ * operation reached through a second spelling (`cli.mjs` routes
+ * `argv = ["supervise", "campaign", …]` into `campaignCli`), so it shares that
+ * operation's flags rather than declaring its own.
+ *
+ * @returns {Surface}
+ */
+export function collectSurface() {
+  /** @type {Record<string, VerbSurface>} */
+  const verbs = {};
+  for (const [verb, flags] of Object.entries(COMMAND_OPTIONS)) verbs[verb] = { flags };
+  if (verbs.supervise) verbs.supervise.operations = { campaign: CAMPAIGN_OPERATIONS.supervise };
+  for (const [verb, operations] of Object.entries(CONTAINER_OPERATIONS)) verbs[verb] = { operations };
+  return { verbs };
+}
+
+const VERB_HEADING = /^## faberun ([a-z][a-z-]*)$/u;
+const TABLE_HEADER = "| Flag | Value | Effect | Default |";
+const TABLE_SEPARATOR = "| --- | --- | --- | --- |";
+/** The start of a flag token in a synopsis line: `--flag` or `[--flag`. */
+const FLAG_TOKEN = /\[?--/u;
+
+/**
+ * Regenerate the derivable parts of a command manual. A verb absent from
+ * `surface` is dropped; one present in `surface` but absent from `current` is
+ * appended as a skeleton section.
+ *
+ * @param {string} current
+ * @param {Surface} surface
+ * @returns {string}
+ */
+export function renderManual(current, surface) {
+  const lines = current.split("\n");
+  /** @type {string[]} */
+  const output = [];
+  const seenVerbs = new Set();
+  let i = 0;
+  while (i < lines.length) {
+    const match = VERB_HEADING.exec(lines[i]);
+    if (!match) {
+      output.push(lines[i]);
+      i += 1;
+      continue;
+    }
+    const verb = match[1];
+    let end = i + 1;
+    while (end < lines.length && !/^## /u.test(lines[end])) end += 1;
+    const entry = surface.verbs[verb];
+    if (entry) {
+      output.push(...renderVerbBlock(verb, lines.slice(i, end), entry));
+      seenVerbs.add(verb);
+    }
+    i = end;
+  }
+  for (const [verb, entry] of Object.entries(surface.verbs)) {
+    if (!seenVerbs.has(verb)) output.push(...renderVerbBlock(verb, [`## faberun ${verb}`], entry));
+  }
+  return output.join("\n");
+}
+
+/**
+ * @param {string} verb
+ * @param {string[]} block
+ * @param {VerbSurface} entry
+ * @returns {string[]}
+ */
+function renderVerbBlock(verb, block, entry) {
+  const heading = block[0] ?? `## faberun ${verb}`;
+  const { body, operationBlocks } = splitOperations(verb, block.slice(1));
+  const renderedBody = entry.flags
+    ? renderFlaggedBody(`faberun ${verb}`, body, entry.flags)
+    : body.length
+      ? body
+      : renderFlaggedBody(`faberun ${verb}`, [], {});
+  const renderedOperations = renderOperations(verb, operationBlocks, entry.operations ?? {});
+  return [heading, ...renderedBody, ...renderedOperations];
+}
+
+/**
+ * Splits a verb's body into the part before its first `### faberun <verb>
+ * <op>` heading and the operation sub-blocks that follow, each running to the
+ * next `### ` heading.
+ *
+ * @param {string} verb
+ * @param {string[]} lines
+ * @returns {{body: string[], operationBlocks: {op: string, block: string[]}[]}}
+ */
+function splitOperations(verb, lines) {
+  const opHeading = new RegExp(`^### faberun ${verb} ([a-z][a-z-]*)$`, "u");
+  const firstOpIndex = lines.findIndex((line) => opHeading.test(line));
+  if (firstOpIndex === -1) return { body: lines, operationBlocks: [] };
+  const body = lines.slice(0, firstOpIndex);
+  /** @type {{op: string, block: string[]}[]} */
+  const operationBlocks = [];
+  let i = firstOpIndex;
+  while (i < lines.length) {
+    const match = opHeading.exec(lines[i]);
+    if (!match) break;
+    let end = i + 1;
+    while (end < lines.length && !/^###? /u.test(lines[end])) end += 1;
+    operationBlocks.push({ op: match[1], block: lines.slice(i, end) });
+    i = end;
+  }
+  return { body, operationBlocks };
+}
+
+/**
+ * @param {string} verb
+ * @param {{op: string, block: string[]}[]} operationBlocks
+ * @param {Record<string, Record<string, FlagSpec>>} operations
+ * @returns {string[]}
+ */
+function renderOperations(verb, operationBlocks, operations) {
+  const output = [];
+  const seen = new Set();
+  for (const { op, block } of operationBlocks) {
+    if (!Object.hasOwn(operations, op)) continue;
+    output.push(block[0] ?? `### faberun ${verb} ${op}`, ...renderFlaggedBody(`faberun ${verb} ${op}`, block.slice(1), operations[op]));
+    seen.add(op);
+  }
+  for (const [op, flags] of Object.entries(operations)) {
+    if (seen.has(op)) continue;
+    output.push(`### faberun ${verb} ${op}`, ...renderFlaggedBody(`faberun ${verb} ${op}`, [], flags));
+  }
+  return output;
+}
+
+/**
+ * Regenerates a section's synopsis fence and flag table in place; every
+ * other line is untouched.
+ *
+ * @param {string} prefix
+ * @param {string[]} body
+ * @param {Record<string, FlagSpec>} flags
+ * @returns {string[]}
+ */
+function renderFlaggedBody(prefix, body, flags) {
+  const positional = extractPositional(prefix, body);
+  const synopsis = renderSynopsis(prefix, positional, flags);
+  const fence = findFence(body, "```text");
+  const withSynopsis = fence
+    ? [...body.slice(0, fence.start), "```text", synopsis, "```", ...body.slice(fence.end + 1)]
+    : ["```text", synopsis, "```", ...body];
+  return replaceFlagTable(withSynopsis, flags);
+}
+
+/**
+ * The positional placeholder a synopsis names, kept verbatim from the
+ * current text (including its own brackets, when optional) — everything
+ * before the first flag token.
+ *
+ * @param {string} prefix
+ * @param {string[]} body
+ * @returns {string}
+ */
+function extractPositional(prefix, body) {
+  const fence = findFence(body, "```text");
+  if (!fence) return "";
+  const inner = body[fence.start + 1] ?? "";
+  if (!inner.startsWith(prefix)) return "";
+  const remainder = inner.slice(prefix.length).trim();
+  const flagToken = FLAG_TOKEN.exec(remainder);
+  return flagToken ? remainder.slice(0, flagToken.index).trim() : remainder;
+}
+
+/**
+ * @param {string} prefix
+ * @param {string} positional
+ * @param {Record<string, FlagSpec>} flags
+ * @returns {string}
+ */
+function renderSynopsis(prefix, positional, flags) {
+  const parts = [prefix];
+  if (positional) parts.push(positional);
+  for (const [name, spec] of Object.entries(flags)) {
+    if (spec.type === "boolean") parts.push(`[--${name}]`);
+    else if (spec.multiple) parts.push(`[--${name} <a>...]`);
+    else parts.push(`[--${name} <value>]`);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * @param {string[]} lines
+ * @param {string} opener
+ * @returns {{start: number, end: number}|null}
+ */
+function findFence(lines, opener) {
+  const start = lines.indexOf(opener);
+  if (start === -1) return null;
+  let end = start + 1;
+  while (end < lines.length && lines[end] !== "```") end += 1;
+  return { start, end };
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Record<string, FlagSpec>} flags
+ * @returns {string[]}
+ */
+function replaceFlagTable(lines, flags) {
+  const headerIndex = lines.indexOf(TABLE_HEADER);
+  const existingRows = headerIndex === -1 ? new Map() : parseRows(lines, headerIndex + 2);
+  const newRows = buildRows(flags, existingRows);
+  if (headerIndex === -1) {
+    const fenceEnd = lines.indexOf("```");
+    const insertAt = fenceEnd === -1 ? lines.length : fenceEnd + 1;
+    return [...lines.slice(0, insertAt), TABLE_HEADER, TABLE_SEPARATOR, ...newRows, ...lines.slice(insertAt)];
+  }
+  let rowsEnd = headerIndex + 2;
+  while (rowsEnd < lines.length && lines[rowsEnd].startsWith("|")) rowsEnd += 1;
+  return [...lines.slice(0, headerIndex), TABLE_HEADER, TABLE_SEPARATOR, ...newRows, ...lines.slice(rowsEnd)];
+}
+
+/**
+ * @param {string[]} lines
+ * @param {number} start
+ * @returns {Map<string, {value: string, effect: string, default: string}>}
+ */
+function parseRows(lines, start) {
+  /** @type {Map<string, {value: string, effect: string, default: string}>} */
+  const map = new Map();
+  let i = start;
+  while (i < lines.length && lines[i].startsWith("|")) {
+    const cells = lines[i].trim().replace(/^\|/u, "").replace(/\|$/u, "").split("|").map((cell) => cell.trim());
+    if (cells.length === 4) map.set(flagKeyOf(cells[0]), { value: cells[1], effect: cells[2], default: cells[3] });
+    i += 1;
+  }
+  return map;
+}
+
+/** @param {string} cell @returns {string} */
+function flagKeyOf(cell) {
+  const match = /`--([a-z-]+)`/u.exec(cell);
+  return match ? match[1] : "—";
+}
+
+/**
+ * @param {Record<string, FlagSpec>} flags
+ * @param {Map<string, {value: string, effect: string, default: string}>} existingRows
+ * @returns {string[]}
+ */
+function buildRows(flags, existingRows) {
+  const names = Object.keys(flags);
+  if (names.length === 0) {
+    const existing = existingRows.get("—");
+    return [existing ? `| — | ${existing.value} | ${existing.effect} | ${existing.default} |` : "| — | — | No flags. | — |"];
+  }
+  return names.map((name) => {
+    const existing = existingRows.get(name);
+    const value = existing ? existing.value : "<value>";
+    const effect = existing ? existing.effect : "";
+    const fallback = existing ? existing.default : "—";
+    return `| \`--${name}\` | ${value} | ${effect} | ${fallback} |`;
+  });
+}
+
+/**
+ * A minimal, dependency-free diff summary: every line index where the two
+ * texts disagree, capped so a large rewrite does not flood the console.
+ *
+ * @param {string} current
+ * @param {string} next
+ * @returns {string}
+ */
+function diffSummary(current, next) {
+  const a = current.split("\n");
+  const b = next.split("\n");
+  const max = Math.max(a.length, b.length);
+  /** @type {string[]} */
+  const lines = [];
+  for (let i = 0; i < max && lines.length < 40; i += 1) {
+    if (a[i] !== b[i]) lines.push(`line ${i + 1}:\n- ${a[i] ?? "<eof>"}\n+ ${b[i] ?? "<eof>"}`);
+  }
+  return lines.join("\n");
+}
+
+/**
+ * @param {string[]} argv
+ * @returns {void}
+ */
+function main(argv) {
+  const mode = argv[0];
+  if (mode !== "--write" && mode !== "--check") {
+    process.stderr.write("usage: manual.mjs --write|--check\n");
+    process.exitCode = 2;
+    return;
+  }
+  const current = readFileSync(MANUAL_PATH, "utf8");
+  const next = renderManual(current, collectSurface());
+  if (next === current) return;
+  if (mode === "--write") {
+    writeFileSync(MANUAL_PATH, next);
+    return;
+  }
+  process.stderr.write(`docs/COMMANDS.md is out of date; run \`npm run docs\`.\n${diffSummary(current, next)}\n`);
+  process.exitCode = 1;
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) main(process.argv.slice(2));

package/src/cli/seat.mjs

@@ -137,3 +137,5 @@ function usage() {
   process.stderr.write("usage: faberun seat <start|attach|status|stop|switch> [<campaign-id>] [--cwd <dir>] ...\n");
   process.exitCode = 2;
 }
+
+export default OPERATION_OPTIONS;

package/src/cli/skills.mjs

@@ -403,3 +403,5 @@ function usage() {
   process.stderr.write("usage: faberun skills <list|install|register> [<name>...] [--target <dir>] [--global] [--force] [--copy] [--harness <a,b>] [--json]\n");
   process.exitCode = 2;
 }
+
+export default OPERATION_OPTIONS;