carthagent 0.0.0-stage → 1.0.7

package/tests/codegraph.test.mjs

@@ -0,0 +1,142 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync, utimesSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createCodeIndex } from '../lib/codegraph.mjs';
+
+const fixture = () => {
+  const dir = mkdtempSync(join(tmpdir(), 'codegraph-'));
+  mkdirSync(join(dir, 'src'), { recursive: true });
+  writeFileSync(join(dir, 'src', 'a.ts'), [
+    `import { helper } from './b';`,
+    `import './side';`,
+    `export function main() { helper(); thing.h(); }`,
+    `export class K { m() { helper(); } }`,
+    `export const arrow = () => helper();`,
+  ].join('\n'));
+  writeFileSync(join(dir, 'src', 'b.ts'), `export function helper() {}\n`);
+  writeFileSync(join(dir, 'src', 'side.ts'), `export const sideEffect = 1;\n`);
+  writeFileSync(join(dir, 'src', 'c.py'), [
+    `import os`,
+    `def f():`,
+    `    helper()`,
+    `class K:`,
+    `    def m(self):`,
+    `        main()`,
+  ].join('\n'));
+  writeFileSync(join(dir, 'src', 'd.rs'), [
+    `fn f() { g(); obj.h(); }`,
+    `struct S {}`,
+    `impl S { fn m(&self) { main(); } }`,
+  ].join('\n'));
+  return dir;
+};
+
+test('codegraph indexes definitions across languages', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir);
+  const stats = ix.stats();
+  assert.equal(stats.files, 5);
+  assert.equal(stats.parseErrors, 0);
+
+  const helper = ix.definition('helper');
+  assert.equal(helper.length, 1);
+  assert.equal(helper[0].file, 'src/b.ts');
+  assert.equal(helper[0].kind, 'function');
+
+  // Qualified lookup finds methods under their container in every language.
+  const methods = ix.definition('K.m');
+  assert.equal(methods.length, 2);
+  assert.deepEqual(new Set(methods.map(d => d.container)), new Set(['K']));
+});
+
+test('codegraph traces callers and callees', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir);
+
+  const callers = ix.callers('helper').map(c => c.caller?.name).sort();
+  assert.deepEqual(callers, ['arrow', 'f', 'm', 'main'].sort());
+  // Member calls record the method name.
+  assert.ok(ix.callers('h').length >= 2);
+
+  const callees = ix.callees('main').map(c => c.name).sort();
+  assert.deepEqual(callees, ['h', 'helper']);
+});
+
+test('codegraph resolves import edges both directions', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir);
+
+  assert.deepEqual(ix.imports('src/a.ts').sort(), ['./b', './side']);
+  const importers = ix.importers('src/b.ts');
+  assert.equal(importers.length, 1);
+  assert.equal(importers[0].file, 'src/a.ts');
+  assert.deepEqual(ix.importers('src/side.ts'), [{ file: 'src/a.ts', spec: './side' }]);
+});
+
+test('codegraph outlines a file and finds symbols by substring', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir);
+
+  assert.deepEqual(ix.outline('src/b.ts').map(d => d.name), ['helper']);
+  const outline = ix.outline('src/a.ts').map(d => d.name);
+  assert.deepEqual(outline, ['main', 'K', 'm', 'arrow']);
+
+  const matches = ix.symbols('arr');
+  assert.equal(matches.length, 1);
+  assert.equal(matches[0].displayName, 'arrow');
+});
+
+test('codegraph refreshes incrementally on mtime change', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir);
+  assert.equal(ix.definition('added').length, 0);
+
+  writeFileSync(join(dir, 'src', 'b.ts'), `export function helper() {}\nexport function added() { helper(); }\n`);
+  const future = new Date(Date.now() + 2000);
+  utimesSync(join(dir, 'src', 'b.ts'), future, future);
+  await ix.refresh();
+
+  assert.equal(ix.definition('added').length, 1);
+  assert.ok(ix.callers('helper').some(c => c.caller?.name === 'added'));
+
+  rmSync(join(dir, 'src', 'c.py'));
+  await ix.refresh();
+  assert.equal(ix.stats().files, 4);
+  assert.equal(ix.outline('src/c.py').length, 0);
+});
+
+test('codegraph callees distinguishes same-named methods in one file', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  writeFileSync(join(dir, 'src', 'two.ts'), [
+    `class A { run() { alpha(); } }`,
+    `class B { run() { beta(); } }`,
+  ].join('\n'));
+  const ix = await createCodeIndex(dir);
+
+  assert.deepEqual(ix.callees('A.run').map(c => c.name), ['alpha']);
+  assert.deepEqual(ix.callees('B.run').map(c => c.name), ['beta']);
+});
+
+test('codegraph drops stale entries when a file grows past maxBytes', async t => {
+  const dir = fixture();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const ix = await createCodeIndex(dir, { maxBytes: 80 });
+
+  writeFileSync(join(dir, 'src', 'small.ts'), `export function tiny() { helper(); }\n`);
+  await ix.refresh();
+  assert.equal(ix.definition('tiny').length, 1);
+
+  writeFileSync(join(dir, 'src', 'small.ts'), `export function tiny() { helper(); } ${'// pad'.repeat(30)}\n`);
+  const future = new Date(Date.now() + 2000);
+  utimesSync(join(dir, 'src', 'small.ts'), future, future);
+  await ix.refresh();
+  assert.equal(ix.definition('tiny').length, 0);
+});

