@guilz-dev/belay 0.4.0 → 0.7.0

package/dist/core/recovery/types.d.ts

@@ -0,0 +1,104 @@
+import type { CapabilityRequestV1 } from '../capability/request.js';
+/** Backends that can mint a verifiable RecoveryProof (ADR: proof-only execution). */
+export type RecoveryBackend = 'git_worktree' | 'file_checkpoint';
+export interface RecoveryProofV1 {
+    version: 1;
+    backend: RecoveryBackend;
+    inputFingerprint: string;
+    resourceScope: string;
+    baseStateHash: string;
+    /** The proof covers only filesystem effects observed inside the repository. */
+    effectClosure: 'repo_local_fs_observed';
+    issuedAt: string;
+    expiresAt: string;
+    probeSignals: string[];
+}
+export type RecoveryCheckpointState = 'prepared' | 'applying' | 'applied' | 'restoring' | 'restored' | 'conflict' | 'corrupt' | 'needs_manual_repair';
+export type RecoveryFileKind = 'absent' | 'file' | 'symlink';
+export interface RecoveryFileSnapshotV1 {
+    kind: RecoveryFileKind;
+    mode?: number;
+    hash?: string;
+    blob?: string;
+    symlinkTarget?: string;
+}
+export interface RecoveryCheckpointEntryV1 {
+    path: string;
+    before: RecoveryFileSnapshotV1;
+    after: RecoveryFileSnapshotV1;
+}
+export interface RecoveryCheckpointManifestV1 {
+    version: 1;
+    checkpointId: string;
+    backend: RecoveryBackend;
+    repoRoot: string;
+    repoIdentity: string;
+    commandFingerprint: string;
+    createdAt: string;
+    expiresAt: string;
+    proof: RecoveryProofV1;
+    entries: RecoveryCheckpointEntryV1[];
+}
+export type RecoveryFileSnapshotV2 = RecoveryFileSnapshotV1 | {
+    kind: 'directory';
+    mode: number;
+    hash: string;
+};
+export interface RecoveryCheckpointEntryV2 {
+    path: string;
+    before: RecoveryFileSnapshotV2;
+    after: RecoveryFileSnapshotV2;
+}
+export type RecoveryCheckpointEntry = RecoveryCheckpointEntryV1 | RecoveryCheckpointEntryV2;
+export interface RecoveryCheckpointManifestV2 {
+    version: 2;
+    checkpointId: string;
+    backend: RecoveryBackend;
+    repoRoot: string;
+    resourceKind: 'git_repository' | 'directory';
+    repoIdentity: string;
+    commandFingerprint: string;
+    createdAt: string;
+    expiresAt: string;
+    proof: RecoveryProofV1;
+    entries: RecoveryCheckpointEntryV2[];
+}
+export type RecoveryCheckpointManifest = RecoveryCheckpointManifestV1 | RecoveryCheckpointManifestV2;
+export interface RecoveryCheckpointStateV1 {
+    version: 1;
+    state: RecoveryCheckpointState;
+    updatedAt: string;
+    manifestHash: string;
+    detail?: string;
+}
+export interface RecoveryReceiptV1 {
+    version: 1;
+    checkpointId: string;
+    manifestHash: string;
+    proofHash: string;
+    postStateHash: string;
+    appliedAt: string;
+    changeCount: number;
+}
+export interface RecoveryCheckpointSummary {
+    checkpointId: string;
+    state: RecoveryCheckpointState;
+    /** Operator-facing detail from durable checkpoint state (e.g. mixed-state reason). */
+    stateDetail?: string;
+    backend: RecoveryBackend;
+    repoRoot: string;
+    commandFingerprint: string;
+    createdAt: string;
+    expiresAt: string;
+    changeCount: number;
+    manifestHash: string;
+    receiptHash?: string;
+    proofHash?: string;
+    postStateHash?: string;
+}
+export interface RecoveryProofContext {
+    repoRoot: string;
+    cwd: string;
+    command: string;
+    requests: CapabilityRequestV1[];
+}

package/dist/core/recovery/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/standing-allow.js

