@0xcraft/powershot 1.1.2 → 1.1.4

package/dist/ground.js

@@ -4,6 +4,7 @@ import { decode } from './text.js';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { PACKS, packFor, parseIsolated } from './lang/packs.js';
 import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
+import { createReinventionScopeResolver, typescriptImplementationFingerprint } from './reinvention.js';
 const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
 const TS_CONFIG = /^tsconfig(?:\..+)?\.json$/i;
 const MISSING_TYPE_PREFIXES = [
@@ -289,7 +290,7 @@ export async function buildGround(root, changed, signal) {
         beforeProject,
         changed,
         files,
-        symbolIndex: buildSymbolIndex(sourceFiles, root),
+        symbolIndex: buildSymbolIndex(sourceFiles, root, changed, beforeProject),
         deps: depsFor(join(root, 'x.ts')),
         depsFor,
         typed,
@@ -437,8 +438,27 @@ async function parseForeign(root, changed, signal) {
         return result ? [result] : [];
     });
 }
-function buildSymbolIndex(sourceFiles, root) {
+function buildSymbolIndex(sourceFiles, root, changed, beforeProject) {
     const index = new Map();
+    const changes = new Map(changed.map((file) => [file.path, file]));
+    const scopeFor = createReinventionScopeResolver(root);
+    const relevantNames = new Set();
+    for (const sf of sourceFiles) {
+        const rel = repoPath(root, String(sf.getFilePath()));
+        if (!changes.has(rel))
+            continue;
+        for (const declaration of sf.getFunctions()) {
+            const name = declaration.getName();
+            if (name)
+                relevantNames.add(normalizeName(name));
+        }
+        for (const declaration of sf.getVariableDeclarations()) {
+            const initializer = declaration.getInitializer();
+            if (initializer?.isKind(SyntaxKind.ArrowFunction) || initializer?.isKind(SyntaxKind.FunctionExpression)) {
+                relevantNames.add(normalizeName(declaration.getName()));
+            }
+        }
+    }
     for (const sf of sourceFiles) {
         const path = String(sf.getFilePath());
         // the project glob follows symlinked directories, so what it loaded is not
@@ -446,26 +466,47 @@ function buildSymbolIndex(sourceFiles, root) {
         if (path.includes('/node_modules/') || !insideRepo(root, path))
             continue;
         for (const [name, decls] of sf.getExportedDeclarations()) {
+            const key = normalizeName(name);
+            // Fingerprint only names the change could have introduced. This keeps index
+            // construction proportional to the diff even when the project closure is a
+            // very large monorepo.
+            if (!relevantNames.has(key))
+                continue;
             const decl = decls[0];
             if (!decl)
                 continue;
             // only index things that could plausibly be reimplemented
             const kind = decl.getKind();
             if (kind !== SyntaxKind.FunctionDeclaration &&
-                kind !== SyntaxKind.VariableDeclaration &&
-                kind !== SyntaxKind.ClassDeclaration)
+                kind !== SyntaxKind.VariableDeclaration)
+                continue;
+            const fingerprint = typescriptImplementationFingerprint(decl);
+            if (!fingerprint)
+                continue;
+            // A barrel alias can be new in this change even when its underlying callable
+            // predates it. Index the declaration from its own module, where both its name
+            // and base existence can be proved, rather than manufacturing history for the
+            // new alias or recording every `export *` as another copy.
+            if (decl.getSourceFile() !== sf)
                 continue;
-            // a barrel re-exports another module's symbol, so record where it is actually
-            // declared — otherwise `export * from './x'` makes every symbol look duplicated
             const declPath = String(decl.getSourceFile().getFilePath());
             if (declPath.includes('/node_modules/') || !insideRepo(root, declPath))
                 continue;
             const rel = repoPath(root, declPath);
-            const key = normalizeName(name);
+            const change = changes.get(rel);
+            const before = change?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + rel);
+            const existedInBase = change === undefined || (before?.getExportedDeclarations().get(name) ?? []).some((baseDeclaration) => typescriptImplementationFingerprint(baseDeclaration) === fingerprint);
             const list = index.get(key) ?? [];
             if (list.some((e) => e.file === rel && e.line === decl.getStartLineNumber()))
                 continue;
-            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            list.push({
+                file: rel,
+                name,
+                line: decl.getStartLineNumber(),
+                fingerprint,
+                existedInBase,
+                scope: scopeFor(rel),
+            });
             index.set(key, list);
         }
     }

package/dist/langtest.js

@@ -8,8 +8,9 @@
  */
 import assert from 'node:assert/strict';
 import { execFileSync } from 'node:child_process';
+import { Project } from 'ts-morph';
 import { PACKS, parse } from './lang/packs.js';
-import { tokensFor } from './verifiers/foreign.js';
+import { foreignReinvented, tokensFor } from './verifiers/foreign.js';
 /** each fixture: a handler that discards, one that genuinely handles, one explained */
 const FIXTURES = {
     python: 'def f():\n    try:\n        a()\n    except Exception:\n        pass\n    try:\n        b()\n    except Exception as e:\n        raise RuntimeError("x") from e\n    try:\n        c()\n    except Exception:\n        pass  # deliberate\n',
@@ -32,6 +33,70 @@ const HANDLED = {
     rust: 'return Err(e)', cpp: 'throw;', 'c#': 'throw;', php: 'throw $e',
     kotlin: 'throw e', ruby: 'raise', solidity: 'revert("x")',
 };
+const REINVENTED_NAME = {
+    python: ['def f():', 'def normalize_payload():'],
+    go: ['func F()', 'func NormalizePayload()'],
+    java: ['class A', 'class NormalizePayload'],
+    rust: ['fn f()', 'fn normalize_payload()'],
+    cpp: ['void f()', 'void normalizePayload()'],
+    c: ['int f(', 'int normalizePayload('],
+    'c#': ['class A', 'class NormalizePayload'],
+    php: ['function f()', 'function normalizePayload()'],
+    kotlin: ['fun f()', 'fun normalizePayload()'],
+    ruby: ['def f\n', 'def normalize_payload\n'],
+    solidity: ['contract A', 'contract NormalizePayload'],
+};
+const REINVENTED_MUTATION = {
+    python: ['a()', 'z()'],
+    go: ['a()', 'z()'],
+    java: ['a()', 'z()'],
+    rust: ['a()', 'z()'],
+    cpp: ['a()', 'z()'],
+    c: ['return n;', 'return n + 1;'],
+    'c#': ['A()', 'Z()'],
+    php: ['a()', 'z()'],
+    kotlin: ['a()', 'z()'],
+    ruby: ['    a\n', '    z\n'],
+    solidity: ['a()', 'z()'],
+};
+function allLines(source) {
+    return new Set(Array.from({ length: source.split('\n').length }, (_, index) => index + 1));
+}
+async function foreignReinventionGround(pack, existingSource, addedSource, existingBeforeSource = existingSource, addedBeforeSource) {
+    const extension = pack.extensions[0];
+    const existingPath = 'z-existing' + extension;
+    const addedPath = 'a-new' + extension;
+    const existingTree = await parse(pack, existingSource);
+    const addedTree = await parse(pack, addedSource);
+    const beforeTree = existingBeforeSource === null ? undefined : await parse(pack, existingBeforeSource);
+    const addedBeforeTree = addedBeforeSource === undefined ? undefined : await parse(pack, addedBeforeSource);
+    if (!existingTree || !addedTree)
+        throw new Error('fixture did not parse');
+    const existingChange = {
+        path: existingPath,
+        added: existingBeforeSource === null ? allLines(existingSource) : new Set(),
+        before: existingBeforeSource ?? undefined,
+    };
+    const addedChange = { path: addedPath, added: allLines(addedSource), before: addedBeforeSource };
+    const foreign = [
+        { path: existingPath, pack, tree: existingTree, beforeTree, changed: existingChange },
+        { path: addedPath, pack, tree: addedTree, beforeTree: addedBeforeTree, changed: addedChange },
+    ];
+    return {
+        root: '/virtual/repo',
+        sourceFiles: [],
+        configFiles: [],
+        beforeProject: new Project({ useInMemoryFileSystem: true }),
+        changed: [existingChange, addedChange],
+        files: [],
+        symbolIndex: new Map(),
+        deps: new Set(),
+        depsFor: () => new Set(),
+        typed: false,
+        internalPrefixes: [],
+        foreign,
+    };
+}
 async function one(name) {
     const pack = PACKS.find((p) => p.name === name);
     if (!pack) {
@@ -79,6 +144,33 @@ async function one(name) {
             assert.equal(hits.some((h) => h.node.text.includes(HANDLED[name])), false, 'reported a real handler');
         });
     }
+    if (source && tree) {
+        const rename = REINVENTED_NAME[name];
+        const mutation = REINVENTED_MUTATION[name];
+        assert.ok(rename && mutation, 'no reinvention fixture written');
+        const existing = source.replace(rename[0], rename[1]);
+        const different = existing.replace(mutation[0], mutation[1]);
+        const differentGround = await foreignReinventionGround(pack, existing, different);
+        const identicalGround = await foreignReinventionGround(pack, existing, existing);
+        const bothNewGround = await foreignReinventionGround(pack, existing, existing, null);
+        const candidateChangedGround = await foreignReinventionGround(pack, existing, existing, different);
+        const targetPreexistingGround = await foreignReinventionGround(pack, existing, existing, existing, existing);
+        check('reinvented ignores a same-name different implementation', () => {
+            assert.equal(foreignReinvented.run(differentGround).length, 0);
+        });
+        check('reinvented detects an exact implementation already present in the base', () => {
+            assert.ok(foreignReinvented.run(identicalGround).length >= 1);
+        });
+        check('reinvented does not compare two declarations both added by the change', () => {
+            assert.equal(foreignReinvented.run(bothNewGround).length, 0);
+        });
+        check('reinvented ignores a candidate that only became equivalent in this change', () => {
+            assert.equal(foreignReinvented.run(candidateChangedGround).length, 0);
+        });
+        check('reinvented ignores an implementation already present in the changed file', () => {
+            assert.equal(foreignReinvented.run(targetPreexistingGround).length, 0);
+        });
+    }
     return failed;
 }
 /** Signature comparison is Python-only for now, and is what decides a contract break. */

package/dist/manifest.js

@@ -2,23 +2,6 @@ import { createHash } from 'node:crypto';
 import { mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export const SCHEMA = 'powershot.run/v1';
-/** Human-readable optional depth, kept separate from verdict-blocking notLookedAt. */
-export function unavailableCoverage(record) {
-    const out = [];
-    const files = (record.files ?? []).filter((file) => file.unavailable?.length);
-    if (files.length > 0) {
-        out.push(files.length + ' file(s) without enriched semantic coverage: ' +
-            files.slice(0, 5).map((file) => file.path + ' (' + file.unavailable.join(', ') + ')').join(', ') +
-            (files.length > 5 ? ', …' : ''));
-    }
-    const checks = record.checks?.unavailable ?? [];
-    if (checks.length > 0) {
-        out.push(checks.length + ' enriched check(s) unavailable: ' +
-            checks.slice(0, 8).map((check) => check.check + ' (no ' + check.missing + ')').join(', ') +
-            (checks.length > 8 ? ', …' : ''));
-    }
-    return out;
-}
 /** The single state machine behind manifests, benches, renderers and exit codes. */
 export function completionOf(parts) {
     const waivedUnits = parts.units.filter((unit) => unit.outcome === 'waived').length;

package/dist/package-smoke.js

@@ -64,8 +64,12 @@ try {
             throw new Error('architecture guide is missing');
         if (!existsSync(join(installed, 'docs', 'ci.md')))
             throw new Error('CI guide is missing');
+        if (!existsSync(join(installed, 'dist', 'github', 'api.js')))
+            throw new Error('GitHub REST runtime is missing');
         if (!existsSync(join(installed, 'dist', 'github', 'inline-comments.js')))
             throw new Error('inline review runtime is missing');
+        if (!existsSync(join(installed, 'dist', 'github', 'summary-comment.js')))
+            throw new Error('summary comment runtime is missing');
         if (!existsSync(join(installed, 'examples', 'github-actions', 'cli.yml')))
             throw new Error('CI example is missing');
         if (!existsSync(join(installed, 'examples', 'gitlab', '.gitlab-ci.yml')))

package/dist/reinvention.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { Node, ts, } from 'ts-morph';
+import { insideRepo, repoPath } from './fspolicy.js';
+const SCOPE_FILES = [
+    'package.json',
+    'pyproject.toml', 'setup.py', 'setup.cfg',
+    'Cargo.toml', 'go.mod',
+    'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+    'composer.json', 'Gemfile',
+    'CMakeLists.txt', 'meson.build',
+    'foundry.toml',
+];
+const SCOPE_SUFFIX = /\.(?:csproj|sln|gemspec)$/i;
+function declaresScope(dir) {
+    if (SCOPE_FILES.some((name) => existsSync(resolve(dir, name))))
+        return true;
+    try {
+        return readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isFile() && SCOPE_SUFFIX.test(entry.name));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve package boundaries once per directory. A symbol index can contain tens of
+ * thousands of declarations in a monorepo, so walking and reading every ancestor for
+ * every symbol would turn a conservative check into the slowest part of the review.
+ */
+export function createReinventionScopeResolver(root) {
+    root = resolve(root);
+    const cache = new Map();
+    const scopeForDirectory = (dir) => {
+        const cached = cache.get(dir);
+        if (cached !== undefined)
+            return cached;
+        let scope;
+        if (declaresScope(dir))
+            scope = repoPath(root, dir);
+        else if (dir === root)
+            scope = '';
+        else {
+            const parent = dirname(dir);
+            scope = parent === dir || !insideRepo(root, parent) ? '' : scopeForDirectory(parent);
+        }
+        cache.set(dir, scope);
+        return scope;
+    };
+    return (file) => {
+        const abs = insideRepo(root, file);
+        return abs ? scopeForDirectory(dirname(abs)) : '';
+    };
+}
+/** Nearest language-appropriate package boundary, or the repository root. */
+export function reinventionScope(root, file) {
+    return createReinventionScopeResolver(root)(file);
+}
+function callable(node) {
+    if (Node.isFunctionDeclaration(node) || Node.isArrowFunction(node) || Node.isFunctionExpression(node))
+        return node;
+    if (!Node.isVariableDeclaration(node))
+        return undefined;
+    const init = node.getInitializer();
+    return init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init)) ? init : undefined;
+}
+/**
+ * Exact program tokens for a callable, excluding its export modifier and declared
+ * name. Layout and comments may differ; parameters, types, operators, callees and
+ * literals may not. That is deliberately conservative: a name match proposes a
+ * candidate, but only equivalent executable text is deterministic evidence that a
+ * helper was reimplemented.
+ */
+export function typescriptImplementationFingerprint(node) {
+    const fn = callable(node);
+    const body = fn?.getBody();
+    if (!fn || !body)
+        return undefined;
+    const generator = !Node.isArrowFunction(fn) && fn.isGenerator();
+    const source = [
+        fn.isAsync() ? 'async' : 'sync',
+        generator ? 'generator' : 'plain',
+        '<' + fn.getTypeParameters().map((parameter) => parameter.getText()).join(',') + '>',
+        '(' + fn.getParameters().map((parameter) => parameter.getText()).join(',') + ')',
+        ':' + (fn.getReturnTypeNode()?.getText() ?? ''),
+        body.getText(),
+    ].join('\n');
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.JSX, source);
+    const tokens = [];
+    let token = scanner.scan();
+    for (let count = 0; token !== ts.SyntaxKind.EndOfFileToken && count < 100_000; count++) {
+        tokens.push({ type: token, text: scanner.getTokenText() });
+        token = scanner.scan();
+    }
+    // Fail closed instead of hashing a shared prefix of two exceptionally large
+    // callables and presenting that collision as duplication evidence.
+    if (token !== ts.SyntaxKind.EndOfFileToken)
+        return undefined;
+    return implementationFingerprint(tokens);
+}
+/** Stable hash of compiler-visible tokens; comments and layout never enter it. */
+export function implementationFingerprint(tokens) {
+    const hash = createHash('sha256');
+    for (const token of tokens) {
+        hash.update(JSON.stringify([token.type, token.text])).update('\n');
+    }
+    return hash.digest('hex');
+}
+//# sourceMappingURL=reinvention.js.map

package/dist/report/markdown.js

@@ -1,4 +1,4 @@
-import { unavailableCoverage } from '#app/manifest.js';
+import { modeNote, noFindingsLabel, scopeLine, } from './summary.js';
 const MARK = { verified: '▣', judged: '▚' };
 /** Untrusted prose encoded as literal CommonMark text. */
 function text(s) {
@@ -51,6 +51,26 @@ function group(findings) {
         list.sort((a, b) => a.line - b.line);
     return out;
 }
+function runSummary(run) {
+    const out = [];
+    const scope = scopeLine(run);
+    const mode = modeNote(run, '`verify-only`');
+    const details = run.state === 'complete'
+        ? run.scopeDetails ?? []
+        : [...run.notLookedAt, ...(run.scopeDetails ?? [])];
+    if (scope)
+        out.push(scope, '');
+    if (mode)
+        out.push(mode, '');
+    if (details.length > 0) {
+        out.push('<details>', '<summary>' +
+            (run.state !== 'complete'
+                ? 'Why this is not a verdict'
+                : run.coverage === 'portable' ? 'Coverage details' : 'Review scope') +
+            '</summary>', '', ...details.map((detail) => '- ' + text(detail)), '', '</details>', '');
+    }
+    return out;
+}
 export function markdown(findings, run) {
     // "No findings" from a run that could not look is the one thing this must never
     // say on its own — the reader takes a comment at face value, and a red job beside
@@ -59,33 +79,25 @@ export function markdown(findings, run) {
     const banner = incomplete
         ? [
             '> [!WARNING]',
-            '> **This review is ' + text(run.state) + ' — not a verdict.** Something was not looked at:',
-            ...run.notLookedAt.slice(0, 8).map((f) => '> - ' + text(f)),
-            '',
-        ]
-        : [];
-    const portable = run?.state === 'complete' && run.coverage === 'portable';
-    const coverage = portable
-        ? [
-            '> [!NOTE]',
-            '> **Portable coverage.** Self-contained oracles ran; enriched semantic depth was unavailable:',
-            ...unavailableCoverage(run).map((reason) => '> - ' + text(reason)),
+            '> **This review is ' + text(run.state) + ' — not a verdict.** Some files or checks were not reviewed.',
             '',
         ]
         : [];
+    const summary = run ? runSummary(run) : [];
     if (findings.length === 0) {
         return [
-            '## PowerShot', '', ...banner, ...coverage,
+            '## PowerShot', '', ...banner,
             incomplete
                 ? 'No findings *from what it managed to review*.'
-                : portable ? 'No findings in portable coverage.' : 'No findings.',
-            '',
+                : run ? '✅ **' + noFindingsLabel(run) + '**' : 'No findings.',
+            '', ...summary,
         ].join('\n');
     }
     const verified = findings.filter((f) => f.class === 'verified').length;
     const judged = findings.length - verified;
-    const out = ['## PowerShot', '', ...banner, ...coverage];
+    const out = ['## PowerShot', '', ...banner];
     out.push('**' + verified + ' verified** (deterministic, 0 tokens) · **' + judged + ' judged** (agent)', '');
+    out.push(...summary);
     for (const [file, list] of group(findings)) {
         out.push('### `' + path(file) + '`', '');
         for (const f of list) {

package/dist/report/sarif.js

@@ -10,7 +10,7 @@ function level(severity) {
 const DESCRIPTIONS = {
     'phantom-api': 'Calls an API that does not exist — hallucinated method, property, or arity',
     'phantom-dep': 'Imports a package that is not a declared dependency',
-    reinvented: 'Declares a helper that already exists in the repository',
+    reinvented: 'Adds a callable whose token-identical implementation already existed in the same package',
     'dropped-guard': 'A guard present before the change is gone after it',
     'swallowed-error': 'Error handling that discards the failure',
     'vacuous-test': 'A test that asserts nothing, or mocks the unit under test',

package/dist/report/summary.js

@@ -0,0 +1,103 @@
+function plural(count, singular, pluralForm = singular + 's') {
+    return count + ' ' + (count === 1 ? singular : pluralForm);
+}
+function capabilityName(capability) {
+    return {
+        types: 'type information',
+        references: 'a reference graph',
+        'python-types': 'Python type information',
+        base: 'a base revision',
+        syntax: 'a syntax tree',
+    }[capability] ?? capability;
+}
+function naturalList(values, conjunction = 'and') {
+    if (values.length < 2)
+        return values[0] ?? '';
+    if (values.length === 2)
+        return values[0] + ' ' + conjunction + ' ' + values[1];
+    return values.slice(0, -1).join(', ') + ', ' + conjunction + ' ' + values.at(-1);
+}
+function scopeDetails(record) {
+    const details = [];
+    const selected = (record.files ?? []).filter((file) => file.disposition === 'selected');
+    const unavailableGroups = new Map();
+    for (const file of selected) {
+        if (!file.unavailable?.length)
+            continue;
+        const order = ['types', 'references', 'python-types', 'base', 'syntax'];
+        const capabilities = [...new Set(file.unavailable)].sort((left, right) => {
+            const leftRank = order.indexOf(left);
+            const rightRank = order.indexOf(right);
+            return (leftRank === -1 ? order.length : leftRank) - (rightRank === -1 ? order.length : rightRank) ||
+                left.localeCompare(right);
+        });
+        const key = capabilities.join('\0');
+        const group = unavailableGroups.get(key) ?? { capabilities, count: 0 };
+        group.count++;
+        unavailableGroups.set(key, group);
+    }
+    for (const group of unavailableGroups.values()) {
+        const capabilities = naturalList(group.capabilities.map(capabilityName));
+        details.push(plural(group.count, 'reviewed file') + ' lacked ' + capabilities + '.');
+    }
+    const unavailableChecks = record.checks?.unavailable ?? [];
+    if (unavailableChecks.length > 0) {
+        const shown = unavailableChecks.slice(0, 8).map((check) => check.check);
+        const requirements = [...new Set(unavailableChecks.flatMap((check) => check.missing.split(/,\s*/)))]
+            .map(capabilityName);
+        details.push(plural(unavailableChecks.length, 'check') + ' requiring ' + naturalList(requirements, 'or') +
+            ' did not run: ' + shown.join(', ') +
+            (unavailableChecks.length > shown.length ? ', and ' + (unavailableChecks.length - shown.length) + ' more' : '') + '.');
+    }
+    const waived = new Map();
+    for (const file of record.files ?? []) {
+        if (file.disposition !== 'waived')
+            continue;
+        const reason = file.reason ?? 'unspecified reason';
+        waived.set(reason, (waived.get(reason) ?? 0) + 1);
+    }
+    for (const [reason, count] of waived) {
+        details.push(plural(count, 'changed file') + ' not reviewed: ' + reason + '.');
+    }
+    return details;
+}
+export function summarizeRun(record) {
+    const hasFiles = record.files !== undefined;
+    const hasChecks = record.checks?.ran !== undefined;
+    return {
+        state: record.state,
+        notLookedAt: [...record.notLookedAt],
+        coverage: record.coverage,
+        verifyOnly: record.engine?.verifyOnly,
+        minSeverity: record.engine?.minSeverity,
+        filesReviewed: hasFiles
+            ? record.files.filter((file) => file.disposition === 'selected').length
+            : undefined,
+        deterministicChecks: hasChecks ? new Set(record.checks.ran).size : undefined,
+        scopeDetails: scopeDetails(record),
+    };
+}
+export function noFindingsLabel(summary) {
+    const threshold = summary.minSeverity === undefined || summary.minSeverity === 'info'
+        ? ''
+        : summary.minSeverity === 'critical'
+            ? 'critical '
+            : summary.minSeverity + '-or-higher ';
+    const origin = summary.verifyOnly === true ? 'deterministic ' : '';
+    return 'No ' + threshold + origin + 'findings';
+}
+export function scopeLine(summary) {
+    const parts = [];
+    if (summary.filesReviewed !== undefined)
+        parts.push(plural(summary.filesReviewed, 'file') + ' reviewed');
+    if (summary.deterministicChecks !== undefined) {
+        parts.push(plural(summary.deterministicChecks, 'deterministic check'));
+    }
+    if (summary.coverage !== undefined)
+        parts.push(summary.coverage + ' coverage');
+    return parts.length > 0 ? parts.join(' · ') : undefined;
+}
+export function modeNote(summary, verifyOnly = 'verify-only') {
+    return summary.verifyOnly === true ? 'Model review was disabled (' + verifyOnly + ').' : undefined;
+}
+//# sourceMappingURL=summary.js.map

package/dist/report/terminal.js

@@ -1,5 +1,6 @@
 import { bold, brightRed, dim, gray, red, steel, yellow } from './ansi.js';
 import { highlight, isJsx } from './highlight.js';
+import { modeNote, noFindingsLabel, scopeLine } from './summary.js';
 const SEVERITY_COLOR = {
     critical: brightRed,
     high: red,
@@ -106,17 +107,22 @@ export function terminal(findings, opts) {
     out.push(' ' + bold('PowerShot') + dim('  ·  ' + opts.subtitle));
     out.push(rule);
     const incomplete = opts.state !== 'complete';
-    const portable = !incomplete && opts.coverage === 'portable';
+    const scope = scopeLine(opts);
+    const mode = modeNote(opts);
     if (findings.length === 0) {
         out.push('', incomplete
             ? ' ' + yellow('!') + '  No findings — but this review is ' + opts.state + ', not a verdict.'
-            : ' ' + steel('✔') + (portable ? '  No findings in portable coverage.' : '  No findings.'));
+            : ' ' + steel('✔') + '  ' + noFindingsLabel(opts) + '.');
         for (const reason of opts.notLookedAt)
             out.push(dim('    ' + reason));
-        if (portable) {
-            out.push(dim('    Portable coverage: self-contained oracles ran; enriched semantic depth was unavailable.'));
-            for (const reason of opts.unavailableCoverage ?? [])
-                out.push(dim('    ' + reason));
+        if (scope)
+            out.push(dim('    ' + scope));
+        if (mode)
+            out.push(dim('    ' + mode));
+        if ((opts.scopeDetails?.length ?? 0) > 0) {
+            out.push(dim('    ' + (opts.coverage === 'portable' ? 'Coverage details:' : 'Review scope:')));
+            for (const detail of opts.scopeDetails)
+                out.push(dim('      - ' + detail));
         }
         out.push('');
         return out.join('\n');
@@ -152,11 +158,12 @@ export function terminal(findings, opts) {
         for (const reason of opts.notLookedAt)
             out.push(dim('   ' + reason));
     }
-    else if (portable) {
-        out.push(' ' + steel('◇ portable coverage') + dim(' · enriched semantic depth was unavailable'));
-        for (const reason of opts.unavailableCoverage ?? [])
-            out.push(dim('   ' + reason));
-    }
+    if (scope)
+        out.push(' ' + steel('◇ ') + dim(scope));
+    if (mode)
+        out.push(dim('   ' + mode));
+    for (const detail of opts.scopeDetails ?? [])
+        out.push(dim('   ' + detail));
     out.push('');
     return out.join('\n');
 }