@guilz-dev/belay 0.6.0 → 0.7.0

package/dist/core/capability/grant-lease.js

@@ -1,36 +1,212 @@
+import { canonicalStringify } from '../fingerprint.js';
 import { isGrantScopeTooBroad } from './grant.js';
 import { grantMatchesRequest } from './grant-match.js';
-export function grantsFromApprovedState(state, repoRoot) {
+function isActiveGrant(grant, now) {
+    if (isGrantScopeTooBroad(grant)) {
+        return false;
+    }
+    const expires = Date.parse(grant.expiresAt);
+    return Number.isFinite(expires) && expires > now && grant.usesRemaining > 0;
+}
+export function grantsFromApproval(approval) {
+    if (approval.grants?.length) {
+        return approval.grants;
+    }
+    if (approval.grant) {
+        return [approval.grant];
+    }
+    return [];
+}
+export function approvalGrantBundleExhausted(approval) {
+    const bundle = grantsFromApproval(approval);
+    if (!bundle.length) {
+        return false;
+    }
+    return bundle.every((grant) => grant.usesRemaining <= 0);
+}
+export function consumeApprovalGrantBundle(approval, requests) {
+    const bundle = grantsFromApproval(approval);
+    if (!bundle.length || !requests.length) {
+        return { approval, consumed: false };
+    }
+    const grants = [...bundle];
     const now = Date.now();
-    return state.approvals
-        .filter((approval) => approval.repoRoot === repoRoot)
-        .map((approval) => approval.grant)
-        .filter((grant) => {
+    for (const request of requests) {
+        const index = grants.findIndex((grant) => {
+            return isActiveGrant(grant, now) && grantMatchesRequest(grant, request);
+        });
+        if (index === -1) {
+            return { approval, consumed: false };
+        }
+        const grant = grants[index];
         if (!grant) {
-            return false;
+            return { approval, consumed: false };
         }
-        if (isGrantScopeTooBroad(grant)) {
+        grants[index] = decrementGrant(grant);
+    }
+    return {
+        approval: {
+            ...approval,
+            grants,
+            grant: grants[0],
+        },
+        consumed: true,
+    };
+}
+function exactGrantMatchesRequest(grant, request) {
+    return (persistedCanonicalStringify(grant.principal) ===
+        persistedCanonicalStringify(request.principal) &&
+        grant.action === request.action &&
+        persistedCanonicalStringify(grant.resource) === persistedCanonicalStringify(request.resource) &&
+        grant.inputFingerprint === request.context.inputFingerprint);
+}
+function validateExactGrantBundle(approval, requests, now, usage) {
+    if (approval.grantBundleVersion !== 1) {
+        return { ok: false, reason: 'legacy_record' };
+    }
+    if (!requests.length) {
+        return { ok: false, reason: 'empty_requests' };
+    }
+    const bundle = grantsFromApproval(approval);
+    if (bundle.length !== requests.length) {
+        return { ok: false, reason: 'cardinality_mismatch' };
+    }
+    if (bundle.some((grant) => isGrantScopeTooBroad(grant))) {
+        return { ok: false, reason: 'grant_scope_too_broad' };
+    }
+    const usageIsValid = bundle.every((grant) => {
+        const expires = Date.parse(grant.expiresAt);
+        if (!Number.isFinite(expires) || expires <= now) {
             return false;
         }
-        const expires = Date.parse(grant.expiresAt);
-        return Number.isFinite(expires) && expires > now && grant.usesRemaining > 0;
+        return usage === 'available'
+            ? grant.usesRemaining > 0
+            : grant.usesRemaining >= 0 && grant.usesRemaining < grant.maxUses;
     });
+    if (!usageIsValid) {
+        return { ok: false, reason: 'grant_inactive' };
+    }
+    const unmatched = [...bundle];
+    for (const request of requests) {
+        const index = unmatched.findIndex((grant) => exactGrantMatchesRequest(grant, request));
+        if (index === -1) {
+            return { ok: false, reason: 'grant_mismatch' };
+        }
+        unmatched.splice(index, 1);
+    }
+    if (unmatched.length > 0) {
+        return { ok: false, reason: 'grant_mismatch' };
+    }
+    return { ok: true, approval };
+}
+function persistedCanonicalStringify(value) {
+    return canonicalStringify(omitUndefined(value));
+}
+function omitUndefined(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => omitUndefined(entry));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .map(([key, entry]) => [key, omitUndefined(entry)]));
+}
+/** Validate and consume a marked exact bundle without mutating on any failure. */
+export function validateAndConsumeGrantBundle(approval, requests, now = Date.now()) {
+    const validated = validateExactGrantBundle(approval, requests, now, 'available');
+    if (!validated.ok) {
+        return validated;
+    }
+    const grants = grantsFromApproval(approval).map((grant) => decrementGrant(grant));
+    return {
+        ok: true,
+        approval: {
+            ...approval,
+            grants,
+            grant: grants[0],
+        },
+    };
+}
+/** Revalidate a marked bundle during an active replay lease without consuming it twice. */
+export function validateGrantBundleForLeaseReuse(approval, requests, now = Date.now()) {
+    return validateExactGrantBundle(approval, requests, now, 'previously_consumed');
+}
+/** Consume every grant in an approved record after fingerprint/hash replay validation. */
+export function consumeApprovedRecordGrantBundle(approval) {
+    const bundle = grantsFromApproval(approval);
+    const now = Date.now();
+    if (!bundle.length ||
+        bundle.some((grant) => {
+            const expires = Date.parse(grant.expiresAt);
+            return !Number.isFinite(expires) || expires <= now || grant.usesRemaining <= 0;
+        })) {
+        return { approval, consumed: false };
+    }
+    const grants = bundle.map((grant) => decrementGrant(grant));
+    return {
+        approval: {
+            ...approval,
+            grants,
+            grant: grants[0],
+        },
+        consumed: true,
+    };
+}
+export function decrementApprovalLegacyGrant(approval) {
+    const bundle = grantsFromApproval(approval);
+    if (!bundle.length) {
+        return approval;
+    }
+    const grants = bundle.map((grant, index) => (index === 0 ? decrementGrant(grant) : grant));
+    return {
+        ...approval,
+        grants,
+        grant: grants[0],
+    };
+}
+export function grantsFromApprovedState(state, repoRoot) {
+    const now = Date.now();
+    const collected = [];
+    for (const approval of state.approvals) {
+        if (approval.repoRoot !== repoRoot) {
+            continue;
+        }
+        for (const grant of grantsFromApproval(approval)) {
+            if (isActiveGrant(grant, now)) {
+                collected.push(grant);
+            }
+        }
+    }
+    return collected;
+}
+function decrementGrant(grant) {
+    return {
+        ...grant,
+        usesRemaining: grant.usesRemaining - 1,
+    };
 }
 export function consumeGrantLease(state, grantId) {
     let consumed = false;
     const approvals = state.approvals.map((approval) => {
-        const grant = approval.grant;
-        if (!grant || grant.grantId !== grantId || grant.usesRemaining <= 0) {
+        const bundle = grantsFromApproval(approval);
+        const index = bundle.findIndex((g) => g.grantId === grantId);
+        if (index === -1) {
+            return approval;
+        }
+        const grant = bundle[index];
+        if (!grant || grant.usesRemaining <= 0) {
             return approval;
         }
         consumed = true;
-        const usesRemaining = grant.usesRemaining - 1;
+        const updated = decrementGrant(grant);
+        const grants = [...bundle];
+        grants[index] = updated;
         return {
             ...approval,
-            grant: {
-                ...grant,
-                usesRemaining,
-            },
+            grants,
+            grant: grants[0],
         };
     });
     return {
@@ -38,6 +214,27 @@ export function consumeGrantLease(state, grantId) {
         consumed,
     };
 }
+/** Consume one lease for each request; all must succeed (atomic bundle consumption). */
+export function consumeGrantLeasesForRequests(state, requests) {
+    const repoRoot = requests[0]?.principal.repoRoot;
+    if (!repoRoot || requests.some((request) => request.principal.repoRoot !== repoRoot)) {
+        return { state, consumed: false };
+    }
+    for (let index = 0; index < state.approvals.length; index += 1) {
+        const approval = state.approvals[index];
+        if (!approval || approval.repoRoot !== repoRoot) {
+            continue;
+        }
+        const consumed = consumeApprovalGrantBundle(approval, requests);
+        if (!consumed.consumed) {
+            continue;
+        }
+        const approvals = [...state.approvals];
+        approvals[index] = consumed.approval;
+        return { state: { ...state, approvals }, consumed: true };
+    }
+    return { state, consumed: false };
+}
 export function findMatchingGrant(grants, request) {
     if (!grants?.length) {
         return undefined;

package/dist/core/capability/grant-match.js

@@ -53,6 +53,9 @@ function grantTargetsResource(grant, request) {
     if (grant.resource.kind === 'executable' && request.resource.kind === 'executable') {
         return grant.resource.command === request.resource.command;
     }
+    if (grant.resource.kind === 'package-cache' && request.resource.kind === 'package-cache') {
+        return grant.resource.manager === request.resource.manager;
+    }
     if (grant.resource.kind === 'git-ref' && request.resource.kind === 'git-ref') {
         return grant.resource.ref === request.resource.ref;
     }

package/dist/core/capability/index.d.ts

@@ -1,5 +1,5 @@
 export { addPathToAllowlist, allPathsAllowlisted, fsScopeAllowlistPath, isPathAllowlisted, loadFsScopeAllowlist, loadFsScopeAllowlistSync, saveFsScopeAllowlist, } from './allowlist.js';
-export { BOUNDARY_ATTESTATION_VERSION, type BoundaryAttestation, type BoundaryDriverId, isAttestationFresh, } from './attestation.js';
+export { attestsWorkspaceMountIsolation, BOUNDARY_ATTESTATION_VERSION, type BoundaryAttestation, type BoundaryDriverId, isAttestationFresh, } from './attestation.js';
 export { BOUNDARY_PROFILE_L1_ATTESTED, BOUNDARY_PROFILE_L3_L4_ONLY, BOUNDARY_PROFILE_L3_POLICY, boundaryVerifiedAllowEnabled, isAttestedBoundary, resolveBoundaryProfile, } from './boundary-profile.js';
 export { evaluateL1FullStatus, hasSandboxRuntime, isCapabilityBrokerDemotionActive, isSandboxBrokerEnabled, } from './broker.js';
 export { CAPABILITY_GRANT_VERSION, type CapabilityGrantV1, isGrantScopeTooBroad, } from './grant.js';

package/dist/core/capability/index.js

@@ -1,5 +1,5 @@
 export { addPathToAllowlist, allPathsAllowlisted, fsScopeAllowlistPath, isPathAllowlisted, loadFsScopeAllowlist, loadFsScopeAllowlistSync, saveFsScopeAllowlist, } from './allowlist.js';
-export { BOUNDARY_ATTESTATION_VERSION, isAttestationFresh, } from './attestation.js';
+export { attestsWorkspaceMountIsolation, BOUNDARY_ATTESTATION_VERSION, isAttestationFresh, } from './attestation.js';
 export { BOUNDARY_PROFILE_L1_ATTESTED, BOUNDARY_PROFILE_L3_L4_ONLY, BOUNDARY_PROFILE_L3_POLICY, boundaryVerifiedAllowEnabled, isAttestedBoundary, resolveBoundaryProfile, } from './boundary-profile.js';
 export { evaluateL1FullStatus, hasSandboxRuntime, isCapabilityBrokerDemotionActive, isSandboxBrokerEnabled, } from './broker.js';
 export { CAPABILITY_GRANT_VERSION, isGrantScopeTooBroad, } from './grant.js';

package/dist/core/capability/policy-engine.d.ts

@@ -56,12 +56,19 @@ export declare function evaluateSubagentPolicy(analysis: SubagentCapabilityAnaly
     decision: PolicyDecision;
 };
 export declare function buildShellCapabilityRequest(analysis: ShellCapabilityAnalysis): CapabilityRequestV1;
+export declare function buildShellCapabilityRequests(analysis: ShellCapabilityAnalysis): CapabilityRequestV1[];
 export declare function buildFileMutationCapabilityRequest(analysis: FileMutationCapabilityAnalysis): CapabilityRequestV1;
 export declare function createTypeScriptPolicyEngine(): PolicyEngine;
 export declare function getDefaultPolicyEngine(): PolicyEngine;
 export declare function policyDecisionRequiresAsk(decision: PolicyDecision): boolean;
+export declare function combinePolicyDecisions(decisions: readonly PolicyDecision[]): PolicyDecision;
+export declare function evaluateCapabilityRequestsPolicy(requests: readonly CapabilityRequestV1[], config: BelayConfigV4, auth?: PolicyAuthExtras, trustedWorkspaceRoots?: string[]): {
+    decisions: PolicyDecision[];
+    decision: PolicyDecision;
+};
 export declare function evaluateShellPolicy(analysis: ShellCapabilityAnalysis, config: BelayConfigV4, auth?: PolicyAuthExtras): {
     request: CapabilityRequestV1;
+    requests: CapabilityRequestV1[];
     decision: PolicyDecision;
 };
 export declare function evaluateFileMutationPolicy(analysis: FileMutationCapabilityAnalysis, config: BelayConfigV4, auth?: PolicyAuthExtras): {

package/dist/core/capability/policy-engine.js

@@ -1,7 +1,9 @@
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { matchesSensitivePath } from '../glob.js';
+import { parseNetworkEndpoint } from '../network-endpoint.js';
 import { canonicalPath, pathWithinRoot, resolveWorkspaceRootMatch } from '../path-utils.js';
+import { tokenizeShell } from '../shell-tokenizer.js';
 import { BOUNDARY_GRANT_ISSUER_CONTAINER, isPathWithinBoundaryMount, materializeContainerBoundaryGrant, } from './boundary-grant-materialize.js';
 import { boundaryVerifiedAllowEnabled } from './boundary-profile.js';
 import { isGrantScopeTooBroad } from './grant.js';
@@ -116,21 +118,27 @@ function resourcePathForShellAnalysis(analysis) {
     const resolved = targets.map((target) => analysis.resolvedPathTargets?.length
         ? canonicalPath(target)
         : resolveCapabilityPath(target, analysis.cwd));
+    const [first] = resolved;
+    if (!first) {
+        return null;
+    }
     if (analysis.effect === 'local_mutation') {
         const outside = resolved.find((candidate) => !pathWithinRoot(repoRoot, candidate));
-        return outside ?? resolved[resolved.length - 1];
+        return outside ?? resolved.at(-1) ?? first;
     }
-    return resolved[0];
+    return first;
 }
 function resourceForShellAnalysis(analysis) {
     if (isGitRefWrite(analysis)) {
         return { kind: 'git-ref', ref: 'push' };
     }
-    if (analysis.egressClass === 'ambiguous' ||
-        analysis.egressClass === 'read' ||
-        analysis.egressClass === 'destructive' ||
-        analysis.location === 'external') {
-        return { kind: 'network', host: '*', protocol: 'unknown' };
+    if (isNetworkShellAnalysis(analysis)) {
+        const exact = exactNetworkResources(analysis);
+        return ((exact.length === 1 ? exact[0] : undefined) ?? {
+            kind: 'network',
+            host: '*',
+            protocol: 'unknown',
+        });
     }
     const resourcePath = resourcePathForShellAnalysis(analysis);
     if (resourcePath) {
@@ -138,8 +146,114 @@ function resourceForShellAnalysis(analysis) {
     }
     return { kind: 'executable', command: analysis.segmentHead };
 }
+function isNetworkShellAnalysis(analysis) {
+    return (analysis.egressClass === 'ambiguous' ||
+        analysis.egressClass === 'read' ||
+        analysis.egressClass === 'destructive' ||
+        analysis.location === 'external');
+}
+const SCP_STYLE_COMMANDS = new Set(['git', 'rsync', 'scp']);
+const PACKAGE_SPEC_COMMANDS = new Set(['bun', 'npm', 'npx', 'pnpm', 'yarn']);
+const NETWORK_VALUE_OPTIONS = new Set(['--registry', '--url']);
+const GIT_OPTIONS_WITH_VALUE = new Set([
+    '-C',
+    '-b',
+    '-c',
+    '-o',
+    '--branch',
+    '--config',
+    '--depth',
+    '--filter',
+    '--git-dir',
+    '--namespace',
+    '--origin',
+    '--reference',
+    '--separate-git-dir',
+    '--upload-pack',
+    '--work-tree',
+]);
+function gitRemoteOperand(tokens) {
+    let cursor = 1;
+    while (cursor < tokens.length) {
+        const token = tokens[cursor];
+        if (!token) {
+            return null;
+        }
+        if (GIT_OPTIONS_WITH_VALUE.has(token)) {
+            cursor += 2;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            cursor += 1;
+            continue;
+        }
+        break;
+    }
+    const subcommand = tokens[cursor];
+    if (!subcommand) {
+        return null;
+    }
+    const positionals = [];
+    let skipOptionValue = false;
+    for (const token of tokens.slice(cursor + 1)) {
+        if (skipOptionValue) {
+            skipOptionValue = false;
+            continue;
+        }
+        if (GIT_OPTIONS_WITH_VALUE.has(token)) {
+            skipOptionValue = true;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            continue;
+        }
+        positionals.push(token);
+    }
+    if (['clone', 'fetch', 'ls-remote', 'pull', 'push'].includes(subcommand)) {
+        return positionals[0] ?? null;
+    }
+    if (subcommand === 'remote' && positionals[0] === 'add') {
+        return positionals[2] ?? null;
+    }
+    if (subcommand === 'submodule' && positionals[0] === 'add') {
+        return positionals[1] ?? null;
+    }
+    return null;
+}
+function exactNetworkResources(analysis) {
+    const resources = new Map();
+    const shellTokens = tokenizeShell(analysis.command);
+    const gitRemote = analysis.segmentHead === 'git' ? gitRemoteOperand(shellTokens) : null;
+    for (const rawToken of shellTokens) {
+        const optionSeparator = rawToken.startsWith('-') ? rawToken.indexOf('=') : -1;
+        const optionName = optionSeparator === -1 ? null : rawToken.slice(0, optionSeparator);
+        const token = optionSeparator !== -1 && optionName && NETWORK_VALUE_OPTIONS.has(optionName)
+            ? rawToken.slice(optionSeparator + 1)
+            : rawToken;
+        const endpoint = parseNetworkEndpoint(token, {
+            allowHostedGitShorthand: PACKAGE_SPEC_COMMANDS.has(analysis.segmentHead),
+            allowScpStyle: SCP_STYLE_COMMANDS.has(analysis.segmentHead) &&
+                (analysis.segmentHead !== 'git' || rawToken === gitRemote),
+        });
+        if (!endpoint) {
+            continue;
+        }
+        const resource = { kind: 'network', ...endpoint };
+        resources.set(`${resource.host}:${resource.port ?? ''}:${resource.protocol}`, resource);
+    }
+    return [...resources.values()];
+}
 export function buildShellCapabilityRequest(analysis) {
-    return {
+    const [request] = buildShellCapabilityRequests(analysis);
+    if (!request) {
+        throw new Error('shell analysis produced no capability request');
+    }
+    return request;
+}
+export function buildShellCapabilityRequests(analysis) {
+    const resources = isNetworkShellAnalysis(analysis) ? exactNetworkResources(analysis) : [];
+    const selectedResources = resources.length > 0 ? resources : [resourceForShellAnalysis(analysis)];
+    return selectedResources.map((resource) => ({
         version: CAPABILITY_REQUEST_VERSION,
         principal: {
             adapter: analysis.adapter,
@@ -147,7 +261,7 @@ export function buildShellCapabilityRequest(analysis) {
             sessionHash: hashSession(`${analysis.repoRoot}:${analysis.cwd}`),
         },
         action: actionForShellAnalysis(analysis),
-        resource: resourceForShellAnalysis(analysis),
+        resource,
         context: {
             cwd: analysis.cwd,
             inputFingerprint: analysis.inputFingerprint,
@@ -163,7 +277,7 @@ export function buildShellCapabilityRequest(analysis) {
             level: evidenceLevelForOpacity(analysis.opacity),
             signals: [...analysis.signals],
         },
-    };
+    }));
 }
 function actionForFileMutation(analysis) {
     if (analysis.locationLabel === 'control_plane') {
@@ -233,6 +347,16 @@ function shellLocationFromRequest(request) {
 function isRepoLocalShellLocation(request) {
     return shellLocationFromRequest(request) === 'repo_local';
 }
+function isRepoLocalPackageExec(request) {
+    if (request.action !== 'process.exec' || request.resource.kind !== 'executable') {
+        return false;
+    }
+    if (!request.evidence.signals.includes('package_exec.local_bin_resolved')) {
+        return false;
+    }
+    const commandPath = canonicalPath(request.resource.command);
+    return path.isAbsolute(commandPath) && pathWithinRoot(request.principal.repoRoot, commandPath);
+}
 function isRepoLocalRoutineWrite(request, sensitivePaths) {
     if (!isRepoLocalShellLocation(request)) {
         return false;
@@ -297,6 +421,14 @@ function builtInRule(request, context) {
             matchedRule: 'builtin.subagent',
         };
     }
+    if (isRepoLocalPackageExec(request)) {
+        return {
+            outcome: 'allow',
+            reason: 'read_only',
+            signals: [...request.evidence.signals, 'repo_local_exec'],
+            matchedRule: 'builtin.repo_local_exec',
+        };
+    }
     if (request.action === 'secret.read' || request.action === 'git.ref.write') {
         return {
             outcome: 'require_approval',
@@ -456,14 +588,69 @@ export function getDefaultPolicyEngine() {
 export function policyDecisionRequiresAsk(decision) {
     return decision.outcome === 'require_approval' || decision.outcome === 'deny';
 }
+function policyOutcomeRank(outcome) {
+    switch (outcome) {
+        case 'deny':
+            return 3;
+        case 'require_approval':
+            return 2;
+        case 'allow':
+            return 1;
+        default:
+            return 0;
+    }
+}
+export function combinePolicyDecisions(decisions) {
+    if (!decisions.length) {
+        return {
+            outcome: 'allow',
+            reason: 'read_only',
+            signals: [],
+            matchedRule: 'plan.conjunction',
+        };
+    }
+    const sorted = [...decisions].sort((left, right) => policyOutcomeRank(right.outcome) - policyOutcomeRank(left.outcome));
+    const worst = sorted[0];
+    if (!worst) {
+        return {
+            outcome: 'allow',
+            reason: 'read_only',
+            signals: [],
+            matchedRule: 'plan.conjunction',
+        };
+    }
+    return worst;
+}
+export function evaluateCapabilityRequestsPolicy(requests, config, auth, trustedWorkspaceRoots) {
+    let workingAuth = auth;
+    const decisions = [];
+    for (const request of requests) {
+        const enriched = enrichAuthWithMaterializedGrants(request, config, workingAuth);
+        const decision = getDefaultPolicyEngine().evaluate(request, buildAuthorizationContext(config, trustedWorkspaceRoots, enriched));
+        decisions.push(decision);
+        const previousCount = workingAuth?.grants?.length ?? 0;
+        const nextCount = enriched?.grants?.length ?? 0;
+        if (nextCount > previousCount) {
+            workingAuth = enriched;
+        }
+    }
+    return {
+        decisions,
+        decision: combinePolicyDecisions(decisions),
+    };
+}
 export function evaluateShellPolicy(analysis, config, auth) {
-    const request = buildShellCapabilityRequest(analysis);
-    const enriched = enrichAuthWithMaterializedGrants(request, config, {
+    const requests = buildShellCapabilityRequests(analysis);
+    const enrichedAuth = {
         ...auth,
         sensitivePaths: auth?.sensitivePaths ?? analysis.sensitivePaths,
-    });
-    const decision = getDefaultPolicyEngine().evaluate(request, buildAuthorizationContext(config, analysis.trustedWorkspaceRoots, enriched));
-    return { request, decision };
+    };
+    const { decision } = evaluateCapabilityRequestsPolicy(requests, config, enrichedAuth, analysis.trustedWorkspaceRoots);
+    const [request] = requests;
+    if (!request) {
+        throw new Error('shell analysis produced no capability request');
+    }
+    return { request, requests, decision };
 }
 export function evaluateFileMutationPolicy(analysis, config, auth) {
     const request = buildFileMutationCapabilityRequest(analysis);

package/dist/core/capability/request.d.ts

@@ -18,6 +18,9 @@ export type CapabilityResource = {
 } | {
     kind: 'executable';
     command: string;
+} | {
+    kind: 'package-cache';
+    manager: 'npm' | 'pnpm';
 } | {
     kind: 'git-ref';
     ref: string;

package/dist/core/config.d.ts

@@ -46,6 +46,15 @@ export interface BelayModelAssistConfig {
     model?: string;
     timeoutMs?: number;
 }
+export interface BelayFileCheckpointConfig {
+    enabled: boolean;
+    allowNonGit: boolean;
+    maxFiles: number;
+    maxSourceBytes: number;
+    maxWorkspaceBytes: number;
+    prepareTimeoutMs: number;
+    copyConcurrency: number;
+}
 export interface BelayTransactionalConfig {
     enabled: boolean;
     minConfidence: number;
@@ -55,6 +64,14 @@ export interface BelayTransactionalConfig {
     gates: {
         shell: boolean;
     };
+    fileCheckpoint: BelayFileCheckpointConfig;
+    checkpoint?: {
+        enabled: boolean;
+        appliedRetentionHours: number;
+        restoredRetentionHours: number;
+        maxCheckpoints: number;
+        maxBytes: number;
+    };
 }
 export interface BelayPolicyConfig {
     unknownLocalEffect: UnknownLocalEffectPolicy;
@@ -196,6 +213,9 @@ export type BelayConfig = BelayConfigV4;
 export declare const DEFAULT_FENCE_WARN_THRESHOLD = 0.5;
 export declare const DEFAULT_CONFIDENCE_THRESHOLDS: BelayConfidenceThresholds;
 export declare const DEFAULT_MODEL_ASSIST: BelayModelAssistConfig;
+export declare const DEFAULT_FILE_CHECKPOINT: BelayFileCheckpointConfig;
+export declare function normalizeFileCheckpointConfig(raw: Partial<BelayFileCheckpointConfig> | undefined): BelayFileCheckpointConfig;
+export declare const DEFAULT_RECOVERY_CHECKPOINT: NonNullable<BelayTransactionalConfig['checkpoint']>;
 export declare const DEFAULT_TRANSACTIONAL_V3: BelayTransactionalConfig;
 export declare const LEGACY_POLICY_V3: BelayPolicyConfig;
 /** Fresh install defaults: recoverable-first with opaque/unparseable fail-closed. */