@dharma-ai-labs/agent-fabric 0.2.86 → 0.2.88

package/dist/index.test.js

@@ -9,7 +9,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
 import { acceptedTrajectoryHead, activateAgyPlugin, attestAgySkillActivation, attestHermesSkillBundleActivation, actionDecisionCapabilityFreshUntil, canonicalFilesystemPath, controlAgentDecisionUrl, installAvailableNativeAgentFabricBootstraps, assertCapsuleAuthorizedByCurrentPolicy, assertRecoveredTaskWorkspacePolicy, assertTaskWorkspacePolicy, assertTaskSkillPin, installNativeAgentFabricBootstrap, installClaudeReadOnlyProjectPermissions, installRepositoryAgentFabricSkill, isDirectExecution, isTransientBootstrapError, loadAgentFabricOnboardingContract, loadOrCreateInstallationId, materializeWorkspacePolicy, applyServerEvidencePolicy, materializeInlineSkillFiles, validateSkillBundleSources, nativeSkillDirectory, nativeSkillDirectoryForWorkspace, nativeSkillRootMatchingAuthorization, normalizeGitRemoteIdentity, postTaskOutcome, parseCliOptions, parseSelectedProviderIds, pathExistsOrThrow, portalUrl, providerHintFromEnvironment, providerHintFromProcessArgv, probeRelayConnection, preflightBootstrapWorkspaceIdentity, rawLocalRetentionDays, syncPendingRetentionCapsules, requireCompletedBootstrapEvidence, retryBootstrapOnboarding, synchronizeBootstrapEvidence, deferUnavailableRelayRetention, recoverLegacySkillBundleIdAfterAuthorizationFailure, installedBundleIdForSkillPollAfterAuthorizationFailure, recoveredTaskPolicyWasSuperseded, relayProcessState, releaseDailyContentUpload, reserveDailyContentUpload, run, runAssistantCommand, sourceRepositoryFingerprint, stableRepositoryLauncherContents, summarizeBootstrapOrganizationApi, ensureAgyReadOnlyAttestationPermission, attestAgySkillBundleActivation, responseTextFromEvent, taskResponsePreview, taskReceiptSession, taskSkillPinFailureCode, verifyAgentFabricSkillInstallation, waitForRelayReadiness, withWorkspacePolicyRefreshLock, withWorkspaceSkillActivationLock, } from './index.js';
 import { canonicalize, signCanonicalObject } from '@dharma-ai-labs/agent-fabric-contracts';
