renma 0.15.0 → 0.15.1

package/CHANGELOG.md

@@ -6,6 +6,18 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [0.15.1] - 2026-07-10
+
+### Added
+
+- Added command-specific CLI help for every command, including purpose, use cases, boundaries, examples, next steps, and relevant options for human and coding-agent workflows.
+
+### Changed
+
+- Expanded top-level CLI help with Renma's deterministic governance boundaries, start-here workflows, and command-selection questions.
+- Clarified command-specific option help with accepted output formats, defaults, owner behavior, scaffold output modes, and BOM timestamp/path boundaries.
+- Improved CLI usage errors to point to the relevant command help page where applicable.
+
 ## [0.15.0] - 2026-07-09
 
 ### Added
@@ -267,7 +279,8 @@ Tag-only release. No GitHub Release entry was published for this version.
 - Added metadata governance, advisory diagnostics, local path checks, and semantic split suggestions.
 - Added the initial project documentation, architecture notes, package metadata, tests, and license.
 
-[Unreleased]: https://github.com/KazuCocoa/renma/compare/v0.15.0...HEAD
+[Unreleased]: https://github.com/KazuCocoa/renma/compare/v0.15.1...HEAD
+[0.15.1]: https://github.com/KazuCocoa/renma/compare/v0.15.0...v0.15.1
 [0.15.0]: https://github.com/KazuCocoa/renma/compare/v0.14.1...v0.15.0
 [0.14.1]: https://github.com/KazuCocoa/renma/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/KazuCocoa/renma/compare/v0.13.2...v0.14.0

package/README.md

@@ -264,7 +264,7 @@ npx renma diff . --from main --to HEAD --format markdown
 
 The first command does not require you to design a knowledge architecture up front. It scans the repository, builds a local catalog, and reports obvious health issues such as broken links, unclear ownership, risky instructions, weak structure, and context that may be hard for agents to trust.
 
