@0xcraft/powershot 1.1.4 → 1.2.0

package/dist/selftest.js

@@ -35,7 +35,7 @@ import { dirname, join, sep } from 'node:path';
 import { runTool } from './judges/tools.js';
 import { codeQuality } from './report/codequality.js';
 import { viewer } from './report/viewer.js';
-import { absorbDelegated, delegateBrief } from './delegate.js';
+import { absorbDelegated, buildDelegateTask, delegateBrief } from './delegate.js';
 import { TARGETS, findTarget } from './agents.js';
 import { PACKS, packFor, parseIsolated } from './lang/packs.js';
 import { isPhantom, pythonManifest, localModules } from './lang/python-deps.js';
@@ -52,7 +52,7 @@ import { summarizeRun } from './report/summary.js';
 import { wrap } from './report/terminal.js';
 import { highlight, isJsx } from './report/highlight.js';
 import { buildGround, normalizeName, readEnvManifest, relPath } from './ground.js';
-import { implementationFingerprint, reinventionScope, typescriptImplementationFingerprint } from './reinvention.js';
+import { exportedDeclarations, implementationFingerprint, reinventionScope, typescriptImplementationFingerprint, } from './reinvention.js';
 import { incompleteReasons } from './bench.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from './package-meta.js';
 import { addedLinesFromPatch, inlineMarker, parseReviewFindings, reconcileInlineComments, selectInlineComments, syncInlineComments, } from './github/inline-comments.js';