-import { buildTrajectoryCapsule } from '@dharma-ai-labs/agent-fabric-evidence-reduction';
+import { buildTrajectoryCapsule, trajectoryCapsuleHash } from '@dharma-ai-labs/agent-fabric-evidence-reduction';
 import { CLI_USAGE } from './usage.js';
 import { isSupportedNodeVersion, launchWithRuntime, nodeRuntimeCandidates, runtimeBootstrapHint, } from './runtime-bootstrap.js';
 test('installation identity is durable per DHARMA_HOME and rejects corrupt state', async () => {
@@ -1334,6 +1334,144 @@ test('queued capsules from a replaced device are retained locally but never sent
     assert.deepEqual(sent, [current.trajectoryId]);
     assert.equal(old.deviceId, '11111111-1111-4111-8111-111111111111');
 });
+test('oversized queued current-device revision is retired only after checking the accepted head', async () => {
+    const base = await materializeWorkspacePolicy({
+        workspace: await mkdtemp(join(tmpdir(), 'dharma-oversized-capsule-')),
+        organizationId: 'org_northstar', revision: 'local',
+    });
+    const session = {
+        provider: 'codex', sessionId: 'oversized-pending', sourcePath: '/private/codex.jsonl',
+        workspace: '/repo', coverage: 'observed',
+        startedAt: '2026-09-24T00:00:00.000Z', endedAt: '2026-09-24T00:00:01.000Z',
+        records: [{ native: { type: 'message' }, sourcePath: '/private/codex.jsonl', line: 1,
+                workspace: '/repo', timestamp: '2026-09-24T00:00:00.000Z', kind: 'metadata' }],
+    };
+    const previousRevisionHash = `sha256:${'a'.repeat(64)}`;
+    const capsule = buildTrajectoryCapsule({
+        organizationId: 'org_northstar', deviceId: '22222222-2222-4222-8222-222222222222',
+        workspaceId: 'workspace-northstar', session, policy: base.policy,
+        rawContentId: `sha256:${'b'.repeat(64)}`, rawBytes: 32,
+        revision: 4, previousRevisionHash,
+    });
+    const capsuleBytes = Buffer.byteLength(canonicalize(capsule));
+    const policyWithSmallerCap = {
+        ...base.policy,
+        evidence: { ...base.policy.evidence, maximumCapsuleBytes: capsuleBytes - 1 },
+    };
+    const pending = [{ trajectoryId: capsule.trajectoryId, revision: 4, capsule }];
+    const discarded = [];
+    let synced = 0;
+    let head = {
+        revision: 3, capsuleHash: previousRevisionHash,
+    };
+    let headUnavailable = false;
+    const vault = {
+        listPendingCapsuleSyncs: async () => [...pending],
+        markCapsuleSynced: () => { synced += 1; pending.length = 0; },
+        discardPendingCapsuleSync: (_trajectoryId, _revision, reason) => {
+            discarded.push(reason);
+            pending.length = 0;
+        },
+    };
+    const fabric = {
+        config: { organizationId: 'org_northstar', deviceId: capsule.deviceId },
+        getTrajectoryHead: async () => {
+            if (headUnavailable)
+                throw new Error('provider unavailable');
+            return { trajectoryId: capsule.trajectoryId, head };
+        },
+        syncTrajectory: async () => { throw new Error('oversized capsule must not be uploaded'); },
+    };
+    assert.equal(await syncPendingRetentionCapsules(vault, fabric, policyWithSmallerCap, 'workspace-northstar'), 0);
+    assert.deepEqual(discarded, ['capsule_size_limit_superseded']);
+    assert.equal(synced, 0);
+    assert.equal(capsule.capsuleHash, buildTrajectoryCapsule({
+        organizationId: 'org_northstar', deviceId: capsule.deviceId, workspaceId: 'workspace-northstar',
+        session, policy: base.policy, rawContentId: `sha256:${'b'.repeat(64)}`, rawBytes: 32,
+        revision: 4, previousRevisionHash,
+    }).capsuleHash);
+    pending.push({ trajectoryId: capsule.trajectoryId, revision: 4, capsule });
+    head = { revision: 4, capsuleHash: capsule.capsuleHash };
+    assert.equal(await syncPendingRetentionCapsules(vault, fabric, policyWithSmallerCap, 'workspace-northstar'), 1);
+    assert.equal(synced, 1);
+    assert.deepEqual(discarded, ['capsule_size_limit_superseded']);
+    pending.push({ trajectoryId: capsule.trajectoryId, revision: 4, capsule });
+    headUnavailable = true;
+    await assert.rejects(() => syncPendingRetentionCapsules(vault, fabric, policyWithSmallerCap, 'workspace-northstar'), /provider unavailable/);
+    assert.equal(pending.length, 1);
+    headUnavailable = false;
+    head = { revision: 2, capsuleHash: previousRevisionHash };
+    await assert.rejects(() => syncPendingRetentionCapsules(vault, fabric, policyWithSmallerCap, 'workspace-northstar'), /conflicts with the accepted server head/);
+    assert.equal(pending.length, 1);
+});
+test('queued native recipient paths retire only an unsent revision without uploading it', async () => {
+    const workspace = await mkdtemp(join(tmpdir(), 'dharma-recipient-path-capsule-'));
+    const signed = signedPolicyAuthorization({
+        revision: 'content-v1', evidence: {
+            automaticDisclosure: { mode: 'customer_authorized_content', consentReceiptId: 'consent-recipient', allowedContentClasses: ['native_provider_payload'] },
+            maximumCapsuleBytes: 500_000, maximumDailyUploadBytes: 50_000_000,
+        },
+    });
+    const base = await materializeWorkspacePolicy({
+        workspace, organizationId: 'org_northstar', revision: 'portal-bootstrap',
+        serverPolicyAuthorization: signed.envelope, serverPublicKeyEd25519: signed.publicKeyEd25519,
+        workspaceId: 'workspace-northstar', secureStore: memorySecureStore(),
+    });
+    const capsule = buildTrajectoryCapsule({
+        organizationId: 'org_northstar', deviceId: '22222222-2222-4222-8222-222222222222',
+        workspaceId: 'workspace-northstar', policy: base.policy,
+        session: {
+            provider: 'codex', sessionId: 'recipient-path-pending', sourcePath: '/private/codex.jsonl',
+            workspace: '/repo', coverage: 'observed', startedAt: '2026-09-24T00:00:00.000Z',
+            endedAt: '2026-09-24T00:00:01.000Z',
+            records: [{ native: { type: 'tool_call', payload: { recipient: 'peer' } }, sourcePath: '/private/codex.jsonl',
+                    line: 1, workspace: '/repo', timestamp: '2026-09-24T00:00:00.000Z', kind: 'tool_call' }],
+        },
+        rawContentId: `sha256:${'b'.repeat(64)}`, rawBytes: 32,
+    });
+    const native = capsule.events[0].payload.nativeProviderPayload;
+    native.payload.recipient = '/home';
+    capsule.capsuleHash = trajectoryCapsuleHash(capsule);
+    const pending = [{ trajectoryId: capsule.trajectoryId, revision: 1, capsule }];
+    const discarded = [];
+    let synced = 0;
+    let head = null;
+    let unavailable = false;
+    const vault = {
+        listPendingCapsuleSyncs: async () => [...pending],
+        markCapsuleSynced: () => { synced += 1; pending.length = 0; },
+        discardPendingCapsuleSync: (_trajectoryId, _revision, reason) => {
+            discarded.push(reason);
+            pending.length = 0;
+        },
+    };
+    const fabric = {
+        config: { organizationId: 'org_northstar', deviceId: capsule.deviceId },
+        getTrajectoryHead: async () => {
+            if (unavailable)
+                throw new Error('provider unavailable');
+            return { trajectoryId: capsule.trajectoryId, head };
+        },
+        syncTrajectory: async () => { throw new Error('path-bearing capsule must not be uploaded'); },
+    };
+    assert.equal(await syncPendingRetentionCapsules(vault, fabric, base.policy, 'workspace-northstar'), 0);
+    assert.deepEqual(discarded, ['local_path_disclosure_superseded']);
+    assert.equal(synced, 0);
+    assert.equal(native.payload.recipient, '/home');
+    pending.push({ trajectoryId: capsule.trajectoryId, revision: 1, capsule });
+    head = { revision: 1, capsuleHash: capsule.capsuleHash };
+    assert.equal(await syncPendingRetentionCapsules(vault, fabric, base.policy, 'workspace-northstar'), 1);
+    assert.equal(synced, 1);
+    assert.deepEqual(discarded, ['local_path_disclosure_superseded']);
+    pending.push({ trajectoryId: capsule.trajectoryId, revision: 1, capsule });
+    head = { revision: 2, capsuleHash: capsule.capsuleHash };
+    await assert.rejects(() => syncPendingRetentionCapsules(vault, fabric, base.policy, 'workspace-northstar'), /conflicts with the accepted server head/);
+    assert.equal(pending.length, 1);
+    head = null;
+    unavailable = true;
+    await assert.rejects(() => syncPendingRetentionCapsules(vault, fabric, base.policy, 'workspace-northstar'), /provider unavailable/);
+    assert.equal(pending.length, 1);
+});
 test('recovered task evidence distinguishes a superseded policy from the current revision', () => {
     const capsule = { redactionReceipt: { policyRevision: 'policy-v1' } };
     assert.equal(recoveredTaskPolicyWasSuperseded(capsule, { revision: 'policy-v2' }), true);
@@ -1614,13 +1752,13 @@ test('relay probe opens an authenticated session without polling or leasing work
         },
         openSession: async (version) => {
             sessions += 1;
-            assert.equal(version, '0.2.86');
+            assert.equal(version, '0.2.88');
             return { ok: true };
         },
     }));
     assert.equal(sessions, 1);
     assert.deepEqual(result, {
-        ok: true, connected: true, organizationId: 'org_test', deviceId: 'device_test', relayVersion: '0.2.86',
+        ok: true, connected: true, organizationId: 'org_test', deviceId: 'device_test', relayVersion: '0.2.88',
     });
 });
 test('relay probe fails closed when the server does not acknowledge the session', async () => {