package/tests/delivery-context.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, writeFileSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { deliveryRecovery, archivalGroups, replaceArchivedGroups, contextMetrics, jsonBytes, designReceipt } from '../lib/delivery-context.mjs';
+import { archiveContext } from '../lib/context-archive.mjs';
+import { approveFixture } from './helpers/tested-design.mjs';
+import { planningStatus } from '../lib/planning.mjs';
+import { fingerprint, revisePlan } from '../lib/delivery.mjs';
+import { recoveryMessages } from '../lib/delivery-context.mjs';
+import { DELIVERY_INVARIANTS, deliveryPhaseGuidance } from '../lib/delivery-guidance.mjs';
+const plan = { goal:'Exact obligations',assumptions:[],artifacts:['.'],outputs:['release.txt'],steps:['Implement'],acceptance:[{requirement:'Keep every cent exactly',checks:['required_money']}],checks:[{id:'required_money',kind:'test',argv:['node','verify.mjs'],timeoutSeconds:5}] };
+function turn(id,name='delivery_status',isError=false){return [{role:'assistant',stopReason:'toolUse',timestamp:1,content:[{type:'thinking',thinking:'x'.repeat(3000),thinkingSignature:'unchanged'},{type:'toolCall',id,name,arguments:{plan:'x'.repeat(5000)}}]},{role:'toolResult',toolCallId:id,toolName:name,isError,content:[{type:'text',text:'x'.repeat(5000)}]}];}
+test('outbound archives preserve users/failures/pairing and leave stored history untouched',t=>{
+ const root=mkdtempSync(join(tmpdir(),'context-'));t.after(()=>rmSync(root,{recursive:true,force:true}));
+ const messages=[{role:'user',content:'Keep this exact request'},...turn('1'),...turn('2','delivery_check',true),...turn('3','write'),...turn('4'),...turn('5'),...turn('6')];const before=structuredClone(messages);
+ const groups=archivalGroups(messages,{allow:true});assert.deepEqual(groups.map(g=>g.start),[1,7]);
+ for(const group of groups)group.archive=archiveContext(root,join(root,'.harness'),group.messages);
+ const projected=replaceArchivedGroups(messages,groups);assert.deepEqual(messages,before);assert.equal(projected[0].content,messages[0].content);assert.ok(projected.some(m=>m.isError));assert.ok(projected.some(m=>m.role==='assistant'&&m.content.some(c=>c.name==='write')));assert.ok(jsonBytes(projected)<jsonBytes(messages)*.75);
+ for(const group of groups)assert.deepEqual(JSON.parse(readFileSync(group.archive.path)),group.messages);
+ writeFileSync(groups[0].archive.path,'corrupted');assert.throws(()=>archiveContext(root,join(root,'.harness'),groups[0].messages),/mismatch/);
+ const linked=join(root,'linked');symlinkSync(join(root,'.harness'),linked,'dir');assert.throws(()=>archiveContext(root,linked,{test:true}),/symlink/i);
+ assert.deepEqual(archivalGroups(messages,{allow:false}),[]);
+ const orphan=turn('7');orphan[1].toolCallId='wrong';assert.deepEqual(archivalGroups(orphan,{allow:true,keepRecent:0}),[]);
+ const blocked=turn('8');blocked[1].content=[{type:'text',text:JSON.stringify({findings:[{severity:'blocking',description:'must remain'}]})}];assert.deepEqual(archivalGroups(blocked,{allow:true,keepRecent:0}),[]);
+});
+test('recovery preserves exact obligations, failed evidence/blockers; cannot revive stale approval',t=>{
+ const cwd=mkdtempSync(join(tmpdir(),'context-state-'));t.after(()=>rmSync(cwd,{recursive:true,force:true}));writeFileSync(join(cwd,'source'),'a');
+ const state={runId:'r',revision:1,plan:structuredClone(plan),evidence:{required_money:{passed:false,code:9,executedRevision:1,outputTail:'lost cent'}},status:'implementing',stepStatus:{}};approveFixture(state,cwd);state.planning.openFindings=[{id:'blocker',revision:1,severity:'blocking',description:'Do not forget'}];
+ const before=structuredClone(state),summary=deliveryRecovery(state);assert.deepEqual(summary.acceptance,plan.acceptance);assert.deepEqual(summary.checks,plan.checks);assert.deepEqual(summary.outputs,plan.outputs);assert.equal(summary.planning.openFindings[0].id,'blocker');assert.equal(summary.evidence.required_money.passed,false);assert.deepEqual(state,before);
+ writeFileSync(join(cwd,'source'),'b');assert.equal(planningStatus(state,fingerprint(cwd,['.'])).locked,true);
+ const revised=revisePlan(state,{assumptions:['new fact']},{cwd,reason:'Changed assumption',hash:fingerprint(cwd,['.'])});deliveryRecovery(revised);assert.equal(planningStatus(revised,fingerprint(cwd,['.'])).locked,true);assert.equal(revised.planning.openFindings[0].id,'blocker');
+});
+test('compact review receipt retains findings/limitations and metrics never copy secret payloads',()=>{
+ const receipt={runId:'r',walkthroughs:[{trace:'x'.repeat(10000)}],challenges:['long'],findings:[{description:'failure'}],limitations:['model authored']};const compact=designReceipt('review',receipt);assert.deepEqual(compact.findings,receipt.findings);assert.equal(compact.walkthroughCount,1);assert.ok(jsonBytes(compact)<jsonBytes(receipt)/10);
+ const payload={tools:[{function:{name:'read'}}],messages:[{role:'system',content:'SECRET'},{role:'assistant',reasoning_details:[{text:'秘密'}],content:'hi'},{role:'tool',content:'SECRET'}]};const m=contextMetrics(payload);assert.equal(Object.values(m.categories).reduce((a,b)=>a+b,0),m.totalBytes);assert.ok(m.categories.reasoning>0);assert.ok(m.categories.envelope>=0);assert.ok(!JSON.stringify(m).includes('SECRET'));
+});
+test('checkpoint is not repeated; compaction/revision restore exact obligations and current failures', () => {
+ const state={runId:'r',revision:1,plan:structuredClone(plan),status:'implementing',evidence:{required_money:{passed:false,code:9}},stepStatus:{}};
+ const summary=deliveryRecovery(state);
+ const first=recoveryMessages([],summary);
+ assert.equal(first.filter(m=>m.customType==='delivery-checkpoint').length,1);
+ assert.deepEqual(JSON.parse(first[0].content).acceptance,plan.acceptance);
+ const second=recoveryMessages(first,summary);
+ assert.equal(second.length,2); assert.equal(second[0],first[0]);
+ assert.equal(JSON.parse(second[1].content).evidence.required_money.passed,false);
+ const compacted=recoveryMessages([{role:'user',content:'summary without checkpoint'}],summary);
+ assert.deepEqual(JSON.parse(compacted[1].content).checks,plan.checks);
+ const changed=recoveryMessages(second,{...summary,revision:2,acceptance:[...summary.acceptance,{requirement:'New',checks:['required_money']}]});
+ assert.equal(changed.filter(m=>m.customType==='delivery-checkpoint').length,1);
+ assert.equal(JSON.parse(changed[0].content).acceptance.length,2);
+ assert.ok(DELIVERY_INVARIANTS.length<2000); assert.match(deliveryPhaseGuidance(null),/code_nav/);
+ assert.match(deliveryPhaseGuidance(state),/Design:/);
+ assert.match(deliveryPhaseGuidance({...state,planning:{approval:{}}}),/snapshot|delivery_review/);
+});
+test('outbound-only checkpoints retain their position until their history anchor disappears', () => {
+ const summary=deliveryRecovery({runId:'r',revision:1,plan,status:'implementing',evidence:{}});
+ const cache={}; const anchor={role:'toolResult',toolCallId:'plan',content:'created'};
+ const first=recoveryMessages([anchor],summary,cache);
+ const checkpoint=first[1];
+ const second=recoveryMessages([anchor,{role:'assistant',content:'next'}],summary,cache);
+ assert.equal(second[1],checkpoint);
+ const third=recoveryMessages([{role:'user',content:'compacted'}],summary,cache);
+ assert.notEqual(third[1],checkpoint); assert.deepEqual(JSON.parse(third[1].content).acceptance,plan.acceptance);
+});

