@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/zig/IEvidenceZigDocumentationAttachment.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Associates parsed Zig documentation with one declaration site.
+ *
+ * The adapter stores this relation beside documentation mappings so semantic
+ * assembly can preserve the original comment attachment.
+ */
+export interface IEvidenceZigDocumentationAttachment {
+    /**
+     * Identifies the declaration that owns the documentation mapping.
+     *
+     * Consumers use the extraction identity before assigning documentation to a
+     * semantic unit.
+     */
+    declarationId: string;
+    /**
+     * Identifies the physical declaration site that receives the comment.
+     *
+     * This keeps attachment precise when one semantic unit has several sites.
+     */
+    siteId: string;
+}

package/lib/adapters/zig/IEvidenceZigFileAnalysis.d.ts

@@ -0,0 +1,51 @@
+import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IEvidenceZigDeclaration } from "./IEvidenceZigDeclaration";
+import type { IEvidenceZigDocumentation } from "./IEvidenceZigDocumentation";
+/**
+ * Holds the node-free Zig extraction retained after a parse session closes.
+ *
+ * Alias reconciliation works from this serializable record after the parser is
+ * closed, retaining the physical sites that support each exported address.
+ */
+export interface IEvidenceZigFileAnalysis {
+    /**
+     * Retains the selected source snapshot that produced this extraction.
+     *
+     * Its physical path and public addresses anchor all later diagnostics, sites,
+     * and public-address materialization for this file.
+     */
+    source: IEvidenceSourceFile;
+    /**
+     * Lists declarations extracted from the file, including non-public
+     * boundaries.
+     *
+     * Alias reconciliation filters public records for publication while retaining
+     * source-level ownership information needed to interpret their
+     * relationships.
+     */
+    declarations: IEvidenceZigDeclaration[];
+    /**
+     * Holds classified documentation and unsupported annotation carriers.
+     *
+     * The adapter parses these records after public units are known so tags
+     * cannot attach to a declaration that never reaches the selected public
+     * surface.
+     */
+    documentation: IEvidenceZigDocumentation[];
+    /**
+     * Records failures encountered while establishing the public surface.
+     *
+     * These diagnostics reach the final inventory to prevent unsupported source
+     * forms from reducing the coverage population without a reported failure.
+     */
+    diagnostics: IEvidenceDiagnostic[];
+    /**
+     * States whether scanning classified every surface-affecting Zig form.
+     *
+     * The inventory treats false as a failed boundary, preserving uncertainty
+     * rather than allowing an unclassified alias to reduce the public
+     * population.
+     */
+    complete: boolean;
+}

package/lib/commands/EvidenceCommand.d.ts

