@dharma-ai-labs/agent-fabric 0.2.129 → 0.2.131

package/dist/index.js

@@ -24,7 +24,7 @@ import { appendRecoveredWorkspace, applyRegistryRecoveryFile, inspectRegistryRec
 import { relayRuntimeObservationReady, upgradeRelayRuntime } from './relayRuntimeUpgrade.js';
 import { assertStudyExactPoll, studyTaskIdFromFlags } from './studyExactTaskSelector.js';
 import { initializeRepositoryKnowledge, readRepositoryKnowledgeSource } from './repositoryKnowledge.js';
-import { inventoryRepositoryPackage, readRepositoryPackageSnapshot, readRepositorySourceBaselineSnapshot, writeRepositoryPackageSnapshot } from './repositoryPackage.js';
+import { inventoryRepositoryPackage, readRepositoryPackageSnapshot, readRepositorySourceBaselineSnapshot, serializeRepositoryPackageSnapshot, writeRepositoryPackageSnapshot } from './repositoryPackage.js';
 import { validateRepositorySourceAuthorization } from './repositorySourceAuthorization.js';
 import { advanceRepositorySourceBaseline, BlockedRepositorySourceRetry, fetchRepositorySourceAuthorization, recoverPublishedLocalSourceBaseline, RepositorySourceWatcher, scanRepositorySourceChanges, seedRepositorySourceWatcher } from './repositorySourceSync.js';
 import { assertRepositoryInstallerOwnership, writeRepositoryInstallerFile } from './repositoryInstallerFiles.js';
@@ -57,11 +57,15 @@ import { createDemoWatchHealthRecorder } from './demoWatchHealth.js';
 import { demoWatchStatus, disableDemoWatch, enableDemoWatch, inspectDemoWatchSupervisor } from './demoWatchControl.js';
 import { namedSessionPaths, namedSessionRequest, readNamedSession, saveNamedSession, runNamedSessionService } from './namedSessionService.js';
 import { queueNamedSessionEvidence } from './namedSessionEvidence.js';
+import { retainNamedSessionRepositoryState } from './namedSessionRepositoryState.js';
+import { syncNamedSessionTaskExports } from './namedSessionTaskExportSync.js';
+import { readNamedSessionPackageContent, verifyNamedSessionVisibleSkill } from './namedSessionPackageGate.js';
 import { openCodexAppServerTransport } from '@dharma-ai-labs/agent-fabric-provider-adapters/experimental/codex-transport';
+import { readCodexPublicContext } from '@dharma-ai-labs/agent-fabric-provider-adapters/experimental/codex-session';
 import { createNamedSessionTrust, isNamedSessionOwnerReceipt, renewNamedSessionLifetime } from './namedSessionTrust.js';
 import { startNamedCodexThread } from './namedCodexThread.js';
 export { openCooperativeInboxSession } from './cooperativeInboxSession.js';
-const VERSION = '0.2.129';
+const VERSION = '0.2.131';
 const USAGE = CLI_USAGE;
 const execFileAsync = promisify(execFile);
 const LOCAL_PROVIDER_IDS = ['codex', 'claude', 'agy', 'hermes'];
@@ -624,7 +628,7 @@ async function acquirePidLock(lockPath, timeoutMs, timeoutMessage) {
             try {
                 await mkdir(recoveryCandidate);
                 await writeFile(resolve(recoveryCandidate, 'owner'), `${process.pid}\n`, { mode: 0o600 });
-                for (let attempt = 0;; attempt++) {
+                for (;;) {
                     try {
                         await rename(recoveryCandidate, recoveryPath);
                         break;
@@ -647,8 +651,10 @@ async function acquirePidLock(lockPath, timeoutMs, timeoutMessage) {
                             windowsRecoveryOwner = owner;
                         }
                         catch (inspectionError) {
-                            if (inspectionError.code === 'ENOENT' && attempt < 3)
+                            if (inspectionError.code === 'ENOENT' && Date.now() < deadline) {
+                                await new Promise((resolvePromise) => setTimeout(resolvePromise, 25));
                                 continue;
+                            }
                             throw renameError;
                         }
                         throw renameError;
@@ -2368,7 +2374,7 @@ async function bootstrap(flags) {
     const role = repositoryReceipt.repositoryRole;
     const roleReady = Boolean(role);
     const relayReady = relay.state === 'running';
-    const startupReady = !['win32', 'linux'].includes(process.platform) || autostart.state === 'enabled';
+    const startupReady = !['win32', 'linux', 'darwin'].includes(process.platform) || autostart.state === 'enabled';
     const complete = sharedRepositoryReady && namedSessionReady && firstLearningReady
         && roleReady && relayReady && startupReady;
     return {
@@ -3664,8 +3670,7 @@ async function namedSessionCommand(action, flags) {
     if (!flags.has('apply'))
         return { ok: true, planned: true, name, workspaceId,
             provider: 'codex', localWork: 'workspace_write', peerQuestions: 'read_only', network: 'deny' };
-    if (!await repositorySharedReady(item))
-        throw new Error('named_session_repository_package_pending');
+    await verifyNamedSessionVisibleSkill(await verifyAgentFabricSkillInstallation({ provider: 'codex', workspace: item.path }), await repositorySharedReady(item));
     if (action === 'start') {
         if (existing && !existing.enabled)
             await saveNamedSession(dharmaHome(), { ...existing, enabled: true });
@@ -3776,15 +3781,89 @@ async function namedSessionCommand(action, flags) {
             } };
         // The durable reservation already suppresses duplicate provider execution.
         const consumed = new Set();
+        let taskState = null;
+        let taskStateFailure = 'source_state_unavailable';
+        const taskSnapshot = async () => {
+            const sourceAuthorization = await fetchRepositorySourceAuthorization(fabric, repositoryRoleScope(item));
+            return inventoryRepositoryPackage({ workspace: item.path, organizationId: item.organizationId,
+                workspaceId, repositoryBindingId: item.repositoryBindingId, repositoryAgentId: item.repositoryAgentId, sourceAuthorization });
+        };
         return await runNamedSessionService({ home: dharmaHome(), registration, vault, signal: controller.signal,
             localWriteRoots: writeRoots,
-            withActivationBoundary: operation => withWorkspaceSkillActivationLock(workspaceId, 'codex', async () => {
+            syncTaskExports: () => syncNamedSessionTaskExports({ vault, bindingId: registration.bindingId,
+                identity: registration.identity,
+                loadPolicy: () => refreshVerifiedWorkspacePolicyForTransmission(policyPath, workspaceId, fabric),
+                send: body => fabric.signedPost('/agent-fabric/codex-task-exports', body) }),
+            withActivationBoundary: (operation, work) => withWorkspaceSkillActivationLock(workspaceId, 'codex', async () => {
                 await refreshLifetime();
                 const skill = await verifyAgentFabricSkillInstallation({ provider: 'codex', workspace: item.path });
-                if (!skill.ready || !await repositorySharedReady(item))
-                    throw new Error('named_session_repository_package_pending');
-                return operation();
+                const packageContent = await readNamedSessionPackageContent(skill, await repositorySharedReady(item));
+                const bundleId = packageContent.bundleId;
+                taskState = null;
+                taskStateFailure = 'source_state_unavailable';
+                if (work) {
+                    const current = await loadVerifiedWorkspacePolicy(policyPath, workspaceId);
+                    if (current.evidence.automaticDisclosure?.mode === 'customer_authorized_content' && skill.activeBundleHash) {
+                        try {
+                            taskStateFailure = 'public_context_unavailable';
+                            const binding = vault.getProviderSessionBinding(registration.bindingId, registration.identity);
+                            if (!binding)
+                                throw new Error('named_session_binding_unavailable');
+                            const retained = await readCodexPublicContext(transport, { threadId: binding.sessionId, workspaceRoot: binding.workspaceRoot });
+                            taskStateFailure = 'runtime_version_unavailable';
+                            const version = (await execFileAsync('codex', ['--version'], { timeout: 10_000, maxBuffer: 4096,
+                                env: providerProcessEnvironment(process.env) })).stdout.trim();
+                            if (!/^codex-cli [0-9]+\.[0-9]+\.[0-9]+(?:[-+][a-zA-Z0-9.-]+)?$/.test(version)) {
+                                throw new Error('named_session_runtime_version_unavailable');
+                            }
+                            const contextContentHash = await vault.putBlob(Buffer.from(retained.bytes), 'named-session-public-context');
+                            if (contextContentHash !== retained.contextHash)
+                                throw new Error('named_session_context_integrity_failed');
+                            taskStateFailure = 'source_state_unavailable';
+                            const before = await taskSnapshot();
+                            const sourceContentHash = await vault.putBlob(Buffer.from(serializeRepositoryPackageSnapshot(before)), 'named-session-source-state');
+                            await vault.putBlob(Buffer.from(JSON.stringify({ workId: work.workId, bindingId: registration.bindingId,
+                                sourceContentHash, sourceSnapshotHash: before.manifest.snapshotHash, bundleId, bundleHash: skill.activeBundleHash,
+                                packageContent, contextContentHash, evidenceRevision: current.revision,
+                                consentReceiptId: current.evidence.automaticDisclosure.consentReceiptId })), 'named-session-source-boundary');
+                            taskState = { workId: work.workId, before, bundleId, bundleHash: skill.activeBundleHash, packageContent,
+                                evidenceRevision: current.revision, consentReceiptId: current.evidence.automaticDisclosure.consentReceiptId,
+                                providerContext: { retainedContextHash: retained.contextHash, contextContentHash,
+                                    runtimeVersion: version.slice('codex-cli '.length), requestedModel: retained.context.configuredModel,
+                                    executedModel: null, replayMode: 'task_level' } };
+                        }
+                        catch { /* Source capture failure must not replay or rewrite a coding task. */ }
+                    }
+                }
+                try {
+                    return await operation();
+                }
+                finally {
+                    taskState = null;
+                }
             }),
+            retainRepositoryState: async (capture) => {
+                const current = await loadVerifiedWorkspacePolicy(policyPath, workspaceId);
+                if (current.evidence.automaticDisclosure?.mode !== 'customer_authorized_content') {
+                    return { state: 'not_authorized', acceptedLearningObservation: false };
+                }
+                if (!taskState)
+                    return { state: 'blocked', code: taskStateFailure, acceptedLearningObservation: false };
+                if (current.revision !== taskState.evidenceRevision
+                    || current.evidence.automaticDisclosure.consentReceiptId !== taskState.consentReceiptId) {
+                    throw new Error('named_session_repository_state_consent_changed');
+                }
+                const binding = vault.getProviderSessionBinding(registration.bindingId, registration.identity);
+                if (!binding)
+                    throw new Error('named_session_binding_unavailable');
+                const receipt = await retainNamedSessionRepositoryState({ vault, binding, capture, workId: taskState.workId,
+                    before: taskState.before, after: await taskSnapshot(), activeBundleId: taskState.bundleId, activeBundleHash: taskState.bundleHash,
+                    taskExport: { policy: current, contextBytes: await vault.getBlob(taskState.providerContext.contextContentHash),
+                        contextHash: taskState.providerContext.retainedContextHash } });
+                return { ...receipt, providerContext: taskState.providerContext,
+                    packageContent: { manifestHash: taskState.packageContent.manifestHash,
+                        catalogHash: taskState.packageContent.catalogHash, skillsHash: taskState.packageContent.skillsHash } };
+            },
             authorizeLocalWork: async () => {
                 const current = await refreshVerifiedWorkspacePolicyForTransmission(policyPath, workspaceId, fabric);
                 return writeRoots.every(root => current.tasks.writePaths.includes(`${root}/**`));
@@ -5595,9 +5674,10 @@ export async function verifyAgentFabricSkillInstallation(input) {
     }
     const bootstrapReady = repositoryInstalled && nativeInstalled && nativeDiscovered;
     const config = await readDeviceConfig();
-    const activeBundleId = workspaceId && organizationAgentId && config
-        ? (await activeSkillAuthorization(input.provider, workspaceId, organizationAgentId, config))?.bundleId ?? null
+    const activeAuthorization = workspaceId && organizationAgentId && config
+        ? await activeSkillAuthorization(input.provider, workspaceId, organizationAgentId, config)
         : null;
+    const activeBundleId = activeAuthorization?.bundleId ?? null;
     let activationAttested = !['agy', 'hermes'].includes(input.provider) ? nativeInstalled : false;
     if (['agy', 'hermes'].includes(input.provider) && activeBundleId && workspaceId) {
         try {
@@ -5629,6 +5709,8 @@ export async function verifyAgentFabricSkillInstallation(input) {
         nativeSkillPath,
         workspaceId: workspaceId || null,
         activeBundleId,
+        activeBundleHash: activeAuthorization?.bundleHash ?? null,
+        signedMarkerBundleId,
         activation: input.provider === 'agy' ? (activationAttested ? 'attested' : 'manual_invocation_required') : 'next_session',
         nextAction: input.provider === 'agy' && bootstrapReady && !activationAttested
             ? 'The Agy bootstrap is installed and discoverable. A signed remediation bundle must include and pass the content-bound activation challenge before full lifecycle support is reported.'
@@ -6718,14 +6800,18 @@ async function relayWorkspaceLoop(flags, signal, serialized) {
             }
             let evidenceRequestId;
             if (canonicalWorkspace.accessMode !== 'knowledge_only' && evidencePolicyFresh && !stopping) {
-                const evidenceCycle = await withRepositoryRelayStage('evidence_sync', () => deferUnavailableRelayRetention(async () => {
-                    const synced = await syncPendingRetentionCapsules(vault, fabric, policy, canonicalWorkspace.workspaceId);
-                    const evidence = await processEvidenceRequest(fabric, policy, canonicalWorkspace.workspaceId);
-                    return {
-                        synced,
-                        evidenceRequestId: typeof evidence.requestId === 'string' ? evidence.requestId : undefined,
-                    };
-                }));
+                const evidenceCycle = await withRepositoryRelayStage('evidence_sync', async () => {
+                    const synced = await withRepositoryRelayStage('pending_capsule_sync', () => deferUnavailableRelayRetention(() => syncPendingRetentionCapsules(vault, fabric, policy, canonicalWorkspace.workspaceId)));
+                    if (synced.state === 'deferred')
+                        return synced;
+                    const evidence = await withRepositoryRelayStage('evidence_request', () => deferUnavailableRelayRetention(() => processEvidenceRequest(fabric, policy, canonicalWorkspace.workspaceId)));
+                    if (evidence.state === 'deferred')
+                        return evidence;
+                    return { state: 'completed', value: {
+                            synced: synced.value,
+                            evidenceRequestId: typeof evidence.value.requestId === 'string' ? evidence.value.requestId : undefined,
+                        } };
+                });
                 if (evidenceCycle.state === 'deferred') {
                     evidencePolicyFresh = false;
                 }