package/tests/delivery-review.test.mjs

@@ -0,0 +1,139 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync, readFileSync, symlinkSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname, basename } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { captureDeliveryReview, recordDeliveryReview } from '../lib/delivery-review.mjs';
+import { evidenceIdentity, fingerprint, completionIssues, revisePlan } from '../lib/delivery.mjs';
+
+function fixture(t) {
+  const cwd = mkdtempSync(join(tmpdir(), 'delivery review café '));
+  t.after(() => rmSync(cwd, { recursive: true, force: true }));
+  const git = args => execFileSync('git', args, { cwd, stdio: 'pipe' });
+  writeFileSync(join(cwd, '.gitignore'), '.harness/\n');
+  writeFileSync(join(cwd, 'app.mjs'), 'export const amount = 1;\n');
+  git(['init', '-q']); git(['add', '.']);
+  git(['-c', 'user.name=Test', '-c', 'user.email=test@localhost', 'commit', '-qm', 'Baseline']);
+  writeFileSync(join(cwd, 'app.mjs'), 'export const amount = 2;\n');
+  writeFileSync(join(cwd, 'new.mjs'), 'export const result = 2;\n');
+  const check = { id: 'unit', kind: 'test', argv: ['node', '--test'], timeoutSeconds: 10 };
+  const state = { runId: 'a', revision: 1, plan: { goal: 'Repair money', artifacts: ['.'], steps: [{ id: 'fix', title: 'Fix' }], acceptance: [{ requirement: 'Correct amount', checks: ['unit'] }], checks: [check] }, evidence: {}, stepStatus: { step0: 'done' } };
+  state.evidence.unit = { ...evidenceIdentity(state, check), passed: true, fingerprint: fingerprint(cwd, ['.']) };
+  const params = captureId => ({ captureId, coverage: [{ requirement: 'Correct amount', assertions: 'app amount equals 2' }], probes: ['node assert amount: 2, passed'], findings: [], limitations: ['Fixture assertion review'] });
+  return { cwd, state, params, dir: join(cwd, '.harness', 'review') };
+}
+
+test('review captures real diff/new files and binds complete assertions to final snapshot', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  assert.match(capture.diff, /-export const amount = 1/);
+  assert.match(capture.diff, /\+export const amount = 2/);
+  assert.match(capture.diff, /new.mjs/);
+  assert.equal(readFileSync(capture.path, 'utf8'), capture.diff);
+  assert.throws(() => recordDeliveryReview(state, cwd, { ...params(capture.id), coverage: [] }), /every exact/);
+  assert.throws(() => recordDeliveryReview(state, cwd, { ...params(capture.id), probes: [] }), /boundary/);
+  assert.match(capture.diff, /export const result = 2/);
+  recordDeliveryReview(state, cwd, params(capture.id));
+  assert.deepEqual(state.reviewEvidence.evidence, state.evidence);
+  assert.ok(Object.values(completionIssues(state, cwd, fingerprint(cwd, ['.']))).every(a => !a.length));
+  const revised = revisePlan(state, { assumptions: ['Additional investigation'] }, { cwd, hash: fingerprint(cwd, ['.']), reason: 'Refine' });
+  assert.equal(revised.reviewEvidence, undefined);
+  assert.ok(revised.revisions[0].reviewEvidence);
+  writeFileSync(join(cwd, 'new.mjs'), 'changed');
+  assert.throws(() => recordDeliveryReview(state, cwd, params(capture.id)), /stale/);
+  assert.equal(completionIssues(state, cwd, fingerprint(cwd, ['.'])).review.length, 1);
+});
+
+test('findings survive empty submissions, recapture, restart and plan revisions until explicitly resolved', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  let capture = await captureDeliveryReview(state, cwd, dir);
+  recordDeliveryReview(state, cwd, params(capture.id));
+  const rejected = recordDeliveryReview(state, cwd, { ...params(capture.id), findings: ['Movement integration untested'] });
+  assert.equal(rejected.recorded, false);
+  assert.equal(state.reviewEvidence, undefined);
+  assert.match(completionIssues(state, cwd, fingerprint(cwd, ['.'])).review[0], /Movement integration/);
+  const restored = JSON.parse(JSON.stringify(state));
+  capture = await captureDeliveryReview(restored, cwd, dir);
+  assert.equal(recordDeliveryReview(restored, cwd, { ...params(capture.id), limitations: ['Movement integration untested'] }).recorded, false);
+  const revised = revisePlan(restored, { assumptions: ['More evidence needed'] }, { cwd, hash: fingerprint(cwd, ['.']), reason: 'Refine' });
+  assert.equal(revised.reviewFindings[0].id, rejected.unresolvedFindings[0].id);
+  assert.throws(() => recordDeliveryReview(restored, cwd, { ...params(capture.id), resolutions: [{ id: 'invented', change: 'fixed', evidence: 'test passed' }] }), /Unknown/);
+  recordDeliveryReview(restored, cwd, { ...params(capture.id), resolutions: [{ id: rejected.unresolvedFindings[0].id, change: 'Added input-to-state integration probe', evidence: 'W at five headings matches camera-forward displacement' }] });
+  assert.ok(restored.reviewEvidence.findingHistory[0].resolution);
+  const retry = { ...params(capture.id), findings: ['Movement integration untested'], resolutions: [{ id: rejected.unresolvedFindings[0].id, change: 'Added input-to-state integration probe', evidence: 'W at five headings matches camera-forward displacement' }] };
+  recordDeliveryReview(restored, cwd, retry);
+  assert.equal(restored.reviewFindings.length, 1);
+  recordDeliveryReview(restored, cwd, retry);
+  assert.equal(restored.reviewFindings.length, 1);
+  assert.deepEqual(completionIssues(restored, cwd, fingerprint(cwd, ['.'])).review, []);
+});
+
+test('explicit unverified coverage blocks acceptance even with passing checks', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  const p = params(capture.id); p.coverage[0].status = 'unverified';
+  assert.equal(recordDeliveryReview(state, cwd, p).recorded, false);
+  assert.match(state.reviewFindings[0].description, /Acceptance gap/);
+  assert.equal(recordDeliveryReview(state, cwd, params(capture.id)).recorded, false);
+});
+
+test('outcome coverage binds actual linked receipts and retains missing user behavior', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  state.plan.outcomes = [{ id:'launch',requirement:'Correct amount',entrypoint:'node app.mjs',observable:'Output is 2',substitutions:[],missedFailure:'Internal function works but launch fails',checks:['unit'] }];
+  const capture = await captureDeliveryReview(state,cwd,dir);
+  assert.throws(()=>recordDeliveryReview(state,cwd,params(capture.id)),/exactly one outcome/);
+  const outcome = {id:'launch',check:'missing',observation:'printed 2',challenge:'bad input rejected',status:'demonstrated'};
+  assert.throws(()=>recordDeliveryReview(state,cwd,{...params(capture.id),outcomes:[outcome]}),/linked check receipt/);
+  outcome.check='unit';outcome.status='unverified';outcome.observation='Only alternate test mode exercised';
+  assert.equal(recordDeliveryReview(state,cwd,{...params(capture.id),outcomes:[outcome]}).recorded,false);
+  outcome.status='demonstrated';outcome.observation='Normal launch printed 2';
+  const result=recordDeliveryReview(state,cwd,{...params(capture.id),outcomes:[outcome],resolutions:[{id:state.reviewFindings[0].id,change:'Executed normal launch',evidence:'Launch printed 2 and rejected malformed input'}]});
+  assert.deepEqual(result.outcomes[0].receipt,state.evidence.unit);
+});
+
+test('capture includes new unicode source contents but excludes unignored dependency and generated trees', async t => {
+  const { cwd, state, dir } = fixture(t);
+  for (const name of ['.venv', 'node_modules', 'artifacts', '.harness']) {
+    mkdirSync(join(cwd, name), { recursive: true });
+    writeFileSync(join(cwd, name, 'noise.txt'), 'DO_NOT_CAPTURE_DEPENDENCY_CONTENT');
+  }
+  writeFileSync(join(cwd, 'new café.txt'), 'critical integration assertion');
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  assert.match(capture.diff, /critical integration assertion/);
+  assert.doesNotMatch(capture.diff, /DO_NOT_CAPTURE_DEPENDENCY_CONTENT|noise.txt/);
+});
+
+test('review rejects modified receipts, stale coverage, and cancellation', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  state.requirementRevisions = { 'Correct amount': 2 };
+  assert.throws(() => recordDeliveryReview(state, cwd, params(capture.id)), /fresh checks/);
+  delete state.requirementRevisions;
+  writeFileSync(capture.path, 'forged diff');
+  assert.throws(() => recordDeliveryReview(state, cwd, params(capture.id)), /modified/);
+  await assert.rejects(captureDeliveryReview(state, cwd, dir, AbortSignal.abort()), /cancelled/);
+});
+
+test('review accepts filesystem aliases of the Git root but rejects ancestor repositories', async t => {
+  const { cwd, state } = fixture(t);
+  const parent = mkdtempSync(join(tmpdir(), 'review-alias-'));
+  t.after(() => rmSync(parent, { recursive: true, force: true }));
+  const link = join(parent, 'alias');
+  symlinkSync(dirname(cwd), link, process.platform === 'win32' ? 'junction' : 'dir');
+  const alias = join(link, basename(cwd));
+  const capture = await captureDeliveryReview(state, alias, join(alias, '.harness', 'review'));
+  assert.match(capture.diff, /diff --git/);
+  const child = join(cwd, 'nested');
+  mkdirSync(child);
+  await assert.rejects(captureDeliveryReview(state, child, join(child, '.harness')), /workspace Git root/);
+});
+
+test('large diffs retain full receipt instead of silently using output tail', async t => {
+  const { cwd, state, dir } = fixture(t);
+  writeFileSync(join(cwd, 'app.mjs'), 'export const amount = 2;\n' + '// meaningful review line\n'.repeat(900));
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  assert.equal(capture.truncated, true);
+  assert.ok(readFileSync(capture.path, 'utf8').length > 12000);
+  assert.match(capture.diff, /diff --git/);
+});