rcf-lite 0.7.1 → 0.9.0

package/src/cli/blueprint.js

@@ -0,0 +1,325 @@
+// `rcf blueprint <verb>` CLI landing.
+//
+// Verbs:
+//   add          apply a blueprint (with optional --resolve)
+//   list         projection over manifest.blueprints[]
+//   remove       remove an applied blueprint
+//   supersede    scaffold a project ADR + record a resolutions[] entry
+//   diff         side-by-side view of applied blueprints' scope:global
+//                ADRs on a topic
+
+import { parseArgs } from 'node:util';
+
+import { isRcfError } from '#core/errors';
+import { walkTree } from '#core/store';
+import { findProjectRoot } from '../view/index.js';
+import {
+  applyBlueprint,
+  diffBlueprintTopic,
+  listBlueprints,
+  removeBlueprint,
+  renderDiff,
+  supersedeBlueprintTopic,
+} from '../blueprint/index.js';
+import { conflictReportJson, renderConflictReport } from '../blueprint/conflicts.js';
+
+export const HELP = `Usage: rcf blueprint <verb> [options]
+
+Verbs:
+  add <source>           Apply a blueprint from a source directory
+                         (Phase 1: local path; the registry / git-ref
+                         resolver is a Phase 2 concern). Writes an entry
+                         to manifest.blueprints[] and copies namespaced
+                         contributions into the tree.
+  list                   List every applied blueprint (slug, version,
+                         appliedAt, contributionCount).
+  remove <slug>          Remove an applied blueprint. Refuses when any
+                         project-authored doc references a contribution
+                         id; prints the referring docs and exits 3.
+  supersede <topic> [--incoming <source>]
+                         Author a project-level ADR that supersedes the
+                         conflict pair on <topic> (one applied blueprint
+                         ADR + one incoming blueprint ADR named via
+                         --incoming <source>), and record a
+                         manifest.resolutions[] entry so the conflict
+                         detector honours the resolution when the
+                         operator re-runs \`rcf blueprint add <source>\`.
+                         --incoming is required when the topic has fewer
+                         than two applied scope:global ADRs (the
+                         refused-add state) and is silently accepted
+                         when already >= 2 are applied. Both blueprint
+                         ADRs co-reside on disk as superseded history.
+  diff <topic>           Side-by-side view of every applied blueprint's
+                         scope:global ADR on <topic>: id, path, title,
+                         status, decision. Read-only.
+
+Options:
+  --namespace <slug>     Override the blueprint's default namespace
+                         (defaults to the blueprint's slug).
+  --resolve <t=project:ADR-id>
+                         (add only) Declare a resolution on this add.
+                         Repeatable per conflicted topic. Records a
+                         manifest.resolutions[] entry before conflict
+                         detection runs, so a would-be conflict on the
+                         topic is honoured. resolvedByAdrId must be a
+                         well-formed ADR id; the referenced ADR should
+                         already exist on the project (this verb does
+                         not scaffold one -- use \`supersede\` for that).
+  --reason <text>        (supersede, add --resolve) Optional operator
+                         note attached to the manifest.resolutions[]
+                         record.
+  --json                 (add only) Emit the result (or conflict
+                         report) as a machine-readable JSON object.
+                         Exit code is unchanged (0 on apply, 3 on
+                         conflict).
+  --dry-run              Print intended writes without executing.
+  --quiet                Suppress non-error stdout.
+  --help                 Print this help.
+
+Composition and namespacing:
+
+  Blueprint-contributed doc ids are namespaced by the blueprint's slug.
+  REQ / US / PRD / BS / TAD / TS: slug PREFIX (spa-REQ-001).
+  ADR / TAC / FBS / CN: slug SUFFIX (ADR-005-spa).
+  Two blueprints both contributing a scope:global ADR on the same topic
+  is a genuine conflict: rcf blueprint add refuses and prints both
+  sides, plus four resolution paths (adopt incoming, keep existing,
+  supersede via project ADR, or declare on the add itself via
+  --resolve).
+`;
+
+const OPTION_SPEC = {
+  namespace: { type: 'string' },
+  resolve: { type: 'string', multiple: true },
+  reason: { type: 'string' },
+  incoming: { type: 'string' },
+  json: { type: 'boolean' },
+  'dry-run': { type: 'boolean' },
+  quiet: { type: 'boolean' },
+  help: { type: 'boolean' },
+};
+
+/**
+ * @param {string[]} argv - argv slice after `blueprint`
+ * @param {object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function main(argv, deps = {}) {
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  const cwd = deps.cwd ?? process.cwd();
+  const now = deps.now ?? new Date();
+
+  let parsed;
+  try {
+    parsed = parseArgs({ args: argv, options: OPTION_SPEC, allowPositionals: true, strict: true });
+  } catch (err) {
+    stderr.write(`[error] ${err.message}\n`);
+    stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.values.help || parsed.positionals.length === 0) {
+    stdout.write(HELP);
+    return 0;
+  }
+  const verb = parsed.positionals[0];
+  const rest = parsed.positionals.slice(1);
+
+  const projectRoot = await findProjectRoot(cwd);
+  if (!projectRoot) {
+    stderr.write('[error] no rcf/ tree found in this directory or any ancestor.\n');
+    return 2;
+  }
+  const { tree, errors } = await walkTree({ projectRoot });
+  if (errors.length > 0 && verb !== 'list') {
+    // Tree errors are non-fatal for list; every other verb needs a clean tree.
+    for (const e of errors) stderr.write(`[tree] ${e.kind}: ${e.message}\n`);
+    return 2;
+  }
+
+  if (verb === 'add') {
+    if (rest.length === 0) {
+      stderr.write('[error] blueprint add: missing <source>\n');
+      return 2;
+    }
+    const source = rest[0];
+    const resolveDeclarations = parseResolveOptions(parsed.values.resolve, parsed.values.reason);
+    if (resolveDeclarations.error) {
+      stderr.write(`[error] blueprint add: ${resolveDeclarations.error}\n`);
+      return 2;
+    }
+    const result = await applyBlueprint({
+      projectRoot, tree, source,
+      namespaceOverride: parsed.values.namespace,
+      resolveDeclarations: resolveDeclarations.value,
+      now,
+      dryRun: parsed.values['dry-run'] === true,
+    });
+    // Surface any writer-side warnings (currently only
+    // duplicate-topic --resolve dedupe). Warnings do not change the
+    // exit code; they land on stderr so the human sees them alongside
+    // the applied line on stdout.
+    if (result && !isRcfError(result) && Array.isArray(result.warnings)) {
+      for (const w of result.warnings) {
+        if (w.kind === 'duplicateResolveTopic' && Array.isArray(w.topics)) {
+          for (const t of w.topics) {
+            stderr.write(`[warn] blueprint add: duplicate --resolve for topic '${t}'; keeping the first declaration only.\n`);
+          }
+        }
+      }
+    }
+    if (isRcfError(result)) {
+      if (parsed.values.json) {
+        stderr.write(`${JSON.stringify({ refused: true, error: { kind: result.kind, message: result.message } })}\n`);
+      } else {
+        stderr.write(`[error] blueprint add: ${result.message}\n`);
+      }
+      return 2;
+    }
+    if (result.conflicts && result.conflicts.length > 0) {
+      if (parsed.values.json) {
+        stdout.write(`${JSON.stringify(conflictReportJson(result.conflicts), null, 2)}\n`);
+      } else {
+        stderr.write(renderConflictReport(result.conflicts));
+      }
+      return 3;
+    }
+    if (parsed.values.json) {
+      stdout.write(`${JSON.stringify({
+        refused: false,
+        applied: result.applied === true,
+        alreadyApplied: result.alreadyApplied === true,
+        slug: result.slug,
+        version: result.version,
+        contributionCount: Array.isArray(result.contributions) ? result.contributions.length : 0,
+      })}\n`);
+      return 0;
+    }
+    if (result.alreadyApplied) {
+      if (!parsed.values.quiet) stdout.write(`[blueprint] '${result.slug}' already applied at ${result.version}; no changes.\n`);
+      return 0;
+    }
+    if (!parsed.values.quiet) {
+      stdout.write(`[blueprint] applied '${result.slug}' at ${result.version} (${result.contributions.length} contribution(s)).\n`);
+    }
+    return 0;
+  }
+
+  if (verb === 'list') {
+    const rows = listBlueprints(tree);
+    if (rows.length === 0) {
+      if (!parsed.values.quiet) stdout.write('[blueprint] no blueprints applied on this project.\n');
+      return 0;
+    }
+    for (const row of rows) {
+      stdout.write(`${row.slug}\t${row.version}\t${row.appliedAt}\t${row.contributionCount} contribution(s)\n`);
+    }
+    return 0;
+  }
+
+  if (verb === 'remove') {
+    if (rest.length === 0) {
+      stderr.write('[error] blueprint remove: missing <slug>\n');
+      return 2;
+    }
+    const slug = rest[0];
+    const result = await removeBlueprint({
+      projectRoot, tree, slug, dryRun: parsed.values['dry-run'] === true,
+    });
+    if (isRcfError(result)) {
+      stderr.write(`[error] blueprint remove: ${result.message}\n`);
+      return 2;
+    }
+    if (!result.removed) {
+      stderr.write(`[blueprint] remove refused: ${result.referringDocs.length} referring doc(s):\n`);
+      for (const r of result.referringDocs) {
+        stderr.write(`  ${r.docId} references ${r.matchedId}\n`);
+      }
+      stderr.write('resolve by unbinding the references, then re-run.\n');
+      return 3;
+    }
+    if (!parsed.values.quiet) stdout.write(`[blueprint] removed '${result.slug}' (${result.deletedPaths.length} file(s) deleted).\n`);
+    return 0;
+  }
+
+  if (verb === 'supersede') {
+    if (rest.length === 0) {
+      stderr.write('[error] blueprint supersede: missing <topic>\n');
+      return 2;
+    }
+    const topic = rest[0];
+    const result = await supersedeBlueprintTopic({
+      projectRoot, tree, topic,
+      incomingSource: parsed.values.incoming,
+      now,
+      dryRun: parsed.values['dry-run'] === true,
+      reason: parsed.values.reason,
+    });
+    if (isRcfError(result)) {
+      stderr.write(`[error] blueprint supersede: ${result.message}\n`);
+      return 2;
+    }
+    if (!parsed.values.quiet) {
+      stdout.write(`[blueprint] superseded topic '${result.topic}' via ${result.resolvedByAdrId} at ${result.resolvedByAdrPath}.\n`);
+      stdout.write(`[blueprint] resolution recorded as ${result.resolutionId}; superseded: ${result.supersedes.map((s) => `${s.adrId} (blueprint ${s.slug})`).join(', ')}.\n`);
+      stdout.write(`[blueprint] edit ${result.resolvedByAdrPath} to fill out the operator's ruling context / decision / consequences.\n`);
+    }
+    return 0;
+  }
+
+  if (verb === 'diff') {
+    if (rest.length === 0) {
+      stderr.write('[error] blueprint diff: missing <topic>\n');
+      return 2;
+    }
+    const topic = rest[0];
+    const result = diffBlueprintTopic({ tree, topic });
+    stdout.write(renderDiff(result));
+    return 0;
+  }
+
+  stderr.write(`[error] blueprint: unknown verb '${verb}'\n`);
+  stderr.write(HELP);
+  return 2;
+}
+
+/**
+ * Parse `--resolve <topic>=project:<ADR-id>` occurrences into a list
+ * of declarations, attaching an optional shared `reason` (from the
+ * single `--reason` flag) to every declaration on this add. Returns
+ * `{ value: Array }` on success or `{ error: string }` on any
+ * mis-shaped input.
+ *
+ * The `--reason` flag is singular per invocation because a single
+ * add's resolutions typically share one operator justification
+ * (`--reason "Project auth model stands over both blueprint
+ * defaults."`); if per-topic reasons are needed later, the flag can
+ * grow a `--reason <topic>=<text>` shape without breaking this call
+ * shape.
+ */
+function parseResolveOptions(rawList, reason) {
+  if (!Array.isArray(rawList) || rawList.length === 0) return { value: [] };
+  const trimmedReason = typeof reason === 'string' ? reason : undefined;
+  const out = [];
+  for (const raw of rawList) {
+    if (typeof raw !== 'string' || raw.length === 0) {
+      return { error: `--resolve expects <topic>=project:<ADR-id>, got '${raw}'` };
+    }
+    const eq = raw.indexOf('=');
+    if (eq === -1) {
+      return { error: `--resolve expects <topic>=project:<ADR-id>, got '${raw}' (missing '=')` };
+    }
+    const topic = raw.slice(0, eq);
+    const rhs = raw.slice(eq + 1);
+    if (topic.length === 0) return { error: `--resolve expects a topic before '=', got '${raw}'` };
+    if (!rhs.startsWith('project:')) {
+      return { error: `--resolve rhs must start with 'project:' (that is the currently supported resolution target), got '${rhs}'` };
+    }
+    const adrId = rhs.slice('project:'.length);
+    if (adrId.length === 0) return { error: `--resolve resolvedByAdrId is empty for topic '${topic}'` };
+    const decl = { topic, resolvedByAdrId: adrId };
+    if (trimmedReason !== undefined) decl.reason = trimmedReason;
+    out.push(decl);
+  }
+  return { value: out };
+}