@@ -18,6 +18,9 @@ const STANDING_ALLOW_BLOCKED_REASONS = new Set([
     'protected_artifact',
     'pipe_to_shell',
     'command_substitution',
+    'outside_repo_mutation',
+    'outside_repo_redirect',
+    'control_plane_mutation',
 ]);
 export function standingAllowFile(config, repoLocalStateDir) {
     return `${belayStateDir(config, repoLocalStateDir)}/standing-allow.json`;

package/dist/core/transactional/apply-observed-changes.d.ts

@@ -0,0 +1,13 @@
+import type { ObservedFileChange } from './file-tree.js';
+import type { TransactionalFileChange } from './types.js';
+export declare const TRANSACTIONAL_APPLY_TOCTOU = "transactional_apply_toctou";
+export declare const TRANSACTIONAL_APPLY_CONFLICT = "transactional_apply_conflict";
+export declare const TRANSACTIONAL_APPLY_ROLLBACK_FAILED = "transactional_apply_rollback_failed";
+export interface ApplyObservedChangesParams {
+    sourceRoot: string;
+    targetRoot: string;
+    changes: ObservedFileChange[];
+    afterApply?: () => Promise<void>;
+}
+export declare function applyObservedChanges(params: ApplyObservedChangesParams): Promise<void>;
+export declare function buildObservedChangesFromTransactional(baselineRoot: string, executionRoot: string, changes: TransactionalFileChange[]): Promise<ObservedFileChange[]>;

package/dist/core/transactional/apply-observed-changes.js

@@ -0,0 +1,275 @@
+import { copyFile, lstat, mkdir, mkdtemp, readlink, rm, rmdir, symlink } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { compareRelativePathsBytewise, joinRelativePath, validateRelativePath, } from './file-tree-path.js';
+import { readSnapshotNode, snapshotNodesEqual } from './snapshot-node.js';
+export const TRANSACTIONAL_APPLY_TOCTOU = 'transactional_apply_toctou';
+export const TRANSACTIONAL_APPLY_CONFLICT = 'transactional_apply_conflict';
+export const TRANSACTIONAL_APPLY_ROLLBACK_FAILED = 'transactional_apply_rollback_failed';
+async function chmodSafe(target, mode) {
+    try {
+        const { chmod } = await import('node:fs/promises');
+        await chmod(target, mode & 0o777);
+    }
+    catch {
+        // best effort
+    }
+}
+async function removePathIfExists(target) {
+    let info;
+    try {
+        info = await lstat(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    if (info.isDirectory() && !info.isSymbolicLink()) {
+        await rmdir(target);
+        return;
+    }
+    await rm(target, { force: true });
+}
+async function copyPathPreservingType(source, target) {
+    const info = await lstat(source);
+    if (info.isDirectory() && !info.isSymbolicLink()) {
+        try {
+            const targetInfo = await lstat(target);
+            if (targetInfo.isDirectory() && !targetInfo.isSymbolicLink()) {
+                await chmodSafe(target, info.mode);
+                return;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    await removePathIfExists(target);
+    await mkdir(path.dirname(target), { recursive: true });
+    if (info.isSymbolicLink()) {
+        await symlink(await readlink(source), target);
+        return;
+    }
+    if (info.isDirectory() && !info.isSymbolicLink()) {
+        await mkdir(target, { recursive: true, mode: info.mode & 0o777 });
+        return;
+    }
+    if (!info.isFile()) {
+        throw new Error(TRANSACTIONAL_APPLY_CONFLICT);
+    }
+    await copyFile(source, target);
+    await chmodSafe(target, info.mode);
+}
+async function assertParentChainSafe(targetRoot, relativePath, plannedDirectories = new Set()) {
+    const segments = relativePath.split(path.sep).filter(Boolean);
+    if (segments.length <= 1) {
+        return;
+    }
+    for (let index = 1; index < segments.length; index++) {
+        const prefix = segments.slice(0, index).join(path.sep);
+        const absolute = joinRelativePath(targetRoot, prefix);
+        let info;
+        try {
+            info = await lstat(absolute);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+        if (info.isSymbolicLink()) {
+            throw new Error(TRANSACTIONAL_APPLY_CONFLICT);
+        }
+        if (!info.isDirectory() && !plannedDirectories.has(prefix)) {
+            throw new Error(TRANSACTIONAL_APPLY_CONFLICT);
+        }
+    }
+}
+async function restorePathFromBackup(backupPath, target, rollbackRoot) {
+    const stagingRoot = await mkdtemp(path.join(rollbackRoot, 'restore-'));
+    const staged = path.join(stagingRoot, 'node');
+    try {
+        await copyPathPreservingType(backupPath, staged);
+        await copyPathPreservingType(staged, target);
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+async function rollbackAppliedChanges(actions, changes, targetRoot, rollbackRoot) {
+    let hadFailure = false;
+    for (const action of [...actions].reverse()) {
+        try {
+            await assertParentChainSafe(targetRoot, action.relativePath);
+            if (action.type === 'restore') {
+                await restorePathFromBackup(action.backupPath, action.target, rollbackRoot);
+            }
+            else {
+                await removePathIfExists(action.target);
+            }
+        }
+        catch {
+            hadFailure = true;
+        }
+    }
+    for (const change of changes) {
+        try {
+            await assertTargetMatches(targetRoot, change);
+        }
+        catch {
+            hadFailure = true;
+        }
+    }
+    return !hadFailure;
+}
+async function assertTargetMatches(targetRoot, change) {
+    const target = joinRelativePath(targetRoot, change.relativePath);
+    const current = await readSnapshotNode(target);
+    if (!snapshotNodesEqual(current, change.before)) {
+        throw new Error(TRANSACTIONAL_APPLY_TOCTOU);
+    }
+}
+async function assertTargetMatchesAfter(targetRoot, change) {
+    const target = joinRelativePath(targetRoot, change.relativePath);
+    const current = await readSnapshotNode(target);
+    if (!snapshotNodesEqual(current, change.after)) {
+        throw new Error(TRANSACTIONAL_APPLY_CONFLICT);
+    }
+}
+function applyRank(change) {
+    if (change.after.kind === 'absent') {
+        return 0;
+    }
+    if (change.after.kind === 'directory') {
+        return 1;
+    }
+    return 2;
+}
+function compareApplyOrder(left, right) {
+    const leftRank = applyRank(left);
+    const rightRank = applyRank(right);
+    const rankDiff = leftRank - rightRank;
+    if (rankDiff !== 0) {
+        return rankDiff;
+    }
+    if (leftRank === 0) {
+        return compareRelativePathsBytewise(right.relativePath, left.relativePath);
+    }
+    return compareRelativePathsBytewise(left.relativePath, right.relativePath);
+}
+function sortedChanges(changes) {
+    return [...changes].sort(compareApplyOrder);
+}
+async function applySingleChange(sourceRoot, targetRoot, change) {
+    const target = joinRelativePath(targetRoot, change.relativePath);
+    await assertParentChainSafe(targetRoot, change.relativePath);
+    if (change.after.kind === 'absent') {
+        if (change.before.kind === 'directory') {
+            await rmdir(target);
+            return;
+        }
+        await rm(target, { force: true });
+        return;
+    }
+    if (change.after.kind === 'directory') {
+        if (change.before.kind !== 'directory') {
+            await removePathIfExists(target);
+        }
+        await mkdir(target, { recursive: true, mode: change.after.mode & 0o777 });
+        await chmodSafe(target, change.after.mode);
+        return;
+    }
+    const source = joinRelativePath(sourceRoot, change.relativePath);
+    await copyPathPreservingType(source, target);
+}
+export async function applyObservedChanges(params) {
+    const { sourceRoot, targetRoot, changes } = params;
+    const plannedDirectories = new Set(changes
+        .filter((change) => change.after.kind === 'directory')
+        .map((change) => change.relativePath));
+    for (const change of changes) {
+        validateRelativePath(change.relativePath);
+    }
+    for (const change of changes) {
+        await assertParentChainSafe(targetRoot, change.relativePath, plannedDirectories);
+        await assertTargetMatches(targetRoot, change);
+    }
+    const backupRoot = await mkdtemp(path.join(os.tmpdir(), 'belay-tx-rollback-'));
+    const rollbackActions = [];
+    let mutationAttempted = false;
+    try {
+        for (const change of sortedChanges(changes)) {
+            const target = joinRelativePath(targetRoot, change.relativePath);
+            await assertParentChainSafe(targetRoot, change.relativePath);
+            await assertTargetMatches(targetRoot, change);
+            let targetExists = true;
+            try {
+                await lstat(target);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                targetExists = false;
+            }
+            if (targetExists) {
+                const backupPath = path.join(backupRoot, String(rollbackActions.length), change.relativePath);
+                await mkdir(path.dirname(backupPath), { recursive: true });
+                await copyPathPreservingType(target, backupPath);
+                await assertParentChainSafe(targetRoot, change.relativePath);
+                rollbackActions.push({
+                    type: 'restore',
+                    target,
+                    backupPath,
+                    relativePath: change.relativePath,
+                });
+            }
+            else if (change.after.kind !== 'absent') {
+                await assertParentChainSafe(targetRoot, change.relativePath);
+                rollbackActions.push({ type: 'remove', target, relativePath: change.relativePath });
+            }
+            mutationAttempted = true;
+            await applySingleChange(sourceRoot, targetRoot, change);
+        }
+        for (const change of changes) {
+            await assertTargetMatchesAfter(targetRoot, change);
+        }
+        try {
+            await params.afterApply?.();
+        }
+        catch {
+            // Cleanup/audit failure after a verified apply must not roll back or reject success.
+        }
+    }
+    catch (error) {
+        if (!mutationAttempted)
+            throw error;
+        const rollbackOk = await rollbackAppliedChanges(rollbackActions, changes, targetRoot, backupRoot);
+        if (!rollbackOk) {
+            throw new Error(TRANSACTIONAL_APPLY_ROLLBACK_FAILED);
+        }
+        throw error;
+    }
+    finally {
+        await rm(backupRoot, { recursive: true, force: true });
+    }
+}
+export async function buildObservedChangesFromTransactional(baselineRoot, executionRoot, changes) {
+    const observed = [];
+    for (const change of changes) {
+        validateRelativePath(change.relativePath);
+        const before = await readSnapshotNode(joinRelativePath(baselineRoot, change.relativePath));
+        const after = await readSnapshotNode(joinRelativePath(executionRoot, change.relativePath));
+        observed.push({
+            relativePath: change.relativePath,
+            kind: change.kind,
+            before,
+            after,
+        });
+    }
+    return observed;
+}

package/dist/core/transactional/backend-selector.d.ts

@@ -0,0 +1,8 @@
+import type { TransactionalBackendContext, TransactionalBackendProbe, TransactionalBackendSelection } from './backend.js';
+export declare const FILE_CHECKPOINT_DISABLED = "file_checkpoint_disabled";
+export declare const FILE_CHECKPOINT_NON_GIT_DISABLED = "file_checkpoint_non_git_disabled";
+export declare const FILE_CHECKPOINT_DURABLE_REQUIRED = "file_checkpoint_durable_checkpoint_required";
+export declare const FILE_CHECKPOINT_ISOLATION_UNAVAILABLE = "file_checkpoint_isolation_unavailable";
+export declare const FILE_CHECKPOINT_NOT_IMPLEMENTED = "file_checkpoint_not_implemented";
+export declare function probeTransactionalBackends(context: TransactionalBackendContext): Promise<TransactionalBackendProbe[]>;
+export declare function selectTransactionalBackend(context: TransactionalBackendContext): Promise<TransactionalBackendSelection>;

package/dist/core/transactional/backend-selector.js

@@ -0,0 +1,118 @@
+import { attestsWorkspaceMountIsolation } from '../capability/attestation.js';
+import { fileCheckpointBackend } from './file-checkpoint-backend.js';
+import { isDirtyWorktree, isGitWorktreeAvailable } from './git-worktree.js';
+import { gitWorktreeBackend } from './git-worktree-backend.js';
+export const FILE_CHECKPOINT_DISABLED = 'file_checkpoint_disabled';
+export const FILE_CHECKPOINT_NON_GIT_DISABLED = 'file_checkpoint_non_git_disabled';
+export const FILE_CHECKPOINT_DURABLE_REQUIRED = 'file_checkpoint_durable_checkpoint_required';
+export const FILE_CHECKPOINT_ISOLATION_UNAVAILABLE = 'file_checkpoint_isolation_unavailable';
+export const FILE_CHECKPOINT_NOT_IMPLEMENTED = 'file_checkpoint_not_implemented';
+function fileCheckpointProbe(reason, signals) {
+    return {
+        eligible: false,
+        backend: 'file_checkpoint',
+        reason,
+        signals,
+    };
+}
+function fileCheckpointIsolationReason(context) {
+    const attestation = context.boundaryAttestation;
+    const fresh = context.boundaryAttestationFresh === true;
+    const driverId = context.boundaryDriverId;
+    if (!attestation || !fresh || !driverId) {
+        return FILE_CHECKPOINT_ISOLATION_UNAVAILABLE;
+    }
+    if (attestation.driver !== driverId) {
+        return FILE_CHECKPOINT_ISOLATION_UNAVAILABLE;
+    }
+    if (!attestsWorkspaceMountIsolation(attestation)) {
+        return FILE_CHECKPOINT_ISOLATION_UNAVAILABLE;
+    }
+    return null;
+}
+export async function probeTransactionalBackends(context) {
+    const probes = [await gitWorktreeBackend.probe(context)];
+    if (await isGitWorktreeAvailable(context.repoRoot)) {
+        probes.push(await probeFileCheckpointForGit(context));
+    }
+    else {
+        probes.push(await probeFileCheckpointForNonGit(context));
+    }
+    return probes;
+}
+async function gitWorkspaceSignals(context) {
+    const signals = ['git_repository'];
+    if (await isDirtyWorktree(context.repoRoot, { ignoreRoots: context.dirtyIgnoreRoots })) {
+        signals.push('dirty_git_worktree');
+    }
+    return signals;
+}
+async function probeFileCheckpointForGit(context) {
+    const signals = await gitWorkspaceSignals(context);
+    if (!context.fileCheckpoint.enabled) {
+        return fileCheckpointProbe(FILE_CHECKPOINT_DISABLED, signals);
+    }
+    if (!context.durableCheckpointEnabled) {
+        return fileCheckpointProbe(FILE_CHECKPOINT_DURABLE_REQUIRED, signals);
+    }
+    const isolationReason = fileCheckpointIsolationReason(context);
+    if (isolationReason) {
+        return fileCheckpointProbe(isolationReason, [...signals, 'isolation_unavailable']);
+    }
+    const backendProbe = await fileCheckpointBackend.probe(context);
+    if (backendProbe.eligible) {
+        return backendProbe;
+    }
+    return fileCheckpointProbe(backendProbe.reason ?? FILE_CHECKPOINT_NOT_IMPLEMENTED, [
+        ...signals,
+        ...(backendProbe.reason === FILE_CHECKPOINT_NOT_IMPLEMENTED ? ['not_implemented'] : []),
+    ]);
+}
+async function probeFileCheckpointForNonGit(context) {
+    if (!context.fileCheckpoint.enabled) {
+        return fileCheckpointProbe(FILE_CHECKPOINT_DISABLED, ['non_git_workspace']);
+    }
+    if (!context.fileCheckpoint.allowNonGit) {
+        return fileCheckpointProbe(FILE_CHECKPOINT_NON_GIT_DISABLED, ['non_git_workspace']);
+    }
+    if (!context.durableCheckpointEnabled) {
+        return fileCheckpointProbe(FILE_CHECKPOINT_DURABLE_REQUIRED, ['non_git_workspace']);
+    }
+    const isolationReason = fileCheckpointIsolationReason(context);
+    if (isolationReason) {
+        return fileCheckpointProbe(isolationReason, ['non_git_workspace', 'isolation_unavailable']);
+    }
+    return fileCheckpointProbe(FILE_CHECKPOINT_NOT_IMPLEMENTED, [
+        'non_git_workspace',
+        'not_implemented',
+    ]);
+}
+export async function selectTransactionalBackend(context) {
+    const gitProbe = await gitWorktreeBackend.probe(context);
+    if (gitProbe.eligible) {
+        return {
+            backend: gitWorktreeBackend,
+            probe: gitProbe,
+        };
+    }
+    if (await isGitWorktreeAvailable(context.repoRoot)) {
+        const fileProbe = await probeFileCheckpointForGit(context);
+        if (fileProbe.eligible) {
+            return {
+                backend: fileCheckpointBackend,
+                probe: fileProbe,
+            };
+        }
+        return {
+            backend: null,
+            probe: fileProbe,
+            skipReason: 'dirty_worktree',
+        };
+    }
+    const fileProbe = await probeFileCheckpointForNonGit(context);
+    return {
+        backend: null,
+        probe: fileProbe,
+        skipReason: 'git_worktree_unavailable',
+    };
+}

package/dist/core/transactional/backend.d.ts

@@ -0,0 +1,55 @@
+import type { BoundaryAttestation, BoundaryDriverId } from '../capability/attestation.js';
+import type { BelayFileCheckpointConfig } from '../config.js';
+import type { TransactionalFileChange } from './types.js';
+export type TransactionalBackendId = 'git_worktree' | 'file_checkpoint';
+export interface TransactionalBackendProbe {
+    eligible: boolean;
+    backend: TransactionalBackendId;
+    reason?: string;
+    signals: string[];
+}
+export interface TransactionalSnapshot {
+    backend: TransactionalBackendId;
+    resourceRoot: string;
+    executionRoot: string;
+    baselineRoot?: string;
+    resourceKind?: 'git_repository' | 'directory';
+    resourceIdentity: string;
+    baselineTreeHash: string;
+    excludedRoots: string[];
+    copyStrategy?: 'clonefile' | 'reflink' | 'copy';
+    snapshotFileCount?: number;
+    snapshotSourceBytes?: number;
+    snapshotWorkspaceBytes?: number;
+    snapshotPrepareMs?: number;
+    /** Relative cwd inside resourceRoot for isolated workspace mounts. */
+    executionCwdRelative?: string;
+    /** Revalidates the source tree and metadata immediately before apply. */
+    validateSourceState?(): Promise<void>;
+    collectChanges(): Promise<TransactionalFileChange[]>;
+    cleanup(): Promise<void>;
+}
+export interface TransactionalBackendContext {
+    repoRoot: string;
+    stateDir: string;
+    cwd: string;
+    dirtyIgnoreRoots?: string[];
+    fileCheckpoint: BelayFileCheckpointConfig;
+    /** Required for file_checkpoint eligibility once implemented. */
+    durableCheckpointEnabled: boolean;
+    /** Verified boundary attestation for file_checkpoint isolation checks. */
+    boundaryAttestation?: BoundaryAttestation | null;
+    boundaryAttestationFresh?: boolean;
+    /** Resolved boundary driver; attestation must match this id for file_checkpoint. */
+    boundaryDriverId?: BoundaryDriverId;
+}
+export interface TransactionalBackend {
+    id: TransactionalBackendId;
+    probe(context: TransactionalBackendContext): Promise<TransactionalBackendProbe>;
+    prepare(context: TransactionalBackendContext): Promise<TransactionalSnapshot>;
+}
+export interface TransactionalBackendSelection {
+    backend: TransactionalBackend | null;
+    probe: TransactionalBackendProbe;
+    skipReason?: string;
+}

package/dist/core/transactional/backend.js

@@ -0,0 +1 @@
+export {};

package/dist/core/transactional/diff-evaluator.js

@@ -51,7 +51,10 @@ export function evaluateTransactionalDiff(changes, ctx) {
         categories.add('large_deletion');
     }
     const categoryList = [...categories];
-    const dangerous = categoryList.includes('large_deletion');
+    const dangerous = categoryList.includes('large_deletion') ||
+        categoryList.includes('repo_outside') ||
+        categoryList.includes('sensitive_path') ||
+        categoryList.includes('control_plane');
     const base = {
         categories: categoryList,
         changes,

package/dist/core/transactional/eligibility.js

@@ -1,3 +1,4 @@
+import { capabilityRequestsBlockRecovery } from '../recovery/capability.js';
 const EXCLUDED_REASONS = new Set([
     'unparseable_shell',
     'external_effect',
@@ -26,6 +27,9 @@ export function isTransactionalEligible(config, kind, result) {
     if (EXCLUDED_REASONS.has(result.reason)) {
         return false;
     }
+    if (capabilityRequestsBlockRecovery(result.capabilityRequests)) {
+        return false;
+    }
     const { assessment } = result;
     if (assessment.external) {
         return false;

package/dist/core/transactional/file-checkpoint-backend.d.ts

@@ -0,0 +1,3 @@
+import type { TransactionalBackend } from './backend.js';
+export declare const FILE_CHECKPOINT_PROTECTED_PATH_CHANGED = "file_checkpoint_protected_path_changed";
+export declare const fileCheckpointBackend: TransactionalBackend;