Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: cancel unmoved preservation without scanning original data (#12725)

[._.]/b25db7c86f17
diff --git a/scripts/lib/initialized_checkout_archive.py b/scripts/lib/initialized_checkout_archive.py
index 6354e367bc..2839fa9f71 100644
--- a/scripts/lib/initialized_checkout_archive.py
+++ b/scripts/lib/initialized_checkout_archive.py
@@ -681,8 +681,7 @@ def preserve(request):
'administrationFingerprint': before['administrationFingerprint'], 'restoreProof': proof}
-def verify_unmoved_preservation(request):
- """Cancel an unbound copy while shared Git evolves; never move any data."""
+def unbound_originals(request):
root = transaction(request['transactionDir'])
if os.path.lexists(root / 'manifest.json'):
fail('preservation-already-bound')
@@ -690,6 +689,10 @@ def verify_unmoved_preservation(request):
if os.path.lexists(quarantine) and (not safe_path(str(quarantine)).is_dir()
or any(quarantine.iterdir())):
fail('preservation-originals-may-have-moved')
+ return root
+
+
+def reviewed_source(request, root):
path = root / 'source.json'
limit = 256 * 1024 ** 2
with os.fdopen(os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK), 'rb') as source:
@@ -707,6 +710,58 @@ def verify_unmoved_preservation(request):
unsigned = {k: v for k, v in compact.items() if k != 'fingerprint'}
if digest({'facts': unsigned, 'sources': before['sources']}) != before['fingerprint']:
fail('preservation-source-proof-changed')
+ return before, hashlib.sha256(encoded).hexdigest()
+
+
+def verify_original_placement(request):
+ """Release only an unstarted cut; never scan, restore or certify file bytes."""
+ root = unbound_originals(request)
+ if os.path.lexists(root / 'source.json'):
+ before, source_sha = reviewed_source(request, root)
+ else:
+ # The executor can stop before capture writes source.json. The service's
+ # accepted journal snapshot still binds the original root identities.
+ before = {k: v for k, v in request['expected'].items() if k != 'ok'}
+ source_sha = None
+ work, admin, common = scan(request)
+ observed = {'identity': {'working': identity(work), 'administration': identity(admin),
+ 'common': identity(common)}, 'modules': []}
+ if observed['identity'] != before['identity'] or str(admin) != before['privateGitDir']:
+ fail('preservation-original-identity-or-git-changed')
+ checked_config(admin)
+ checked_config(common)
+ head = git(admin, work, 'rev-parse', '--verify', 'HEAD^{commit}')
+ branch = git(admin, work, 'symbolic-ref', '--short', 'HEAD')
+ release = request['release']
+ if release != before['release'] or head != release['head'] or branch != release['branch']:
+ fail('release-head-or-branch-changed')
+ lock = admin / 'locked'
+ if lock.exists() != release['locked'] or (release['locked']
+ and lock.read_text().strip() != (release.get('lockReason') or '')):
+ fail('release-lock-changed')
+ observed.update(head=head, branch=branch, locked=release['locked'])
+ for module in before['modules']:
+ module_work = safe_path(str(work / module['path']))
+ module_admin = read_pointer(module_work / '.git', 'gitdir:')
+ module_identity = {'working': identity(module_work), 'administration': identity(module_admin)}
+ if (str(module_admin) != module['gitDir'] or not module_admin.is_relative_to(admin / 'modules')
+ or module_identity != module['identity']):
+ fail('preservation-original-identity-or-git-changed')
+ checked_config(module_admin)
+ if git(module_admin, module_work, 'rev-parse', '--verify', 'HEAD^{commit}') != module['head']:
+ fail('preservation-original-identity-or-git-changed')
+ observed['modules'].append({'path': module['path'], 'identity': module_identity,
+ 'gitDir': str(module_admin), 'head': module['head']})
+ return {'verified': True, 'originalsUnmoved': True, 'archiveVerified': False,
+ 'contentAndMetadataUnverified': True, 'partialArchivesRetained': True,
+ 'sourceSha256': source_sha, 'sourceCaptureRecorded': source_sha is not None,
+ 'reviewedFingerprint': before['fingerprint'], 'structuralObservation': observed}
+
+
+def verify_unmoved_preservation(request):
+ """Cancel an unbound copy while shared Git evolves; never move any data."""
+ root = unbound_originals(request)
+ before, source_sha = reviewed_source(request, root)
after = inspect(request, full=True)
def stable_facts(value):
facts = {k: v for k, v in value.items() if k not in ('sources', 'fingerprint')}
@@ -725,7 +780,7 @@ def verify_unmoved_preservation(request):
return {'verified': True, 'originalsUnmoved': True, 'archiveVerified': False,
'sharedBeforeSha256': digest(before['sources']['common']),
'sharedAfterSha256': digest(after['sources']['common']),
- 'sourceSha256': hashlib.sha256(encoded).hexdigest(),
+ 'sourceSha256': source_sha,
'reviewedFingerprint': before['fingerprint'], 'observedFingerprint': after['fingerprint']}
@@ -1530,7 +1585,7 @@ def main():
'review-restored-finalization', 'verify-restored-finalization',
'review-quarantine-resumption', 'verify-quarantine-resumption', 'resume-quarantine',
'verify-completed-quarantine', 'verify-retired-quarantine', 'verify-deleted-branch',
- 'verify-unmoved-preservation'):
+ 'verify-unmoved-preservation', 'verify-original-placement'):
fd = lock_file(transaction(request['transactionDir']), 'backend.lock')
try:
result = {'preserve': preserve, 'verify': verify, 'move': move,
@@ -1543,7 +1598,8 @@ def main():
'verify-completed-quarantine': verify_completed_quarantine,
'verify-retired-quarantine': verify_retired_quarantine,
'verify-deleted-branch': verify_deleted_branch,
- 'verify-unmoved-preservation': verify_unmoved_preservation}[action](request)
+ 'verify-unmoved-preservation': verify_unmoved_preservation,
+ 'verify-original-placement': verify_original_placement}[action](request)
finally:
os.close(fd)
else:
diff --git a/scripts/lib/initialized_checkout_archive_test.py b/scripts/lib/initialized_checkout_archive_test.py
index e77e424154..384fdea194 100644
--- a/scripts/lib/initialized_checkout_archive_test.py
+++ b/scripts/lib/initialized_checkout_archive_test.py
@@ -172,6 +172,58 @@ class NativeArchive(unittest.TestCase):
with self.assertRaisesRegex(RuntimeError, 'release-head-or-branch-changed'):
archive.verify_unmoved_preservation(self.request)
+ def test_cancel_original_placement_never_hydrates_or_certifies_changed_file_data(self):
+ before = archive.inspect(self.request, full=True)
+ self.request['expected'] = {k: v for k, v in before.items() if k != 'sources'}
+ # An interrupted executor may not have begun its copy.
+ self.assertFalse(archive.verify_original_placement(self.request)['sourceCaptureRecorded'])
+ archive.private_json(self.txn / 'source.json', before)
+ (self.txn / 'quarantine').mkdir(mode=0o700)
+ partial = self.txn / 'partial-copy'
+ partial.write_bytes(b'unverified partial evidence')
+ original = self.work / 'base.txt'
+ original.write_bytes(b'new local work must remain here\n')
+ info = original.stat()
+ os.utime(original, ns=(info.st_atime_ns, info.st_mtime_ns + 108))
+ # Model the observed read-time metadata race. Cancellation must never
+ # enter the byte/metadata scanner; preservation and restore still do.
+ with patch.object(archive, 'manifest', side_effect=RuntimeError('source-changed-during-scan')):
+ proof = archive.verify_original_placement(self.request)
+ self.assertTrue(proof['originalsUnmoved'])
+ self.assertTrue(proof['contentAndMetadataUnverified'])
+ self.assertTrue(proof['partialArchivesRetained'])
+ self.assertFalse(proof['archiveVerified'])
+ self.assertNotIn('observedFingerprint', proof)
+ self.assertEqual(original.read_bytes(), b'new local work must remain here\n')
+ self.assertEqual(partial.read_bytes(), b'unverified partial evidence')
+ with self.assertRaisesRegex(RuntimeError, 'preservation-original-content-changed'):
+ archive.verify_unmoved_preservation(self.request)
+ for target, refusal in (
+ (self.txn / 'quarantine' / 'working', 'preservation-originals-may-have-moved'),
+ (self.txn / 'manifest.json', 'preservation-already-bound'),
+ ):
+ target.write_bytes(b'evidence')
+ with self.assertRaisesRegex(RuntimeError, refusal):
+ archive.verify_original_placement(self.request)
+ target.unlink()
+ saved = (self.txn / 'source.json').read_bytes()
+ tampered = copy.deepcopy(before)
+ tampered['sources']['working'][0]['mode'] ^= 1
+ (self.txn / 'source.json').write_text(json.dumps(tampered))
+ with self.assertRaisesRegex(RuntimeError, 'preservation-source-proof-changed'):
+ archive.verify_original_placement(self.request)
+ (self.txn / 'source.json').write_bytes(saved)
+ moved = self.scratch / 'original-work-retained'
+ self.work.rename(moved)
+ shutil.copytree(moved, self.work, symlinks=True)
+ with self.assertRaisesRegex(RuntimeError, 'preservation-original-identity-or-git-changed'):
+ archive.verify_original_placement(self.request)
+ shutil.rmtree(self.work)
+ moved.rename(self.work)
+ self.git(self.repo, 'update-ref', 'refs/heads/feature/fixture', 'HEAD^')
+ with self.assertRaisesRegex(RuntimeError, 'release-head-or-branch-changed'):
+ archive.verify_original_placement(self.request)
+
def test_common_runtime_sockets_are_outside_capture_but_private_and_captured_sockets_hold(self):
facts = archive.inspect(self.request)
common = Path(facts['commonGitDir'])
diff --git a/server/services/initializedCheckoutRecovery.js b/server/services/initializedCheckoutRecovery.js
index 29aeeded8a..8f02687703 100644
--- a/server/services/initializedCheckoutRecovery.js
+++ b/server/services/initializedCheckoutRecovery.js
@@ -519,23 +519,30 @@ export function _createInitializedCheckoutRecovery(deps = {}) {
return await gate.withCheckoutReservation(reservation, async () => {
// Preservation can fail before a native manifest exists. No move is
// ever attempted before its fsynced intent; only those early phases
- // may cancel the cut after a fresh unchanged-source inspection.
+ // may cancel the cut. Explicit cancellation proves placement without
+ // reading/hydrating working bytes; it neither restores nor certifies them.
if (['intent', 'reserved', 'preserved'].includes(state.phase)
|| (state.phase === 'restored' && state.cancelledUnboundPreservation === true)) {
if (state.phase !== 'restored' && !newReservation && state.reservation
&& JSON.stringify(reservation) !== JSON.stringify(state.reservation)) fail('retirement-reservation-changed');
- const snapshot = await native({ command: 'inspect', repoPath: ctx.repoPath, release: state.release });
let cancellationProof;
- if (JSON.stringify(snapshot) !== JSON.stringify(state.review.snapshot)) {
- // A failed, unbound copy has never authorized a move. A concurrent
- // fetch or another checkout can change shared Git data. Verify the
- // untouched original checkout/private Git, retaining every copy; this
- // cancels only the reservation and never approves an archive.
- if (state.proof?.manifestSha256 || state.phase === 'preserved') fail('retirement-source-changed');
- cancellationProof = await native({ command: 'verify-unmoved-preservation',
+ if (cancelOnly) {
+ cancellationProof = await native({ command: 'verify-original-placement',
repoPath: ctx.repoPath, release: state.release, transactionDir: directory,
expected: state.review.snapshot });
- if (cancellationProof.verified !== true || cancellationProof.originalsUnmoved !== true) fail('retirement-source-changed');
+ if (cancellationProof.verified !== true || cancellationProof.originalsUnmoved !== true
+ || cancellationProof.archiveVerified !== false || cancellationProof.contentAndMetadataUnverified !== true
+ || cancellationProof.partialArchivesRetained !== true) fail('retirement-cancellation-proof-invalid');
+ } else {
+ const snapshot = await native({ command: 'inspect', repoPath: ctx.repoPath, release: state.release });
+ if (JSON.stringify(snapshot) !== JSON.stringify(state.review.snapshot)) {
+ // Ordinary restore retains its original unchanged-content proof.
+ if (state.proof?.manifestSha256 || state.phase === 'preserved') fail('retirement-source-changed');
+ cancellationProof = await native({ command: 'verify-unmoved-preservation',
+ repoPath: ctx.repoPath, release: state.release, transactionDir: directory,
+ expected: state.review.snapshot });
+ if (cancellationProof.verified !== true || cancellationProof.originalsUnmoved !== true) fail('retirement-source-changed');
+ }
}
await ensureOwner(ctx, state.release, true);
executor.assertHeld();
@@ -543,7 +550,8 @@ export function _createInitializedCheckoutRecovery(deps = {}) {
cancelledUnboundPreservation: !state.proof?.manifestSha256,
...(cancellationProof ? { cancellationProof } : {}) });
await gate.releaseCheckoutReservation(reservation);
- return { ok: true, transactionId: state.id, restored: true, archivesRetained: true };
+ return { ok: true, transactionId: state.id, restored: true, archivesRetained: true,
+ ...(cancelOnly ? { cancelled: true, archiveVerified: false, contentAndMetadataUnverified: true } : {}) };
}
const { listWorktrees } = await import('./worktreeManager.js');
const trees = await (deps.listWorktrees || listWorktrees)(ctx.repoPath);
diff --git a/server/services/initializedCheckoutRecovery.test.js b/server/services/initializedCheckoutRecovery.test.js
index d17e244573..7016141d7f 100644
--- a/server/services/initializedCheckoutRecovery.test.js
+++ b/server/services/initializedCheckoutRecovery.test.js
@@ -86,7 +86,15 @@ beforeEach(async () => {
};
const native = vi.fn(async input => {
if (input.command === 'lock') return { assertHeld: () => {}, release: async () => {} };
- if (input.command === 'inspect') return { ...fixture.snapshot };
+ if (input.command === 'inspect') {
+ if (fixture.inspectRefusal) throw new Error(fixture.inspectRefusal);
+ return { ...fixture.snapshot };
+ }
+ if (input.command === 'verify-original-placement') {
+ if (fixture.cancelRefusal) throw new Error(fixture.cancelRefusal);
+ return { verified: true, originalsUnmoved: true, archiveVerified: false,
+ contentAndMetadataUnverified: true, partialArchivesRetained: true };
+ }
if (input.command === 'verify-unmoved-preservation') {
if (fixture.cancelRefusal) throw new Error(fixture.cancelRefusal);
if ((await readdir(input.transactionDir)).includes('manifest.json')) throw new Error('preservation-already-bound');
@@ -244,12 +252,15 @@ describe('initialized checkout transaction', () => {
expect(await fixture.service.restore({ appId: 'app', transactionId: result.transactionId, journalDigest: status.journalDigest })).toMatchObject({ ok: true });
expect((await readdir(join(root, result.transactionId))).length).toBeGreaterThan(0);
});
- it('releases an unmoved failed copy after shared Git drift and replays cancellation after restart', async () => {
+ it('cancels by original placement without hydration and replays interrupted release after restart', async () => {
fixture.failPreserve = true;
const result = await fixture.service.retire(await reviewed());
fixture.snapshot.fingerprint = '9'.repeat(64);
const input = { appId: 'app', transactionId: result.transactionId };
const status = await fixture.service.status(input);
+ // A full source scan itself may hydrate compressed files and change mtime.
+ // Cancellation must not depend on that scan or certify its data as archived.
+ fixture.inspectRefusal = 'source-changed-during-scan';
fixture.deps.admission.releaseCheckoutReservation.mockRejectedValueOnce(new Error('release-interrupted'));
expect(await fixture.service.cancelPreservation({ ...input, journalDigest: status.journalDigest }))
.toMatchObject({ ok: false, reason: 'release-interrupted' });
@@ -257,10 +268,12 @@ describe('initialized checkout transaction', () => {
const rows = (await readdir(join(root, result.transactionId))).filter(name => /^\d{6}\.json$/.test(name)).sort();
const saved = JSON.parse(await readFile(join(root, result.transactionId, rows.at(-1)), 'utf8'));
expect(saved).toMatchObject({ phase: 'restored', cancelledUnboundPreservation: true,
- cancellationProof: { verified: true, originalsUnmoved: true, archiveVerified: false } });
+ cancellationProof: { verified: true, originalsUnmoved: true, archiveVerified: false,
+ contentAndMetadataUnverified: true, partialArchivesRetained: true } });
const restarted = _createInitializedCheckoutRecovery(fixture.deps);
const fresh = await restarted.status(input);
- expect(await restarted.cancelPreservation({ ...input, journalDigest: fresh.journalDigest })).toMatchObject({ ok: true });
+ expect(await restarted.cancelPreservation({ ...input, journalDigest: fresh.journalDigest }))
+ .toMatchObject({ ok: true, cancelled: true, archiveVerified: false, contentAndMetadataUnverified: true });
expect(fixture.cut).toBeNull();
});
it.each(['preservation-original-content-changed', 'preservation-originals-may-have-moved'])(