package/src/cli/create.js

@@ -207,6 +207,15 @@ export async function main(argv, deps = {}) {
       stderr.write('[error] usage create cn: --path is required\n');
       return 2;
     }
+    // Pre-validate the #symbol portion so the refusal names the rule and
+    // the fix (paper-cut batch): the CN symbol regex admits identifier
+    // characters only, so a dotted symbol like `#Store.put` fails the
+    // schema pattern with an opaque message. Catch it here and teach.
+    const symbolCheck = checkCnSymbolPath(body.path);
+    if (!symbolCheck.ok) {
+      stderr.write(`[error] usage create cn: ${symbolCheck.message}\n`);
+      return 2;
+    }
     // Phase 10 D5: --derive-deps assist. Optional, dev-time only, never a
     // runtime dependency - errors helpfully (exit 2) when the tool cannot
     // be resolved rather than silently degrading or reaching for the
@@ -261,7 +270,10 @@ export async function main(argv, deps = {}) {
       return 2;
     }
     body.acId = flags.ac;
-    options.slug = flags.slug ?? deriveSlug(body.description);
+    // 0.8.0 slug-train (w-2026-07-28-012 landmine 4): deriveSlug returns ''
+    // on empty derivation; TC keeps its historical 'tc' fallback locally
+    // rather than letting deriveSlug bake it in.
+    options.slug = flags.slug ?? (deriveSlug(body.description) || 'tc');
     options.testPointer = flags['test-pointer'];
   }
 