-For guided workflows, see the User Manual sections on [creating a new skill with scaffold](docs/user-manual.md#user-story-create-a-new-skill-with-scaffold) and [improving existing skills with diagnostics](docs/user-manual.md#user-story-improve-existing-skills-with-diagnostics).
+Command-specific help is designed for both humans and coding agents: start with `renma --help`, then run `renma <command> --help` before choosing a workflow. For guided workflows, see the User Manual sections on [LLM-assisted skill maintenance](docs/user-manual.md#llm-assisted-skill-maintenance), [creating a new skill with scaffold](docs/user-manual.md#user-story-create-a-new-skill-with-scaffold), and [improving existing skills with diagnostics](docs/user-manual.md#user-story-improve-existing-skills-with-diagnostics).
 
 If you are developing Renma from source:
 

package/dist/cli-help.d.ts

@@ -0,0 +1,293 @@
+export interface CommandHelp {
+    name: string;
+    usage: string;
+    question: string;
+    purpose: string;
+    useWhen: readonly string[];
+    doNotUseFor: readonly string[];
+    examples: readonly string[];
+    interpretation: readonly string[];
+    nextSteps: readonly string[];
+    options: readonly CommandOptionHelp[];
+}
+export type CommandOptionHelp = CliOptionName | {
+    name: CliOptionName;
+    description?: string;
+};
+declare const OPTION_HELP: {
+    readonly config: {
+        readonly flags: "-c, --config <path>";
+        readonly description: "Read Renma JSON config from path.";
+    };
+    readonly "fail-on": {
+        readonly flags: "--fail-on <level>";
+        readonly description: "Exit 1 when scan findings meet severity: low, medium, high, or critical.";
+    };
+    readonly focus: {
+        readonly flags: "--focus <asset-id-or-path>";
+        readonly description: "Keep one matched asset and its one-hop graph neighborhood.";
+    };
+    readonly format: {
+        readonly flags: "--format <format>";
+        readonly description: "Output format for commands that accept --format.";
+    };
+    readonly from: {
+        readonly flags: "--from <ref>";
+        readonly description: "Git ref to use as the comparison baseline.";
+    };
+    readonly help: {
+        readonly flags: "-h, --help";
+        readonly description: "Show this help page without running the command.";
+    };
+    readonly "include-owned": {
+        readonly flags: "--include-owned";
+        readonly description: "Include flat owned asset details in ownership output.";
+    };
+    readonly id: {
+        readonly flags: "--id <id>";
+        readonly description: "Set the scaffolded asset ID instead of deriving one.";
+    };
+    readonly json: {
+        readonly flags: "--json";
+        readonly description: "Shortcut for --format json where JSON is supported.";
+    };
+    readonly lines: {
+        readonly flags: "--lines <range>";
+        readonly description: "Print an exact line range such as L10-L42 or 10-42.";
+    };
+    readonly "max-context-bytes": {
+        readonly flags: "--max-context-bytes <n>";
+        readonly description: "Limit nearby context bytes for semantic split suggestions.";
+    };
+    readonly "max-source-bytes": {
+        readonly flags: "--max-source-bytes <n>";
+        readonly description: "Limit source file bytes for semantic split suggestions.";
+    };
+    readonly "omit-generated-at": {
+        readonly flags: "--omit-generated-at";
+        readonly description: "Omit the BOM run-time generatedAt timestamp.";
+    };
+    readonly owner: {
+        readonly flags: "--owner <owner>";
+        readonly description: "Owner value for commands that accept --owner.";
+    };
+    readonly tags: {
+        readonly flags: "--tags <tags>";
+        readonly description: "Set comma-separated or repeated scaffold tags.";
+    };
+    readonly title: {
+        readonly flags: "--title <title>";
+        readonly description: "Set scaffold title metadata.";
+    };
+    readonly to: {
+        readonly flags: "--to <ref>";
+        readonly description: "Git ref to use as the comparison target.";
+    };
+    readonly version: {
+        readonly flags: "-v, --version";
+        readonly description: "Print the Renma package version.";
+    };
+    readonly view: {
+        readonly flags: "--view <view>";
+        readonly description: "Graph view: summary, workflow, full, layered, or lens.";
+    };
+};
+export type CliOptionName = keyof typeof OPTION_HELP;
+export declare const COMMAND_HELP: readonly [{
+    readonly name: "scan";
+    readonly usage: "renma scan [path] [options]";
+    readonly question: "What concrete problems should be fixed?";
+    readonly purpose: "Scan is usually the first command when improving existing skills or context assets. It reports concrete findings and deterministic diagnostics without editing files.";
+    readonly useWhen: readonly ["You need the first actionable view of repository problems.", "You are preparing or verifying a patch for skills, contexts, prompts, or agent-facing docs.", "A downstream tool or coding agent needs JSON guidance, repair constraints, and verification steps."];
+    readonly doNotUseFor: readonly ["Automatically rewriting files or applying fixes.", "An agent inventing owners, references, source-of-truth documents, or product rules.", "Selecting runtime context for an LLM or assembling task prompts."];
+    readonly examples: readonly ["renma scan .", "renma scan . --format json", "renma scan . --fail-on high"];
+    readonly interpretation: readonly ["Text output is a human-readable finding list.", "JSON output includes structured diagnostics, review bundles, and guidance intended for downstream tools and coding agents.", "When repair constraints or verification steps are present, follow them instead of broadening the edit."];
+    readonly nextSteps: readonly ["Inspect evidence before editing.", "Prepare a minimal reviewable patch that preserves supported semantics.", "Rerun scan and any relevant structural commands after editing."];
+    readonly options: readonly ["config", "fail-on", {
+        readonly name: "format";
+        readonly description: "Output format: text or json. Defaults to text.";
+    }, "json", "help"];
+}, {
+    readonly name: "catalog";
+    readonly usage: "renma catalog [path] [options]";
+    readonly question: "What assets and metadata exist?";
+    readonly purpose: "Catalog inventories discovered assets and normalized metadata so reviewers can see the repository evidence Renma found.";
+    readonly useWhen: readonly ["You need IDs, kinds, owners, lifecycle states, hashes, tags, declared dependencies, or context relationships.", "You want inventory evidence before changing metadata or references.", "You need stable JSON or Markdown asset inventory for review."];
+    readonly doNotUseFor: readonly ["Treating inventory as a problem list by itself.", "Deciding what context an agent should consume at runtime.", "Proving that a declared dependency is semantically correct."];
+    readonly examples: readonly ["renma catalog . --format markdown", "renma catalog . --format json"];
+    readonly interpretation: readonly ["Catalog output is deterministic inventory evidence.", "Missing, duplicate, or unresolved metadata may appear as diagnostics, but catalog is not a substitute for scan.", "Dependencies are declared relationships discovered from repository metadata and references."];
+    readonly nextSteps: readonly ["Run graph to inspect relationships.", "Run readiness for repository-level summary.", "Run scan for concrete findings to fix."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "help"];
+}, {
+    readonly name: "graph";
+    readonly usage: "renma graph [path] [options]";
+    readonly question: "How are assets structurally connected?";
+    readonly purpose: "Graph shows declared structural relationships between assets, including focused views around one asset.";
+    readonly useWhen: readonly ["You need to inspect dependencies, references, unresolved targets, or isolation.", "You want a one-hop neighborhood with --focus for one asset ID or path.", "You need Markdown, JSON, or Mermaid evidence for review."];
+    readonly doNotUseFor: readonly ["It does not select context for an LLM.", "It does not prove that a dependency is semantically correct.", "Deleting isolated assets without human review."];
+    readonly examples: readonly ["renma graph . --format markdown", "renma graph . --view layered --format mermaid", "renma graph . --focus contexts/testing/boundary-value-analysis.md --view full"];
+    readonly interpretation: readonly ["Edges represent declared relationships Renma can resolve or report as unresolved.", "Unexpected isolation is evidence to review, not automatic permission to delete an asset.", "Focused output filters to the matched asset and directly connected neighbors."];
+    readonly nextSteps: readonly ["Use catalog to inspect the assets behind graph nodes.", "Use scan to fix concrete relationship findings.", "Rerun graph after metadata or reference changes."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json, markdown, or mermaid. Defaults to json. JSON defaults to the full view; non-JSON formats default to the summary view.";
+    }, "json", "view", "focus", "help"];
+}, {
+    readonly name: "trust-graph";
+    readonly usage: "renma trust-graph [path] [options]";
+    readonly question: "What trust-relevant evidence is connected to each asset?";
+    readonly purpose: "Trust graph connects deterministic evidence such as ownership, lifecycle, policy, references, dependencies, and diagnostics.";
+    readonly useWhen: readonly ["A reviewer or downstream tool needs traceable trust-relevant evidence per asset.", "You need to connect owners, lifecycle status, effective policy fingerprints, dependencies, and diagnostics.", "You want a stable evidence layer for human review."];
+    readonly doNotUseFor: readonly ["It is not a subjective trust score.", "It does not certify that an asset is trustworthy.", "Runtime policy enforcement, prompt assembly, or telemetry."];
+    readonly examples: readonly ["renma trust-graph . --format markdown", "renma trust-graph . --format json"];
+    readonly interpretation: readonly ["The report connects evidence; it does not decide trust for you.", "Missing owner, lifecycle, policy, or diagnostic evidence should be reviewed in context.", "JSON is the source of truth for downstream tooling; Markdown is for human review."];
+    readonly nextSteps: readonly ["Use scan for concrete diagnostics.", "Use ownership when owner coverage needs deeper review.", "Use readiness for repository-level summary."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "help"];
+}, {
+    readonly name: "readiness";
+    readonly usage: "renma readiness [path] [options]";
+    readonly question: "Is the repository broadly prepared for agent-facing use?";
+    readonly purpose: "Readiness provides a repository-level scorecard and health summary derived from deterministic repository evidence.";
+    readonly useWhen: readonly ["You need a broad maintainer or CI summary after scan, catalog, or graph review.", "You want repository-level checks for ownership, graph resolution, lifecycle, context lens governance, and selected findings.", "You need Markdown for review or JSON for automation."];
+    readonly doNotUseFor: readonly ["Replacing scan when you need concrete findings.", "Deciding whether an agent should consume a particular context asset at runtime.", "Claiming what an LLM actually used."];
+    readonly examples: readonly ["renma readiness . --format markdown", "renma readiness . --format json"];
+    readonly interpretation: readonly ["Scan gives concrete findings; readiness gives a broad repository summary.", "Readiness scores and checks are static repository review signals.", "Security posture and context lens summaries remain deterministic evidence, not runtime decisions."];
+    readonly nextSteps: readonly ["Use scan to fix specific findings behind readiness failures.", "Use catalog and graph to inspect inventory or relationship causes.", "Rerun readiness after the patch."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "help"];
+}, {
+    readonly name: "bom";
+    readonly usage: "renma bom [path] [options]";
+    readonly question: "What declared repository context manifest should be reviewed?";
+    readonly purpose: "BOM prints a declared repository evidence snapshot combining catalog, graph, lifecycle, hashes, diagnostics, readiness, and security posture evidence.";
+    readonly useWhen: readonly ["Reviewers or CI consumers need one manifest of declared repository context evidence.", "You need a PR artifact that combines inventory, dependencies, diagnostics, readiness, lifecycle, hashes, and security posture.", "You need structured JSON generated from deterministic repository evidence or compact Markdown for review."];
+    readonly doNotUseFor: readonly ["Reporting what an LLM actually consumed.", "It is not telemetry, prompt assembly, runtime context selection, or agent execution.", "Normalizing every repository or environment-dependent metadata value."];
+    readonly examples: readonly ["renma bom . --format json", "renma bom . --format markdown", "renma bom . --format json --omit-generated-at"];
+    readonly interpretation: readonly ["The BOM is a declared repository manifest, not a runtime usage report or telemetry.", "--omit-generated-at only removes the run-time generation timestamp.", "The option does not normalize repository metadata timestamps such as lastReviewedAt or expiresAt, and it does not normalize all environment-dependent paths such as root or configPath."];
+    readonly nextSteps: readonly ["Review diagnostics and readiness sections before merging.", "Use scan, catalog, or graph for focused follow-up.", "Store JSON when automation needs the source of truth."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "omit-generated-at", "help"];
+}, {
+    readonly name: "ownership";
+    readonly usage: "renma ownership [path] [options]";
+    readonly question: "Where is ownership missing or concentrated?";
+    readonly purpose: "Ownership helps review owner coverage, unowned assets, and concentration by declared owner.";
+    readonly useWhen: readonly ["You need to find assets without owner metadata.", "You want to review what one owner is responsible for.", "You need ownership coverage evidence for governance review."];
+    readonly doNotUseFor: readonly ["Renma should not invent or assign an owner from paths, prose, Git history, or guesses.", "Replacing human or source-of-truth confirmation for missing ownership.", "Treating unowned assets as automatic failures in every repository."];
+    readonly examples: readonly ["renma ownership . --format markdown", "renma ownership . --include-owned", "renma ownership . --owner qa-platform --format json"];
+    readonly interpretation: readonly ["Ownership output reports declared owner metadata and coverage.", "Missing ownership normally requires confirmation from a human or an existing source of truth.", "Owner filters keep repository-level totals while adding owner-specific details."];
+    readonly nextSteps: readonly ["Confirm missing owners before editing metadata.", "Use suggest-metadata when preparing a metadata-only retrofit.", "Rerun ownership and scan after ownership changes."];
+    readonly options: readonly ["config", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "include-owned", {
+        readonly name: "owner";
+        readonly description: "Show owner-specific declared asset details while preserving repository-level coverage totals.";
+    }, "help"];
+}, {
+    readonly name: "diff";
+    readonly usage: "renma diff [path] --from <ref> --to <ref> [options]";
+    readonly question: "What deterministic readiness evidence changed between refs?";
+    readonly purpose: "Diff compares deterministic repository evidence between Git refs for context and skill review.";
+    readonly useWhen: readonly ["You need to review readiness, asset, graph, check, or finding changes before merging.", "A pull request changes skills, contexts, metadata, or agent-facing docs.", "You want JSON or Markdown evidence over repository governance changes."];
+    readonly doNotUseFor: readonly ["A generic source-code diff.", "Determining what an LLM consumed at runtime.", "Replacing human review of semantic changes."];
+    readonly examples: readonly ["renma diff . --from main --to HEAD", "renma diff . --from origin/main --to HEAD --format markdown"];
+    readonly interpretation: readonly ["The report compares Renma evidence generated at two refs.", "Added or removed findings show deterministic review signal changes, not arbitrary source hunks.", "Usage errors exit 2; generated comparison output follows command status rules."];
+    readonly nextSteps: readonly ["Use ci-report when a PR-oriented summary is needed.", "Use scan or graph on the working tree to investigate changed evidence.", "Summarize changed evidence and remaining uncertainty for reviewers."];
+    readonly options: readonly ["config", "from", "to", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to json.";
+    }, "json", "help"];
+}, {
+    readonly name: "ci-report";
+    readonly usage: "renma ci-report [path] --from <ref> --to <ref> [options]";
+    readonly question: "What should a CI or PR reviewer inspect?";
+    readonly purpose: "CI report produces a pull-request-oriented summary from deterministic Renma evidence.";
+    readonly useWhen: readonly ["CI needs a PASS, WARN, or FAIL status with review-focused details.", "A PR reviewer needs readiness, graph, and finding changes summarized.", "You want Markdown for a PR comment or JSON for automation."];
+    readonly doNotUseFor: readonly ["Replacing human review.", "A full generic code diff.", "Certifying that all semantic changes are correct."];
+    readonly examples: readonly ["renma ci-report . --from main --to HEAD --format markdown", "renma ci-report . --from origin/main --to HEAD --format json"];
+    readonly interpretation: readonly ["The report combines deterministic evidence for review.", "PASS and WARN exit 0; FAIL exits 1; usage errors exit 2.", "Reviewers should still inspect meaningful semantic changes."];
+    readonly nextSteps: readonly ["Fix or explain new failures and warnings.", "Use diff for the underlying evidence comparison.", "Rerun ci-report after updating the branch."];
+    readonly options: readonly ["config", "from", "to", {
+        readonly name: "format";
+        readonly description: "Output format: json or markdown. Defaults to markdown.";
+    }, "json", "help"];
+}, {
+    readonly name: "inspect";
+    readonly usage: "renma inspect <file> [options]";
+    readonly question: "What is the outline or exact line slice of one file?";
+    readonly purpose: "Inspect provides a compact outline or exact line slice of a single file.";
+    readonly useWhen: readonly ["You need to inspect one asset before editing without reading the whole repository.", "A coding agent needs a deterministic outline or exact line range.", "You want Context Lens or relationship hints for one file when repository context can be inferred."];
+    readonly doNotUseFor: readonly ["Selecting runtime context for an LLM.", "Assembling prompts for task execution.", "Replacing scan, catalog, or graph for repository-wide evidence."];
+    readonly examples: readonly ["renma inspect skills/testing/spec-review/SKILL.md", "renma inspect skills/testing/spec-review/SKILL.md --lines L10-L42", "renma inspect contexts/testing/boundary-value-analysis.md --format json"];
+    readonly interpretation: readonly ["Without --lines, output is a structured outline of one file.", "With --lines, output is an exact source slice.", "Inspect is an inspection helper, not a runtime context selector or prompt assembler."];
+    readonly nextSteps: readonly ["Use scan for concrete findings before or after edits.", "Use catalog or graph if one-file inspection reveals relationship questions.", "Cite exact lines when summarizing edits for review."];
+    readonly options: readonly [{
+        readonly name: "format";
+        readonly description: "Output format: text or json. Defaults to json.";
+    }, "json", "lines", "help"];
+}, {
+    readonly name: "scaffold";
+    readonly usage: "renma scaffold <skill|context|context_lens> <path> [options]";
+    readonly question: "How can a new asset start from a deterministic structure?";
+    readonly purpose: "Scaffold creates deterministic starter structures or authoring prompts for new Renma assets.";
+    readonly useWhen: readonly ["You are creating a new skill, context asset, or context lens.", "You want a starter file or prompt with expected metadata and sections.", "You need a deterministic starting point before authoring content."];
+    readonly doNotUseFor: readonly ["Generating a complete production-ready skill or context.", "Inventing domain knowledge merely to fill the template.", "Replacing author-provided purpose, routing boundaries, inputs, completion criteria, verification, or references."];
+    readonly examples: readonly ["renma scaffold skill skills/testing/spec-review/SKILL.md --owner qa-platform", "renma scaffold context contexts/testing/boundary-value-analysis.md --owner qa-platform", "renma scaffold context_lens lenses/testing/spec-review-boundary-values.md --owner qa-platform", "renma scaffold skill skills/testing/spec-review/SKILL.md --owner qa-platform --format prompt"];
+    readonly interpretation: readonly ["File mode creates the scaffold file at the target path and refuses to overwrite existing files.", "Prompt and JSON modes print to stdout instead of creating the scaffold file.", "Generated scaffold content is a starting structure, not a complete asset.", "The author must still provide purpose, routing boundaries, inputs, completion criteria, verification, and references.", "Domain knowledge must come from evidence or human input."];
+    readonly nextSteps: readonly ["Edit the generated content with evidence-backed details.", "Run scan, catalog, graph, and readiness after editing.", "Have a human review meaningful semantic content before merging."];
+    readonly options: readonly [{
+        readonly name: "format";
+        readonly description: "Output format: file, prompt, or json. Defaults to file. File mode writes the scaffold to the target path and requires --owner. Prompt and JSON modes print to stdout instead of creating the target file.";
+    }, {
+        readonly name: "owner";
+        readonly description: "Set owner metadata on the scaffold. Required when --format file is used.";
+    }, "id", "title", "tags", "help"];
+}, {
+    readonly name: "suggest-metadata";
+    readonly usage: "renma suggest-metadata <file> [options]";
+    readonly question: "How can a coding agent prepare a metadata-only retrofit?";
+    readonly purpose: "Suggest metadata emits a prompt or structured suggestion for a metadata-focused retrofit of one existing asset.";
+    readonly useWhen: readonly ["An asset lacks compact metadata and you want a reviewable metadata patch.", "You need guidance that preserves the existing Markdown body and semantics.", "A human explicitly provides an owner with --owner or the asset already declares one."];
+    readonly doNotUseFor: readonly ["Editing the file automatically.", "Changing the Markdown body or asset semantics unless explicitly requested.", "Inferring an owner without evidence."];
+    readonly examples: readonly ["renma suggest-metadata skills/testing/spec-review/SKILL.md --format prompt", "renma suggest-metadata skills/testing/spec-review/SKILL.md --owner qa-platform --format json"];
+    readonly interpretation: readonly ["The command prints to stdout and does not edit the target file.", "Without --owner, do not add owner metadata unless the asset already declares one or a maintainer confirms it.", "Preserve existing Markdown body and semantics for a metadata-only retrofit."];
+    readonly nextSteps: readonly ["Apply only evidence-backed metadata changes in a reviewable patch.", "Run scan and ownership after editing.", "Report any missing owner, reference, or source-of-truth uncertainty."];
+    readonly options: readonly [{
+        readonly name: "format";
+        readonly description: "Output format: prompt or json. Defaults to prompt. The command prints to stdout and does not edit the target file.";
+    }, "json", {
+        readonly name: "owner";
+        readonly description: "Explicitly provide an owner candidate. Renma must not infer an owner when this option is absent.";
+    }, "help"];
+}, {
+    readonly name: "suggest-semantic-split";
+    readonly usage: "renma suggest-semantic-split <file> [options]";
+    readonly question: "How can a coding agent prepare a reviewable semantic split?";
+    readonly purpose: "Suggest semantic split packages bounded source material and instructions for drafting a semantic split.";
+    readonly useWhen: readonly ["A Markdown asset is too large or mixes multiple responsibilities.", "A coding agent needs bounded source context and deterministic helper commands.", "You want a prompt or JSON review bundle before proposing a split."];
+    readonly doNotUseFor: readonly ["Editing files automatically.", "Splitting merely to satisfy a size metric when boundaries are not semantically meaningful.", "Dropping meaning, references, metadata, or review context."];
+    readonly examples: readonly ["renma suggest-semantic-split docs/large-runbook.md", "renma suggest-semantic-split docs/large-runbook.md --format json", "renma suggest-semantic-split docs/large-runbook.md --max-source-bytes 32768"];
+    readonly interpretation: readonly ["The command prints to stdout and does not edit files.", "A split must preserve meaning and references.", "The resulting patch requires review."];
+    readonly nextSteps: readonly ["Draft bounded files only when the proposed boundaries are meaningful.", "Preserve references and summarize uncertainty.", "Run scan, catalog, graph, and readiness after editing."];
+    readonly options: readonly [{
+        readonly name: "format";
+        readonly description: "Output format: prompt or json. Defaults to prompt. The command prints to stdout and does not edit files.";
+    }, "json", "max-source-bytes", "max-context-bytes", "help"];
+}];
+export type CommandName = (typeof COMMAND_HELP)[number]["name"];
+export declare function isCommandName(value: string): value is CommandName;
+export declare function renderGlobalHelp(version: string): string;
+export declare function renderCommandHelp(name: CommandName, version: string): string;
+export {};
+//# sourceMappingURL=cli-help.d.ts.map

package/dist/cli-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-help.d.ts","sourceRoot":"","sources":["../src/cli-help.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvC;AAED,MAAM,MAAM,iBAAiB,GACzB,aAAa,GACb;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EP,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,WAAW,CAAC;AAErD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgjBkB,CAAC;AAE5C,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAMhE,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,WAAW,CAEjE;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA6CxD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAyC5E"}