@@ -70,6 +70,7 @@ function ground(files, deps = []) {
         const lineCount = f.after.split('\n').length;
         const c = {
             path: f.path,
+            beforePath: f.beforePath,
             added: new Set(Array.from({ length: lineCount }, (_, i) => i + 1)),
             before: f.before,
         };
@@ -77,7 +78,9 @@ function ground(files, deps = []) {
         entries.push({
             sf,
             changed: c,
-            before: f.before === undefined ? undefined : beforeProject.createSourceFile('/before/' + f.path, f.before, { overwrite: true }),
+            before: f.before === undefined
+                ? undefined
+                : beforeProject.createSourceFile('/before/' + (f.beforePath ?? f.path), f.before, { overwrite: true }),
             typed: true,
         });
     }
@@ -85,17 +88,18 @@ function ground(files, deps = []) {
     for (const sf of project.getSourceFiles()) {
         const rel = sf.getFilePath().slice(root.length + 1);
         const input = files.find((file) => file.path === rel);
-        for (const [name, decls] of sf.getExportedDeclarations()) {
-            const decl = decls[0];
-            if (!decl)
-                continue;
-            const fingerprint = typescriptImplementationFingerprint(decl);
+        for (const { name, node: decl } of exportedDeclarations(sf)) {
+            const fingerprint = typescriptImplementationFingerprint(decl, rel);
             if (!fingerprint)
                 continue;
             const key = normalizeName(name);
             const list = symbolIndex.get(key) ?? [];
-            const before = input?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + rel);
-            const existedInBase = (before?.getExportedDeclarations().get(name) ?? []).some((baseDeclaration) => typescriptImplementationFingerprint(baseDeclaration) === fingerprint);
+            const beforePath = input?.beforePath ?? rel;
+            const before = input?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + beforePath);
+            const existedInBase = before && reinventionScope(root, beforePath) === reinventionScope(root, rel)
+                ? exportedDeclarations(before).some((baseDeclaration) => baseDeclaration.name === name &&
+                    typescriptImplementationFingerprint(baseDeclaration.node, beforePath) === fingerprint)
+                : false;
             list.push({
                 file: rel,
                 name,
@@ -134,6 +138,22 @@ async function checkAsync(name, fn) {
 function fires(v, g) {
     return v.run(g).length > 0;
 }
+async function javascriptReinvention(candidate) {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-javascript-reinvention-')));
+    try {
+        mkdirSync(join(dir, 'lib'), { recursive: true });
+        mkdirSync(join(dir, 'utils'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["lib/**/*.mjs","utils/**/*.mjs"]}');
+        writeFileSync(join(dir, 'lib/normalize.mjs'), 'export function normalizePayload(value) { return value.trim() }\n');
+        writeFileSync(join(dir, 'utils/normalize.mjs'), candidate);
+        const g = await buildGround(dir, [{ path: 'utils/normalize.mjs', added: new Set([1]) }]);
+        return fires(reinvented, g);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
 console.log('\nphantom-dep');
 check('fires on an import that is not a declared dependency', () => {
     const g = ground([{ path: 'a.ts', after: "import ky from 'ky'\nexport const x = ky\n" }], ['zod']);
@@ -159,6 +179,11 @@ check('resolves a scoped subpath to its package', () => {
     assert.equal(fires(phantomDep, g), false);
 });
 console.log('\nreinvented');
+check('keeps every public alias for one exported declaration', () => {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const source = project.createSourceFile('/aliases.mjs', 'function helper(value) { return value }\nexport { helper, helper as normalizePayload }\n');
+    assert.deepEqual(exportedDeclarations(source).map((declaration) => declaration.name).sort(), ['helper', 'normalizePayload']);
+});
 check('fires when a helper already exists elsewhere', () => {
     const existing = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
     const g = ground([
@@ -169,6 +194,75 @@ check('fires when a helper already exists elsewhere', () => {
     assert.ok(found.length >= 1, 'expected a duplication finding');
     assert.equal(found[0].confidence, 'firm'); // heuristic, never claims `proven`
 });
+await checkAsync('fires on an exact JavaScript helper already present in the base', async () => {
+    assert.equal(await javascriptReinvention('export function normalizePayload(value) { return value.trim() }\n'), true);
+});
+await checkAsync('silent on a same-name JavaScript helper with different behavior', async () => {
+    assert.equal(await javascriptReinvention('export function normalizePayload(value) { return JSON.stringify(value) }\n'), false);
+});
+check('binds an implementation fingerprint to its import source', () => {
+    const existing = [
+        "import { transform } from './alpha.js'",
+        'export function normalizePayload(value: string) { return transform(value) }',
+        '',
+    ].join('\n');
+    const same = ground([
+        { path: 'lib/existing.ts', before: existing, after: existing },
+        { path: 'lib/added.ts', after: existing },
+    ]);
+    const different = ground([
+        { path: 'lib/existing.ts', before: existing, after: existing },
+        { path: 'lib/added.ts', after: existing.replace("'./alpha.js'", "'./beta.js'") },
+    ]);
+    assert.equal(fires(reinvented, same), true);
+    assert.equal(fires(reinvented, different), false);
+});
+check('binds an implementation fingerprint to referenced module locals', () => {
+    const source = (factor) => [
+        'const FACTOR = ' + factor,
+        'export function scalePayload(value: number) { return value * FACTOR }',
+        '',
+    ].join('\n');
+    const same = ground([
+        { path: 'lib/existing.ts', before: source(2), after: source(2) },
+        { path: 'lib/added.ts', after: source(2) },
+    ]);
+    const different = ground([
+        { path: 'lib/existing.ts', before: source(2), after: source(2) },
+        { path: 'lib/added.ts', after: source(3) },
+    ]);
+    assert.equal(fires(reinvented, same), true);
+    assert.equal(fires(reinvented, different), false);
+});
+check('qualifies relative imports by their source directory', () => {
+    const source = [
+        "import { transform } from './transform.js'",
+        'export function normalizePayload(value: string) { return transform(value) }',
+        '',
+    ].join('\n');
+    const sameDirectory = ground([
+        { path: 'lib/existing.ts', before: source, after: source },
+        { path: 'lib/added.ts', after: source },
+    ]);
+    const differentDirectory = ground([
+        { path: 'alpha/existing.ts', before: source, after: source },
+        { path: 'beta/added.ts', after: source },
+    ]);
+    assert.equal(fires(reinvented, sameDirectory), true);
+    assert.equal(fires(reinvented, differentDirectory), false);
+});
+check('binds an implementation fingerprint to TypeScript reference directives', () => {
+    const source = (target) => [
+        '/// <reference path="' + target + '" />',
+        'export function normalizePayload(value: Payload) { return value }',
+        '',
+    ].join('\n');
+    const g = ground([
+        { path: 'lib/existing.ts', before: source('./alpha.d.ts'), after: source('./alpha.d.ts') },
+        { path: 'lib/added.ts', after: source('./beta.d.ts') },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
 check('silent when matching helpers are both new in the change', () => {
     const added = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
     const g = ground([
@@ -336,11 +430,33 @@ check('fires when an early-return guard disappears', () => {
     assert.equal(found.length, 1);
     assert.match(found[0].title, /!inv\.customer/);
 });
+check('fires when a JavaScript early-return guard disappears', () => {
+    const before = 'export function release(slot) {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.mjs', after, before }])), true);
+});
+check('silent when JavaScript moves the guarded operation into a helper', () => {
+    const before = 'export function release(slot) {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = [
+        'export function release(slot) { return closeIfReady(slot) }',
+        'function closeIfReady(slot) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.mjs', after, before }])), false);
+});
 check('fires when a throwing guard disappears', () => {
     const before = 'export function pay(a: any) {\n  if (a <= 0) { throw new Error("bad") }\n  return a\n}\n';
     const after = 'export function pay(a: any) {\n  return a\n}\n';
     assert.equal(fires(droppedGuard, ground([{ path: 'pay.ts', after, before }])), true);
 });
+check('fires inside an arrow function', () => {
+    const before = 'export const release = (slot: any) => {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = 'export const release = (slot: any) => {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), true);
+});
 check('silent when the guard is kept, even if reformatted', () => {
     const before = 'export function close(inv: any) {\n  if (!inv.customer) return null\n  return inv.total\n}\n';
     const after = 'export function close(inv: any) {\n  if (!inv.customer)\n    return null\n  return inv.total * 2\n}\n';
@@ -353,6 +469,258 @@ check('silent when a rewrite respells the same guard for a new type', () => {
     const after = 'export function check(pool: number) {\n  if (pool === 0) return null\n  return pool\n}\n';
     assert.equal(fires(droppedGuard, ground([{ path: 'c.ts', after, before }])), false);
 });
+check('silent when the callable contract narrows with the removed guard', () => {
+    const before = [
+        'export function release(slot: { close(): boolean } | null) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export function release(slot: { close(): boolean }) {',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the callable owner contract narrows with the removed guard', () => {
+    const before = [
+        'export class Batch<T extends { close(): boolean } | null> {',
+        '  release(slot: T) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export class Batch<T extends { close(): boolean }> {',
+        '  release(slot: T) {',
+        '    return slot.close()',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('fires when an unchanged outer branch still contains the guard-only deletion', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), true);
+});
+check('silent when an outer branch is strengthened as the inner guard is removed', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('if (enabled)', 'if (enabled && slot)')
+        .replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a sibling statement changes as a nested guard is removed', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  observe(slot)',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('observe(slot)', 'ensureSlot(slot)')
+        .replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when an import binding changes as its guard is removed', () => {
+    const before = [
+        "import type { Slot } from './alpha.js'",
+        'export function release(slot: Slot | null) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace("'./alpha.js'", "'./beta.js'")
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a module type changes as its guard is removed', () => {
+    const before = [
+        'type Slot = { close(): boolean } | null',
+        'export function release(slot: Slot) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace(' | null', '')
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the same guard still protects the callable', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  if (slot.shouldClose()) {',
+        '    if (!slot.ready()) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot.ready()) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('matches remaining guards by tokens rather than comments', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (!slot /* already checked */) return false',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the guarded operation moves behind a helper', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export function release(slot: any) {',
+        '  return closeIfReady(slot)',
+        '}',
+        'function closeIfReady(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when an already-called helper absorbs the guard', () => {
+    const before = [
+        'function closeSlot(slot: any) { return slot.close() }',
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return closeSlot(slot)',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'function closeSlot(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        'export function release(slot: any) {',
+        '  return closeSlot(slot)',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a nested callable binding changes with the guard deletion', () => {
+    const before = [
+        'export function release(slot: any, fallback: any) {',
+        '  function closeSlot(value = slot) { return value.close() }',
+        '  if (!slot) return false',
+        '  return closeSlot()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('value = slot', 'value = fallback')
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a guarded file is renamed as the guard is deleted', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'new/release.ts', beforePath: 'old/release.ts', after, before }])), false);
+});
+check('silent when another source is renamed to an unsupported suffix', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    const g = ground([{ path: 'release.ts', after, before }]);
+    g.inventory = [
+        ...g.changed,
+        {
+            path: 'notes/helper.txt',
+            beforePath: 'src/helper.ts',
+            added: new Set(),
+            before: 'export function closeSlot(slot: any) { return slot.close() }\n',
+        },
+    ];
+    assert.equal(fires(droppedGuard, g), false);
+});
+check('silent when a TypeScript reference directive changes with the guard deletion', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    const refs = (target) => '/// <reference path="' + target + '" />\nexport const stable = true\n';
+    const g = ground([
+        { path: 'release.ts', after, before },
+        { path: 'bindings.ts', after: refs('./beta.d.ts'), before: refs('./alpha.d.ts') },
+    ]);
+    assert.equal(fires(droppedGuard, g), false);
+});
+check('silent when a branch only conditionally returns', () => {
+    const before = [
+        'export function release(slot: any, force: boolean) {',
+        '  if (!slot.ready()) {',
+        '    if (force) return false',
+        '    slot.recordMiss()',
+        '  }',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = 'export function release(slot: any, force: boolean) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the removed conditional had an else branch', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  else slot.recordReady()',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
 check('silent when the guard became obsolete with the code it protected', () => {
     // found by bench: formatWeight moved from ounces to grams, so the old guards
     // referenced locals the rewritten function no longer has
@@ -709,6 +1077,7 @@ check('Git paths are read as NUL-delimited data and passed back literally', () =
         const changes = collectChanges(dir, {});
         const moved = changes.find((change) => change.path === renamed);
         assert.ok(moved?.before?.includes('before9'));
+        assert.equal(moved?.beforePath, tracked);
         assert.deepEqual([...moved.added], [10]);
         assert.ok(changes.some((change) => change.path === untracked));
     }
@@ -716,6 +1085,45 @@ check('Git paths are read as NUL-delimited data and passed back literally', () =
         rmSync(dir, { recursive: true, force: true });
     }
 });
+await checkAsync('deleted and policy-waived source stays in guard proof inventory', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-deleted-proof-')));
+    const run = (...args) => {
+        execFileSync('git', args, { cwd: dir, stdio: ['ignore', 'ignore', 'pipe'] });
+    };
+    try {
+        run('init', '-q', '.');
+        run('config', 'user.email', 'tests@powershot.invalid');
+        run('config', 'user.name', 'PowerShot Tests');
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        mkdirSync(join(dir, 'ignored'), { recursive: true });
+        const guarded = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+        const helper = 'export function closeSlot(slot: any) { return slot.close() }\n';
+        writeFileSync(join(dir, 'src/release.ts'), guarded);
+        writeFileSync(join(dir, 'ignored/helper.ts'), helper);
+        run('add', '.');
+        run('commit', '-qm', 'base');
+        writeFileSync(join(dir, 'src/release.ts'), 'export function release(slot: any) {\n  return slot.close()\n}\n');
+        rmSync(join(dir, 'ignored/helper.ts'));
+        const changes = collectChanges(dir, {});
+        const deleted = changes.find((change) => change.path === 'ignored/helper.ts');
+        assert.equal(deleted?.deleted, true);
+        assert.equal(deleted?.before, helper);
+        assert.equal(deleted?.added.size, 0);
+        const result = await review({
+            root: dir,
+            range: {},
+            config: { ...loadConfig(dir), ignore: ['ignored/**'] },
+            verifyOnly: true,
+            checks: ['dropped-guard'],
+        });
+        assert.equal(result.findings.some((finding) => finding.check === 'dropped-guard'), false);
+        const deletedPlan = result.plan?.items().find((item) => item.path === 'ignored/helper.ts');
+        assert.equal(deletedPlan?.disposition, 'waived');
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 check('lines split on either ending', () => {
     assert.deepEqual(splitLines('a\r\nb\nc'), ['a', 'b', 'c']);
     assert.equal(stripCR('a\r'), 'a');
@@ -767,9 +1175,14 @@ check('portable coverage is a verdict, but never masquerades as full semantic co
         filesReviewed: 1, deterministicChecks: 1, scopeDetails: unavailable,
     });
     assert.match(out, /No medium-or-higher deterministic findings\./);
-    assert.match(out, /1 file reviewed · 1 deterministic check · portable coverage/);
+    assert.match(out, /1 file reviewed · 1 deterministic check · portable oracle coverage/);
     assert.match(out, /1 reviewed file lacked type information and a reference graph/);
     assert.doesNotMatch(out, /not a verdict/);
+    const full = terminal([], {
+        subtitle: 'workspace', verified: 0, judged: 0, state: 'complete', notLookedAt: [],
+        coverage: 'full', filesReviewed: 2, filesChanged: 2, deterministicChecks: 3,
+    });
+    assert.match(full, /2\/2 changed files reviewed · 3 deterministic checks · full applicable-oracle coverage/);
     const selected = Array.from({ length: 20 }, (_, index) => ({
         path: 'web/file-' + index + '.ts',
         disposition: 'selected',
@@ -794,7 +1207,7 @@ check('portable coverage is a verdict, but never masquerades as full semantic co
         },
     }));
     assert.match(md, /✅ \*\*No medium-or-higher deterministic findings\*\*/);
-    assert.match(md, /20 files reviewed · 19 deterministic checks · portable coverage/);
+    assert.match(md, /20\/36 changed files reviewed · 19 deterministic checks · portable oracle coverage/);
     assert.match(md, /Model review was disabled \(`verify-only`\)\./);
     assert.match(md, /<summary>Coverage details<\/summary>/);
     const rendered = md.replace(/\\/g, '');
@@ -1550,6 +1963,16 @@ check('the public action persists judge answers and publishes only a verdict', (
     assert.match(action, /m\.coverage === "full" \|\| m\.coverage === "portable" \? m\.coverage : "unknown"/);
     assert.match(action, /Approve a clean review[\s\S]+steps\.review\.outputs\.coverage == 'full'/);
 });
+check('the public action keeps every pull request write inside the base repository', () => {
+    const action = readFileSync(join(process.cwd(), 'action.yml'), 'utf8');
+    for (const name of ['Post inline comments', 'Comment on the pull request', 'Approve a clean review']) {
+        const start = action.indexOf('    - name: ' + name);
+        const end = action.indexOf('\n    - name: ', start + 1);
+        const step = action.slice(start, end === -1 ? undefined : end);
+        assert.ok(start >= 0, name + ' step is missing');
+        assert.match(step, /github\.event\.pull_request\.head\.repo\.full_name == github\.repository/, name);
+    }
+});
 check('published CI examples preserve one verdict and its exit status', () => {
     const action = readFileSync(join(process.cwd(), 'examples', 'github-actions', 'action.yml'), 'utf8');
     const github = readFileSync(join(process.cwd(), 'examples', 'github-actions', 'cli.yml'), 'utf8');
@@ -1589,10 +2012,11 @@ check('the viewer labels a complete portable session', () => {
     const html = viewer([], {
         id: 'portable', target: 'workspace', started: '2026-01-01T10:00:00Z',
         state: 'complete', notLookedAt: [], coverage: 'portable',
-        verifyOnly: true, minSeverity: 'medium', filesReviewed: 1, deterministicChecks: 2,
+        verifyOnly: true, minSeverity: 'medium', filesReviewed: 1, filesChanged: 3,
+        deterministicChecks: 2,
         scopeDetails: ['1 reviewed file lacked type information'],
     });
-    assert.match(html, /1 file reviewed · 2 deterministic checks · portable coverage/);
+    assert.match(html, /1\/3 changed files reviewed · 2 deterministic checks · portable oracle coverage/);
     assert.match(html, /No medium-or-higher deterministic findings\./);
     assert.match(html, /<summary>Coverage details<\/summary>/);
 });
@@ -1625,9 +2049,11 @@ check('delegate --checks selects only the requested judging brief', () => {
         provider: 'anthropic', model: 'm', verifiers: ['*'], judges: ['*'],
         minSeverity: 'low', ignore: [], coverage: 'portable', promptCache: true,
     };
-    const brief = delegateBrief(ground([{ path: 'a.ts', after: 'export const a = 1\n' }]), cfg, {
-        checks: ['intent'], intent: 'add a',
-    });
+    const task = buildDelegateTask(ground([{ path: 'a.ts', after: 'export const a = 1\n' }]), cfg, [{
+            path: 'a.ts', disposition: 'selected', bytes: 19, addedLines: 1,
+            language: 'typescript', checks: [],
+        }], { checks: ['intent'], intent: 'add a' });
+    const brief = delegateBrief(task);
     assert.match(brief, /## Judge: intent/);
     assert.doesNotMatch(brief, /## Judge: plausible-logic/);
 });
@@ -1782,6 +2208,17 @@ check('a finding is matched past a line that moved under it', () => {
     assert.equal(Session.compare(at(12), at(22)).remaining.length, 1);
     rmSync(dir, { recursive: true, force: true });
 });
+check('a finished session preserves the reviewed and changed file counts', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'psh-scope-session-'));
+    const session = Session.create(dir, 'workspace');
+    session.saveReport([], {
+        state: 'complete', notLookedAt: [], filesReviewed: 2, filesChanged: 5,
+    });
+    const reopened = Session.open(dir, session.id);
+    assert.equal(reopened?.report?.filesReviewed, 2);
+    assert.equal(reopened?.report?.filesChanged, 5);
+    rmSync(dir, { recursive: true, force: true });
+});
 check('partial sessions cannot be compared or rendered as clean', () => {
     const dir = mkdtempSync(join(tmpdir(), 'psh-partial-session-'));
     const partial = Session.create(dir, 'workspace');
@@ -3067,6 +3504,7 @@ check('CLI rejects selections that would otherwise run nothing and report clean'
         assert.equal(status(['scan', 'example.rb', '--verify-only', '--checks', 'plausible-logic', '--format', 'manifest']), 2);
         assert.equal(status(['delegate', '--checks', 'phantom-api']), 2);
         assert.equal(status(['delegate']), 0);
+        assert.equal(status(['delegate', '--format', 'manifest']), 2);
         assert.equal(existsSync(join(dir, '.powershot', 'sessions')), false, 'delegate must not create an unused session');
         assert.equal(status(['scan', 'example.rb', '--format', 'unknown']), 2);
         assert.equal(status(['scan', 'example.rb', '--report', 'unknown=report.txt']), 2);
@@ -3081,6 +3519,58 @@ check('CLI rejects selections that would otherwise run nothing and report clean'
         rmSync(dir, { recursive: true, force: true });
     }
 });
+check('delegate JSON uses the review selection contract and names excluded files', () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-delegate-plan-')));
+    const cli = join(process.cwd(), 'dist', 'cli.js');
+    try {
+        execFileSync('git', ['init', '-q', '.'], { cwd: dir });
+        writeFileSync(join(dir, 'source.rs'), 'pub fn value() -> i32 { 1 }\n');
+        writeFileSync(join(dir, 'notes.md'), '# Notes\n');
+        writeFileSync(join(dir, 'large.ts'), 'x'.repeat(512 * 1024 + 1));
+        const raw = execFileSync(process.execPath, [cli, 'delegate', '--format', 'json'], {
+            cwd: dir,
+            env: { ...process.env, CI: 'true' },
+            encoding: 'utf8',
+            maxBuffer: 2 * 1024 * 1024,
+        });
+        const task = JSON.parse(raw);
+        const files = new Map(task.files.map((file) => [file.path, file]));
+        assert.equal(task.schema, 'powershot.delegate/v1');
+        assert.equal(task.state, 'complete');
+        assert.equal(files.get('source.rs')?.disposition, 'selected');
+        assert.equal(files.get('notes.md')?.disposition, 'waived');
+        assert.match(files.get('notes.md')?.reason ?? '', /no parser/);
+        assert.equal(files.get('large.ts')?.disposition, 'waived');
+        assert.match(files.get('large.ts')?.reason ?? '', /over 512KB/);
+        assert.ok(task.judges.some((judge) => judge.name === 'plausible-logic' && judge.applicable));
+        assert.deepEqual([...new Set(task.units.flatMap((unit) => unit.files))], ['source.rs']);
+        assert.match(task.units[0]?.changes ?? '', /pub fn value/);
+        const markdown = execFileSync(process.execPath, [cli, 'delegate'], {
+            cwd: dir,
+            env: { ...process.env, CI: 'true' },
+            encoding: 'utf8',
+            maxBuffer: 2 * 1024 * 1024,
+        });
+        assert.match(markdown, /## Scope/);
+        assert.match(markdown, /source\.rs.*selected/);
+        assert.match(markdown, /notes\.md.*no parser/);
+        assert.match(markdown, /large\.ts.*over 512KB/);
+        assert.ok(markdown.length < 100_000, 'an oversized source leaked into the delegate brief');
+        assert.equal(existsSync(join(dir, '.powershot', 'sessions')), false, 'delegate must stay LLM-free');
+        rmSync(join(dir, 'source.rs'));
+        rmSync(join(dir, 'large.ts'));
+        const waivedOnly = JSON.parse(execFileSync(process.execPath, [cli, 'delegate', '--format', 'json'], { cwd: dir, env: { ...process.env, CI: 'true' }, encoding: 'utf8' }));
+        assert.equal(waivedOnly.state, 'complete');
+        assert.deepEqual(waivedOnly.files, [{
+                path: 'notes.md', disposition: 'waived', bytes: 8, addedLines: 2, language: 'other',
+                reason: 'no parser for this language',
+            }]);
+        assert.deepEqual(waivedOnly.units, []);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 check('a budget stop is partial and the manifest names what was not reviewed', () => {
     const b = new Budget({ requests: 1 }, 0);
     b.spend({ requests: 1 });