@@ -2,34 +2,35 @@ import type { IEvidenceCommand } from "../structures/IEvidenceCommand";
 import type { IEvidenceCommandResult } from "../structures/IEvidenceCommandResult";
 import type { EvidenceCommandExitCode } from "../typings/EvidenceCommandExitCode";
 /**
- * Parses and executes the standalone Evidence command contract.
+ * Parses and executes the standalone Evidence Graph command contract.
  *
- * The executable delegates its argument handling here, while integrations can use
- * `parse` to inspect a command or `run` to capture a finite command's output.
- * This boundary validates syntax before configuration loading so malformed input
- * cannot accidentally scan the caller's project.
+ * The executable delegates its argument handling here, while integrations can
+ * use `parse` to inspect a command or `run` to capture a finite command's
+ * output. This boundary validates syntax before configuration loading so
+ * malformed input cannot accidentally scan the caller's project.
  *
  * @example
- * const command: IEvidenceCommand = EvidenceCommand.parse([
- *   "list",
- *   "--format",
- *   "json",
- * ]);
- * // command.operation is "list" and its default cwd is ".".
+ *   const command: IEvidenceCommand = EvidenceCommand.parse([
+ *     "list",
+ *     "--format",
+ *     "json",
+ *   ]);
+ *   // command.operation is "list" and its default cwd is ".".
  */
 export declare namespace EvidenceCommand {
     /**
      * Converts a complete argument vector into one validated command object.
      *
-     * Parsing assigns operation-specific defaults and rejects unknown, duplicate, or
-     * incompatible options before any filesystem access. `check` is implicit when
-     * the first token is absent or an option; `inspect` alone accepts one positional
-     * target. Callers receive an {@link EvidenceCommandError} for repairable syntax
-     * mistakes rather than a configuration or source diagnostic.
+     * Parsing assigns operation-specific defaults and rejects unknown, duplicate,
+     * or incompatible options before any filesystem access. `check` is implicit
+     * when the first token is absent or an option; `inspect` alone accepts one
+     * positional target. Callers receive an {@link EvidenceCommandError} for
+     * repairable syntax mistakes rather than a configuration or source
+     * diagnostic.
      *
      * @example
-     * EvidenceCommand.parse(["graph", "--format", "dot"]);
-     * // { operation: "graph", cwd: ".", config: "evidence.config.ts", format: "dot" }
+     *   EvidenceCommand.parse(["graph", "--format", "dot"]);
+     *   // { operation: "graph", cwd: ".", config: "evidence.config.ts", format: "dot" }
      */
     function parse(args: readonly string[]): IEvidenceCommand;
     /**
@@ -37,34 +38,38 @@ export declare namespace EvidenceCommand {
      *
      * This is the embedding and logic-test entry point: it does not write process
      * streams and returns parse or operational failures with exit code 2. Text
-     * failures use stderr, while JSON operational failures use stdout to preserve a
-     * parseable report. Watch mode is deliberately excluded because its unbounded
-     * publication lifecycle belongs to {@link EvidenceWatcher} or {@link main}.
+     * failures use stderr, while JSON operational failures use stdout to preserve
+     * a parseable report. Watch mode is deliberately excluded because its
+     * unbounded publication lifecycle belongs to {@link EvidenceWatcher} or
+     * {@link main}.
      *
      * @example
-     * const result: IEvidenceCommandResult = await EvidenceCommand.run(["--help"]);
-     * // result.exitCode === 0 and result.stdout contains the command reference.
+     *   const result: IEvidenceCommandResult = await EvidenceCommand.run([
+     *     "--help",
+     *   ]);
+     *   // result.exitCode === 0 and result.stdout contains the command reference.
      */
     function run(args: readonly string[], baseCwd?: string): Promise<IEvidenceCommandResult>;
     /**
      * Streams a command result through Node's standard output and error channels.
      *
-     * The packaged executable calls this method. It reuses the buffered command path
-     * for finite operations, but keeps watch open and sends parser-asset progress to
-     * stderr unless a report file was requested. Repeated progress is deduplicated
-     * because retries can report the same acquisition state more than once.
+     * The packaged executable calls this method. It reuses the buffered command
+     * path for finite operations, but keeps watch open and sends parser-asset
+     * progress to stderr unless a report file was requested. Repeated progress is
+     * deduplicated because retries can report the same acquisition state more
+     * than once.
      */
     function main(args: readonly string[]): Promise<EvidenceCommandExitCode>;
     /**
      * Creates a starter configuration in the format implied by its filename.
      *
      * JSON receives literal data and TypeScript receives an `IEvidenceConfig`
-     * `satisfies` template with identical defaults. Exclusive creation preserves an
-     * existing author-owned configuration; its collision is rethrown with a focused
-     * repair message instead of being overwritten.
+     * `satisfies` template with identical defaults. Exclusive creation preserves
+     * an existing author-owned configuration; its collision is rethrown with a
+     * focused repair message instead of being overwritten.
      *
      * @example
-     * await EvidenceCommand.initialize("evidence.config.ts");
+     *   await EvidenceCommand.initialize("evidence.config.ts");
      */
     function initialize(file: string): Promise<void>;
 }

package/lib/commands/EvidenceCommand.js