@@ -339,6 +351,42 @@ function isRcfError(value) {
     && ERROR_KINDS.has(value.kind) && typeof value.message === 'string';
 }
 
+/**
+ * Pre-flight the CN --path against the same identity rule the schema
+ * enforces (see cn.schema.json: `^[^#]+(#[A-Za-z_$][A-Za-z0-9_$]*)?$`).
+ * When the symbol part carries a dot (or any other non-identifier
+ * character), the schema-driven message reads as a bare pattern-mismatch
+ * and buries the fix. This surfaces it: name the rule, name the fix,
+ * point at the TC pointer as the right seat for method-level precision.
+ *
+ * @param {string} path - the --path argument
+ * @returns {{ ok: true } | { ok: false, message: string }}
+ */
+function checkCnSymbolPath(path) {
+  const hash = path.indexOf('#');
+  if (hash < 0) return { ok: true };
+  const symbol = path.slice(hash + 1);
+  if (symbol.length === 0) {
+    return {
+      ok: false,
+      message: `--path '${path}' has an empty #symbol suffix; drop the '#' to name the file only, or add an identifier after it (e.g. '#ClassName').`,
+    };
+  }
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(symbol)) return { ok: true };
+  // The pattern rejects anything that isn't a bare identifier. The dot
+  // case is by far the most common (people reach for `Class.method`), so
+  // call it out explicitly; other rejections fall through to the same
+  // teaching message.
+  const dotted = symbol.includes('.');
+  const hint = dotted
+    ? `dotted symbols (like '${symbol}') are not admitted: name the class or function alone (e.g. '#${symbol.split('.')[0]}') and record method-level precision on the TC test-pointer instead`
+    : `the symbol suffix admits identifier characters only (letters, digits, '_', '$'; a leading digit is not allowed)`;
+  return {
+    ok: false,
+    message: `--path '${path}' has an invalid #symbol '${symbol}': ${hint}.`,
+  };
+}
+
 function handleWriterError(err, stderr) {
   const kind = err.kind;
   // BUG-007 fix: spec §D15 mandates exit-1 emit

package/src/cli/help.js

@@ -41,6 +41,9 @@ import { HELP as INTAKE_HELP } from './intake.js';
 // 0.7.1 packaging consolidation: `rcf verify <verb>` routes to the same
 // help block the transition-grace `rcf-verify` alias bin uses.
 import { TOP_LEVEL_HELP as VERIFY_HELP } from '../verify/cli/help.js';
+// Blueprint mechanism (Phase 1, w-2026-08-18-016).
+import { HELP as BLUEPRINT_HELP } from './blueprint.js';
+import { HELP as STANDARDS_HELP } from './standards.js';
 
 const TOP_LEVEL = `Usage: rcf <command> [options]
 
@@ -74,6 +77,8 @@ Commands:
   req-baseline <verb> Baseline-AC sweep and opt-out ledger for classified REQs
   intake              Variable-fidelity intake stage (classify supplied artefacts)
   verify <verb>       Adversarial ship gate (run|report|provision|cleanup|mcp); the legacy rcf-verify bin is a transition alias
+  blueprint <verb>    Compose blueprints onto the project (add | list | remove)
+  standards <verb>    Register standards packs against the project (add | list)
   help [command]      Print help for a command
 
 Options:
@@ -124,6 +129,9 @@ const HELP_MAP = {
   intake: INTAKE_HELP,
   // 0.7.1 packaging consolidation: verify subcommand tree.
   verify: VERIFY_HELP,
+  // Blueprint mechanism (Phase 1, w-2026-08-18-016).
+  blueprint: BLUEPRINT_HELP,
+  standards: STANDARDS_HELP,
 };
 
 /**

package/src/cli/init.js

@@ -22,7 +22,7 @@ import { parseArgs } from 'node:util';
 import { createInterface } from 'node:readline/promises';
 
 import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 
 import { initProject } from '#core/store/init.js';
 import {
@@ -61,7 +61,11 @@ to elicit. Re-running on an existing project leaves the tree alone and
 refreshes the wiring.
 
 Options:
-  --project-name <name>     Project name (required for --non-interactive)
+  --project-name <name>     Project name. In non-interactive mode this
+                            defaults to the working directory's basename
+                            (pass explicitly to override); an unusable
+                            basename (empty, '.', or '/') still requires
+                            the flag.
   --non-interactive         Skip prompts; use seed values (default when
                             not on a TTY or when piped)
   --no-agent-setup          Scaffold the tree only; print the manual
@@ -115,10 +119,21 @@ export async function main(argv, deps = {}) {
       rl.close();
     }
   } else {
+    // Non-interactive: --project-name defaults to the working
+    // directory's basename. An unusable basename (empty, '.', or '/')
+    // still requires the flag - no silent fallback to a generic name.
     if (!projectName) {
-      stderr.write('[error] usage --project-name is required in non-interactive mode\n');
-      stderr.write(HELP);
-      return 2;
+      const candidate = basename(cwd).trim();
+      if (candidate && candidate !== '.' && candidate !== '/') {
+        projectName = candidate;
+      } else {
+        stderr.write(
+          `[error] usage --project-name is required in non-interactive mode `
+          + `(cwd basename '${candidate}' is unusable as a default)\n`,
+        );
+        stderr.write(HELP);
+        return 2;
+      }
     }
   }
 

package/src/cli/read.js

@@ -119,7 +119,13 @@ function resolveTarget(tree, id) {
     const entry = (us.acceptanceCriteria ?? []).find((ac) => ac.id === id);
     return entry ? { doc: entry, containerId: parentId, invalid: false } : null;
   }
-  if (/^TC-\d{3}-[a-z0-9-]+$/.test(id)) {
+  // 0.8.0 slug-train (w-2026-07-28-012 landmine 3, consumer-path
+  // straggler): widened `\d{3}` -> `\d{3,}` in lockstep with rcf-schemas
+  // 0.4.3's TC pattern. Under the previous shape `rcf read TC-1000-x`
+  // fell through to the `return null` below (silent skip) even when the
+  // TC existed under a widened TS -- exactly the class the landmine
+  // charter names.
+  if (/^TC-\d{3,}-[a-z0-9-]+$/.test(id)) {
     const parentId = tree.parentByChild.get(id);
     if (!parentId) return null;
     const ts = tree.byId.get(parentId);

package/src/cli/standards.js

@@ -0,0 +1,127 @@
+// `rcf standards <verb>` — Phase 1 landing (add | list).
+
+import { parseArgs } from 'node:util';
+
+import { isRcfError } from '#core/errors';
+import { walkTree } from '#core/store';
+import { findProjectRoot } from '../view/index.js';
+import { listStandards, registerStandardsPack } from '../blueprint/index.js';
+
+export const HELP = `Usage: rcf standards <verb> [options]
+
+Verbs:
+  add <source>           Register a standards pack against the project.
+                         Reference-by-default: if <source> lives inside
+                         the project root, the pack is referenced in place
+                         and no copy is written. If <source> lives OUTSIDE
+                         the project root, the pack is copied into
+                         rcf/standards/<slug>/ so the tree stays portable.
+  list                   List every registered standards pack.
+
+Options (for add):
+  --slug <slug>              Required. Kebab slug for this pack.
+  --tags <t1,t2,...>         Required. Comma-separated tag vocabulary.
+  --summary <string>         Optional short summary read by the selective-
+                             retrieval step alongside the tags.
+  --tests-provided-by <val>  Required. One of: standard | agent | none.
+  --provenance <val>         Required. One of: personal | corporate.
+  --dry-run                  Print intended writes without executing.
+  --quiet                    Suppress non-error stdout.
+  --help                     Print this help.
+`;
+
+const OPTION_SPEC = {
+  slug: { type: 'string' },
+  tags: { type: 'string' },
+  summary: { type: 'string' },
+  'tests-provided-by': { type: 'string' },
+  provenance: { type: 'string' },
+  'dry-run': { type: 'boolean' },
+  quiet: { type: 'boolean' },
+  help: { type: 'boolean' },
+};
+
+/**
+ * @param {string[]} argv
+ * @param {object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function main(argv, deps = {}) {
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  const cwd = deps.cwd ?? process.cwd();
+
+  let parsed;
+  try {
+    parsed = parseArgs({ args: argv, options: OPTION_SPEC, allowPositionals: true, strict: true });
+  } catch (err) {
+    stderr.write(`[error] ${err.message}\n`);
+    stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.values.help || parsed.positionals.length === 0) {
+    stdout.write(HELP);
+    return 0;
+  }
+  const verb = parsed.positionals[0];
+  const rest = parsed.positionals.slice(1);
+
+  const projectRoot = await findProjectRoot(cwd);
+  if (!projectRoot) {
+    stderr.write('[error] no rcf/ tree found in this directory or any ancestor.\n');
+    return 2;
+  }
+  const { tree, errors } = await walkTree({ projectRoot });
+  if (errors.length > 0 && verb !== 'list') {
+    for (const e of errors) stderr.write(`[tree] ${e.kind}: ${e.message}\n`);
+    return 2;
+  }
+
+  if (verb === 'add') {
+    if (rest.length === 0) {
+      stderr.write('[error] standards add: missing <source>\n');
+      return 2;
+    }
+    if (!parsed.values.slug || !parsed.values.tags || !parsed.values['tests-provided-by'] || !parsed.values.provenance) {
+      stderr.write('[error] standards add: --slug, --tags, --tests-provided-by and --provenance are required\n');
+      return 2;
+    }
+    const result = await registerStandardsPack({
+      projectRoot, tree,
+      sourcePath: rest[0],
+      slug: parsed.values.slug,
+      tags: parsed.values.tags.split(',').map((t) => t.trim()).filter(Boolean),
+      summary: parsed.values.summary,
+      testsProvidedBy: parsed.values['tests-provided-by'],
+      provenance: parsed.values.provenance,
+      dryRun: parsed.values['dry-run'] === true,
+    });
+    if (isRcfError(result)) {
+      stderr.write(`[error] standards add: ${result.message}\n`);
+      return 2;
+    }
+    if (!parsed.values.quiet) {
+      const shape = result.copyPath ? `copied to ${result.copyPath}` : `referenced in place at ${result.entry.sourcePath}`;
+      const state = result.alreadyRegistered ? 'already registered (no change)' : 'registered';
+      stdout.write(`[standards] '${result.entry.slug}' ${state} (${shape}).\n`);
+    }
+    return 0;
+  }
+
+  if (verb === 'list') {
+    const rows = listStandards(tree);
+    if (rows.length === 0) {
+      if (!parsed.values.quiet) stdout.write('[standards] no standards packs registered on this project.\n');
+      return 0;
+    }
+    for (const row of rows) {
+      const shape = row.copyPath ? 'copied' : 'referenced';
+      stdout.write(`${row.slug}\t${row.testsProvidedBy}\t${row.provenance}\t${shape}\t${(row.tags ?? []).join(',')}\n`);
+    }
+    return 0;
+  }
+
+  stderr.write(`[error] standards: unknown verb '${verb}'\n`);
+  stderr.write(HELP);
+  return 2;
+}

package/src/cli/test-suite.js

@@ -82,8 +82,13 @@ export async function main(argv, deps = {}) {
     stderr.write('[error] usage test-suite: verb required (provenance | approve)\n');
     return 2;
   }
-  if (!/^TS-\d{3}$/.test(tsId)) {
-    stderr.write(`[error] usage test-suite: expected a TS id like TS-015, got '${tsId}'\n`);
+  // 0.8.0 slug-train (w-2026-07-28-012 landmine 3, consumer-path
+  // straggler): widened `\d{3}` -> `\d{3,}` in lockstep with rcf-schemas
+  // 0.4.3's TS pattern. The previous shape hard-refused any TS >= 1000 --
+  // silent from the operator's perspective (the tsId matched the schema
+  // but the CLI verb refused with a usage error citing "TS-015").
+  if (!/^TS-\d{3,}$/.test(tsId)) {
+    stderr.write(`[error] usage test-suite: expected a TS id like TS-015 or TS-1000, got '${tsId}'\n`);
     return 2;
   }