@@ -52,37 +52,38 @@ const EvidenceWatcher_1 = require("./EvidenceWatcher");
 const EvidenceWatchReporter_1 = require("../reporters/EvidenceWatchReporter");
 const EvidenceArtifactTypes_1 = require("../internal/EvidenceArtifactTypes");
 const EvidenceConfigFormat_1 = require("../internal/EvidenceConfigFormat");
-const TreeSitterAssetScope_1 = require("../internal/TreeSitterAssetScope");
+const EvidenceTreeSitterAssetScope_1 = require("../internal/EvidenceTreeSitterAssetScope");
 /**
- * Parses and executes the standalone Evidence command contract.
+ * Parses and executes the standalone Evidence Graph command contract.
  *
- * The executable delegates its argument handling here, while integrations can use
- * `parse` to inspect a command or `run` to capture a finite command's output.
- * This boundary validates syntax before configuration loading so malformed input
- * cannot accidentally scan the caller's project.
+ * The executable delegates its argument handling here, while integrations can
+ * use `parse` to inspect a command or `run` to capture a finite command's
+ * output. This boundary validates syntax before configuration loading so
+ * malformed input cannot accidentally scan the caller's project.
  *
  * @example
- * const command: IEvidenceCommand = EvidenceCommand.parse([
- *   "list",
- *   "--format",
- *   "json",
- * ]);
- * // command.operation is "list" and its default cwd is ".".
+ *   const command: IEvidenceCommand = EvidenceCommand.parse([
+ *     "list",
+ *     "--format",
+ *     "json",
+ *   ]);
+ *   // command.operation is "list" and its default cwd is ".".
  */
 var EvidenceCommand;
 (function (EvidenceCommand) {
     /**
      * Converts a complete argument vector into one validated command object.
      *
-     * Parsing assigns operation-specific defaults and rejects unknown, duplicate, or
-     * incompatible options before any filesystem access. `check` is implicit when
-     * the first token is absent or an option; `inspect` alone accepts one positional
-     * target. Callers receive an {@link EvidenceCommandError} for repairable syntax
-     * mistakes rather than a configuration or source diagnostic.
+     * Parsing assigns operation-specific defaults and rejects unknown, duplicate,
+     * or incompatible options before any filesystem access. `check` is implicit
+     * when the first token is absent or an option; `inspect` alone accepts one
+     * positional target. Callers receive an {@link EvidenceCommandError} for
+     * repairable syntax mistakes rather than a configuration or source
+     * diagnostic.
      *
      * @example
-     * EvidenceCommand.parse(["graph", "--format", "dot"]);
-     * // { operation: "graph", cwd: ".", config: "evidence.config.ts", format: "dot" }
+     *   EvidenceCommand.parse(["graph", "--format", "dot"]);
+     *   // { operation: "graph", cwd: ".", config: "evidence.config.ts", format: "dot" }
      */
     function parse(args) {
         if (args.length === 1 && (args[0] === "-v" || args[0] === "--version"))
@@ -177,7 +178,7 @@ var EvidenceCommand;
             const language = values.get("language");
             if (language !== undefined &&
                 !EvidenceArtifactTypes_1.EvidenceArtifactTypes.isSupported(language))
-                throw new EvidenceCommandError_1.EvidenceCommandError(`Unknown Evidence artifact type '${language}'. Use a type backed by a shipped adapter.`);
+                throw new EvidenceCommandError_1.EvidenceCommandError(`Unknown evidence artifact type '${language}'. Use a type backed by a shipped adapter.`);
             const kind = values.get("kind");
             if (kind !== undefined && !(() => {
                 const _iv0 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
@@ -209,13 +210,16 @@ var EvidenceCommand;
      *
      * This is the embedding and logic-test entry point: it does not write process
      * streams and returns parse or operational failures with exit code 2. Text
-     * failures use stderr, while JSON operational failures use stdout to preserve a
-     * parseable report. Watch mode is deliberately excluded because its unbounded
-     * publication lifecycle belongs to {@link EvidenceWatcher} or {@link main}.
+     * failures use stderr, while JSON operational failures use stdout to preserve
+     * a parseable report. Watch mode is deliberately excluded because its
+     * unbounded publication lifecycle belongs to {@link EvidenceWatcher} or
+     * {@link main}.
      *
      * @example
-     * const result: IEvidenceCommandResult = await EvidenceCommand.run(["--help"]);
-     * // result.exitCode === 0 and result.stdout contains the command reference.
+     *   const result: IEvidenceCommandResult = await EvidenceCommand.run([
+     *     "--help",
+     *   ]);
+     *   // result.exitCode === 0 and result.stdout contains the command reference.
      */
     async function run(args, baseCwd = process.cwd()) {
         let parsed;
@@ -232,7 +236,7 @@ var EvidenceCommand;
                 return { exitCode: 0, stdout: `${await version()}\n`, stderr: "" };
             }
             catch (cause) {
-                return failureResult(cause, "Restore the installed @wrtnlabs/evidence package manifest.");
+                return failureResult(cause, "Restore the installed evidence package manifest.");
             }
         }
         if (parsed.operation === "init")
@@ -247,10 +251,11 @@ var EvidenceCommand;
     /**
      * Streams a command result through Node's standard output and error channels.
      *
-     * The packaged executable calls this method. It reuses the buffered command path
-     * for finite operations, but keeps watch open and sends parser-asset progress to
-     * stderr unless a report file was requested. Repeated progress is deduplicated
-     * because retries can report the same acquisition state more than once.
+     * The packaged executable calls this method. It reuses the buffered command
+     * path for finite operations, but keeps watch open and sends parser-asset
+     * progress to stderr unless a report file was requested. Repeated progress is
+     * deduplicated because retries can report the same acquisition state more
+     * than once.
      */
     async function main(args) {
         let parsed;
@@ -264,7 +269,7 @@ var EvidenceCommand;
         // malformed input consistently with all other buffered command failures.
         const selected = parsed;
         const progressMessages = new Set();
-        const result = await TreeSitterAssetScope_1.TreeSitterAssetScope.run({
+        const result = await EvidenceTreeSitterAssetScope_1.EvidenceTreeSitterAssetScope.run({
             progress: (message) => {
                 if (selected !== undefined &&
                     "output" in selected &&
@@ -289,12 +294,12 @@ var EvidenceCommand;
      * Creates a starter configuration in the format implied by its filename.
      *
      * JSON receives literal data and TypeScript receives an `IEvidenceConfig`
-     * `satisfies` template with identical defaults. Exclusive creation preserves an
-     * existing author-owned configuration; its collision is rethrown with a focused
-     * repair message instead of being overwritten.
+     * `satisfies` template with identical defaults. Exclusive creation preserves
+     * an existing author-owned configuration; its collision is rethrown with a
+     * focused repair message instead of being overwritten.
      *
      * @example
-     * await EvidenceCommand.initialize("evidence.config.ts");
+     *   await EvidenceCommand.initialize("evidence.config.ts");
      */
     async function initialize(file) {
         const format = EvidenceConfigFormat_1.EvidenceConfigFormat.get(file);
@@ -308,7 +313,7 @@ var EvidenceCommand;
         }
         catch (cause) {
             if (errorCode(cause) === "EEXIST")
-                throw new Error(`Refusing to overwrite the existing Evidence configuration: ${file}`);
+                throw new Error(`Refusing to overwrite the existing Evidence Graph configuration: ${file}`);
             throw cause;
         }
     }
@@ -317,9 +322,10 @@ var EvidenceCommand;
 /**
  * Opens the process-owned watch lifecycle and routes each published cycle.
  *
- * Watch output is either appended to the requested destination or written through
- * stdout's completion callback so I/O failures become command failures. The SIGINT
- * handler only requests shutdown; `finally` removes it and joins watcher cleanup.
+ * Watch output is either appended to the requested destination or written
+ * through stdout's completion callback so I/O failures become command failures.
+ * The SIGINT handler only requests shutdown; `finally` removes it and joins
+ * watcher cleanup.
  */
 async function runWatch(command, baseCwd) {
     const cwd = node_path_1.default.resolve(baseCwd, command.cwd);
@@ -332,7 +338,7 @@ async function runWatch(command, baseCwd) {
             await (0, promises_1.writeFile)(destination, "", "utf8");
     }
     catch (cause) {
-        return failureResult(new Error(`Could not initialize Evidence watch output '${String(destination)}': ${errorMessage(cause)}`), "Correct the output path or its permissions and run the command again.");
+        return failureResult(new Error(`Could not initialize Evidence Graph watch output '${String(destination)}': ${errorMessage(cause)}`), "Correct the output path or its permissions and run the command again.");
     }
     const watcher = new EvidenceWatcher_1.EvidenceWatcher(configFile);
     const interrupt = () => {
@@ -361,7 +367,8 @@ async function runWatch(command, baseCwd) {
  * Waits for Node to accept a complete watch block on standard output.
  *
  * Watch publication must apply backpressure. Resolving after `write`'s callback
- * prevents a rapid filesystem change from reordering or losing rendered cycles.
+ * prevents a rapid filesystem change from reordering or losing rendered
+ * cycles.
  */
 async function writeStandardOutput(content) {
     await new Promise((resolve, reject) => {
@@ -376,10 +383,10 @@ async function writeStandardOutput(content) {
 /**
  * Runs one analysis and projects it into check, query, or graph output.
  *
- * Every operation shares one checker result so list, inspect, and graph describe
- * the same configuration and source snapshot as the underlying check. A thrown
- * loading or analysis failure is serialized in the selected report format before
- * the optional output-file path is attempted.
+ * Every operation shares one checker result so list, inspect, and graph
+ * describe the same configuration and source snapshot as the underlying check.
+ * A thrown loading or analysis failure is serialized in the selected report
+ * format before the optional output-file path is attempted.
  */
 async function runAnalysis(command, baseCwd) {
     const cwd = node_path_1.default.resolve(baseCwd, command.cwd);
@@ -423,8 +430,9 @@ async function runAnalysis(command, baseCwd) {
 /**
  * Renders shipped adapter capabilities without loading project configuration.
  *
- * `languages` remains useful in a broken project because its data comes from the
- * package registry, while output handling follows the same contract as analysis.
+ * `languages` remains useful in a broken project because its data comes from
+ * the package registry, while output handling follows the same contract as
+ * analysis.
  */
 async function runLanguages(command, baseCwd) {
     const cwd = node_path_1.default.resolve(baseCwd, command.cwd);
@@ -436,7 +444,8 @@ async function runLanguages(command, baseCwd) {
  *
  * Text failures use stderr when no file is requested; JSON is kept on stdout so
  * machine consumers receive a valid structured failure document. File-write
- * errors replace the original result because no requested report was delivered.
+ * errors replace the original result because no requested report was
+ * delivered.
  */
 async function writeReport(output, cwd, content, exitCode, failure) {
     if (output === undefined)
@@ -451,15 +460,15 @@ async function writeReport(output, cwd, content, exitCode, failure) {
         return { exitCode, stdout: "", stderr: "" };
     }
     catch (cause) {
-        return failureResult(new Error(`Could not write Evidence report '${destination}': ${errorMessage(cause)}`), "Correct the output path or its permissions and run the command again.");
+        return failureResult(new Error(`Could not write Evidence Graph report '${destination}': ${errorMessage(cause)}`), "Correct the output path or its permissions and run the command again.");
     }
 }
 /**
  * Resolves and creates an initialization target for buffered command execution.
  *
- * Initializing is intentionally separate from analysis: it needs only its working
- * directory and configuration path, and reports existing-file conflicts as a
- * command result instead of loading an unrelated current configuration.
+ * Initializing is intentionally separate from analysis: it needs only its
+ * working directory and configuration path, and reports existing-file conflicts
+ * as a command result instead of loading an unrelated current configuration.
  */
 async function runInit(command, baseCwd) {
     const cwd = node_path_1.default.resolve(baseCwd, command.cwd);
@@ -490,15 +499,15 @@ function command(token) {
         case "list":
             return token;
         default:
-            throw new EvidenceCommandError_1.EvidenceCommandError(`Unknown Evidence command '${token}'.`);
+            throw new EvidenceCommandError_1.EvidenceCommandError(`Unknown evidence command '${token}'.`);
     }
 }
 /**
  * Normalizes supported short and long option spellings to parser map keys.
  *
- * The normalized key lets the parser reject duplicate aliases and apply operation
- * rules once, while an undefined result preserves the user's original token in the
- * unknown-argument diagnostic.
+ * The normalized key lets the parser reject duplicate aliases and apply
+ * operation rules once, while an undefined result preserves the user's original
+ * token in the unknown-argument diagnostic.
  */
 function optionKey(token) {
     switch (token) {
@@ -541,8 +550,9 @@ function optionAllowed(operation, option) {
 /**
  * Adds a report destination only when the user supplied one.
  *
- * Omission remains distinct from an empty string, which parse has already rejected;
- * renderers then choose buffered stdout or stderr behavior from property presence.
+ * Omission remains distinct from an empty string, which parse has already
+ * rejected; renderers then choose buffered stdout or stderr behavior from
+ * property presence.
  */
 function optionalOutput(values) {
     const output = values.get("output");
@@ -551,8 +561,9 @@ function optionalOutput(values) {
 /**
  * Validates the text-or-JSON format shared by report-producing commands.
  *
- * Text is the interactive default. Rejecting unknown values before loading keeps a
- * misspelled formatter from paying the cost of analysis or changing source state.
+ * Text is the interactive default. Rejecting unknown values before loading
+ * keeps a misspelled formatter from paying the cost of analysis or changing
+ * source state.
  */
 function reportFormat(value) {
     const format = value ?? "text";
@@ -564,7 +575,8 @@ function reportFormat(value) {
  * Validates the graph-specific output family and supplies its JSON default.
  *
  * Graph visualization formats are not general report formats, so this separate
- * gate keeps `mermaid` and `dot` unavailable to commands that cannot render them.
+ * gate keeps `mermaid` and `dot` unavailable to commands that cannot render
+ * them.
  */
 function graphFormat(value) {
     const format = value ?? "json";
@@ -575,8 +587,8 @@ function graphFormat(value) {
 /**
  * Reads the installed package version without loading project configuration.
  *
- * The manifest is shape-checked because executable packaging determines its path;
- * a broken installation becomes an actionable version-command failure.
+ * The manifest is shape-checked because executable packaging determines its
+ * path; a broken installation becomes an actionable version-command failure.
  */
 async function version() {
     const manifest = (() => {
@@ -595,12 +607,12 @@ async function version() {
                 ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
                     method: "typia.json.assertParse",
                     path: _path + "",
-                    expected: "IPackageManifest",
+                    expected: "IEvidencePackageManifest",
                     value: input
                 }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
                     method: "typia.json.assertParse",
                     path: _path + "",
-                    expected: "IPackageManifest",
+                    expected: "IEvidencePackageManifest",
                     value: input
                 }, _errorFactory))(input, "$input", true);
             }
@@ -614,21 +626,23 @@ async function version() {
  * Converts an unexpected command-boundary failure into the stable result shape.
  *
  * Exit code 2 distinguishes unavailable or invalid execution from a completed
- * Evidence violation. Keeping this mapping centralized makes parse, manifest, and
- * I/O failures present the same repair-oriented terminal contract.
+ * Evidence Graph violation. Keeping this mapping centralized makes parse,
+ * manifest, and I/O failures present the same repair-oriented terminal
+ * contract.
  */
 function failureResult(cause, repair) {
     return {
         exitCode: 2,
         stdout: "",
-        stderr: `Evidence command failed: ${errorMessage(cause)}\nRepair: ${repair}\n`,
+        stderr: `evidence command failed: ${errorMessage(cause)}\nRepair: ${repair}\n`,
     };
 }
 /**
  * Extracts a Node-style error code without trusting arbitrary thrown values.
  *
  * Filesystem APIs may throw non-Error values in embedding environments. The
- * initializer uses this narrow probe only to recognize exclusive-create conflicts.
+ * initializer uses this narrow probe only to recognize exclusive-create
+ * conflicts.
  */
 function errorCode(cause) {
     if (!(cause instanceof Error) || !("code" in cause))
@@ -639,8 +653,8 @@ function errorCode(cause) {
 /**
  * Produces a printable failure message while preserving native Error text.
  *
- * String conversion gives command rendering a deterministic fallback for rejected
- * promises that throw primitives or foreign error-like objects.
+ * String conversion gives command rendering a deterministic fallback for
+ * rejected promises that throw primitives or foreign error-like objects.
  */
 function errorMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
@@ -649,7 +663,8 @@ function errorMessage(cause) {
  * Terminal reference returned before configuration loading for explicit help.
  *
  * Keep options, defaults, formats, and exit semantics aligned with `parse` and
- * command execution so the repair path remains trustworthy after syntax failure.
+ * command execution so the repair path remains trustworthy after syntax
+ * failure.
  */
 const HELP = (0, utils_1.dedent) `
   Usage: evidence [check] [options]
@@ -663,7 +678,7 @@ const HELP = (0, utils_1.dedent) `
 
   Commands:
     check                 Evaluate every enabled claim and reference (default).
-    list                  List configured public Evidence targets.
+    list                  List configured public Evidence Graph targets.
     inspect               Resolve and explain one target in every applicable scope.
     graph                 Export the configured graph as json, mermaid, or dot.
     languages             Report adapters shipped with this package.
@@ -674,8 +689,8 @@ const HELP = (0, utils_1.dedent) `
         --cwd <path>      Resolve CLI paths from this directory.
         --format <value>  Select the command's output format.
     -o, --output <path>   Write command output to a file.
-        --language <type> Filter evidence list by artifact type.
-        --kind <symbol>   Filter evidence list by symbol kind.
+        --language <type> Filter the Evidence Graph list by artifact type.
+        --kind <symbol>   Filter the Evidence Graph list by symbol kind.
     -w, --watch           Recheck whenever an active dependency changes.
     -h, --help            Show this help without loading configuration.
     -v, --version         Show the package version without loading configuration.
@@ -687,7 +702,7 @@ const HELP = (0, utils_1.dedent) `
 
   Exit codes:
     0  Complete analysis without error-severity findings.
-    1  Complete analysis with Evidence violations or an unresolved inspection.
+    1  Complete analysis with Evidence Graph violations or an unresolved inspection.
     2  Invalid command/configuration or incomplete analysis.
 
   Watch stays active across cycle exit codes. Ctrl+C cleans up and exits 0.

package/lib/commands/EvidenceCommandError.d.ts

@@ -1,9 +1,9 @@
 /**
  * Invalid CLI syntax detected before configuration or source loading.
  *
- * The command parser uses this error for unknown, repeated, missing, or incompatible
- * arguments. Buffered execution turns it into actionable failure output so malformed
- * commands cannot trigger an unrelated project analysis.
+ * The command parser uses this error for unknown, repeated, missing, or
+ * incompatible arguments. Buffered execution turns it into actionable failure
+ * output so malformed commands cannot trigger an unrelated project analysis.
  */
 export declare class EvidenceCommandError extends Error {
     /**

package/lib/commands/EvidenceCommandError.js

@@ -4,9 +4,9 @@ exports.EvidenceCommandError = void 0;
 /**
  * Invalid CLI syntax detected before configuration or source loading.
  *
- * The command parser uses this error for unknown, repeated, missing, or incompatible
- * arguments. Buffered execution turns it into actionable failure output so malformed
- * commands cannot trigger an unrelated project analysis.
+ * The command parser uses this error for unknown, repeated, missing, or
+ * incompatible arguments. Buffered execution turns it into actionable failure
+ * output so malformed commands cannot trigger an unrelated project analysis.
  */
 class EvidenceCommandError extends Error {
     /**