@dharma-ai-labs/agent-fabric 0.2.164 → 0.2.165

package/dist/index.js

@@ -48,6 +48,7 @@ import { registerRepositoryRoleMetadata, discoverRepositoryRoleMetadata } from '
 import { askRepositoryRoleQuestion, readRepositoryRoleReply } from './repositoryRoleQuestion.js';
 import { deriveRepositoryRole } from './repositoryRoleDerivation.js';
 import { withOnboardingStage } from './onboardingStage.js';
+import { reportCodexSetupFailure } from './codexSetupDiagnostic.js';
 import { waitForRepositoryReadiness } from './repositoryReadinessWait.js';
 import { connectDemoDevice, verifyDemoDevice } from './demoEnrollment.js';
 import { performDemoPeerAction, withDemoDeviceLock } from './demoPeer.js';
@@ -89,7 +90,7 @@ import { assertCodexSetupExecutionLease } from './codexSetupAdmission.js';
 import { parseLocalCodexSetupReadiness } from '@dharma-ai-labs/agent-fabric-local-vault/setup-readiness';
 import { writeBootstrapHostJson, writeBootstrapHostText } from './bootstrapHostFiles.js';
 export { openCooperativeInboxSession } from './cooperativeInboxSession.js';
-const VERSION = '0.2.164';
+const VERSION = '0.2.165';
 const USAGE = CLI_USAGE;
 const execFileAsync = promisify(execFile);
 const LOCAL_PROVIDER_IDS = ['codex', 'claude', 'agy', 'hermes'];
@@ -784,14 +785,22 @@ async function acquirePidLock(lockPath, timeoutMs, timeoutMessage) {
                             }
                             catch (inspectionError) {
                                 let disappeared = inspectionError.code === 'ENOENT';
-                                if (!disappeared && inspectionError.code === 'EPERM') {
+                                // Invalid owner metadata rethrows renameError and remains an immediate denial.
+                                if (!disappeared && inspectionError !== renameError
+                                    && inspectionError.code === 'EPERM') {
                                     // Windows can deny owner reads while its directory is being
-                                    // deleted. Retry only when fresh metadata confirms absence.
-                                    try {
-                                        await step(() => lstat(recoveryPath));
-                                    }
-                                    catch (readbackError) {
-                                        disappeared = readbackError.code === 'ENOENT';
+                                    // deleted. Observe only; never republish until absence is verified.
+                                    while (Date.now() < deadline) {
+                                        try {
+                                            await step(() => lstat(recoveryPath));
+                                        }
+                                        catch (readbackError) {
+                                            if (readbackError.code !== 'ENOENT')
+                                                throw renameError;
+                                            disappeared = true;
+                                            break;
+                                        }
+                                        await step(() => new Promise((resolvePromise) => setTimeout(resolvePromise, 25)));
                                     }
                                 }
                                 if (disappeared && Date.now() < deadline) {
@@ -2503,13 +2512,15 @@ export async function bootstrapFromCodexSetup(input) {
     }
 }
 /** Native-owner continuation: no caller-selected flags or replacement authority. */
-export async function bootstrapFromCodexSetupScope(scope) {
+export async function bootstrapFromCodexSetupScope(scope, observeFailure) {
     try {
         return await runCodexBootstrapHostScope(scope, prepared => run(['bootstrap',
             ...[...prepared.flags].flatMap(([key, value]) => value === true ? [`--${key}`] : [`--${key}`, String(value)]),
         ]));
     }
     catch (error) {
+        if (observeFailure)
+            reportCodexSetupFailure(observeFailure, error, 'bootstrap');
         if (error instanceof Error && error.message === 'setup_session_sender_unavailable') {
             return { ok: false, stage: 'host_setup_unavailable',
                 code: 'codex_setup_host_execution_unqualified', effects: false, grantRedeemed: false };
@@ -2740,7 +2751,7 @@ async function observeCodexBootstrapRuntime(prepared, vault, firstLearning, inte
         expiresAt: new Date(Math.min(Date.parse(intent.expiresAt), Date.parse(policy.serverAuthorization.expiresAt), Date.parse(startupPolicy.serverAuthorization.expiresAt), Date.parse(binding.expiresAt), signed.expiresAt ? Date.parse(signed.expiresAt) : Infinity)).toISOString() });
 }
 /** Trusted native host composition, not an MCP/model/peer tool. */
-export async function createCodexBootstrapCompletionOwner(scope, vault) {
+export async function createCodexBootstrapCompletionOwner(scope, vault, observeFailure) {
     const prepared = await runCodexBootstrapHostScope(scope, async (value) => value);
     let firstLearning;
     const readiness = createCodexSetupReadinessOwner({ intent: prepared.intent,
@@ -2754,16 +2765,25 @@ export async function createCodexBootstrapCompletionOwner(scope, vault) {
         } });
     return Object.freeze({
         execute: async (lease) => {
-            await scope.step(() => assertCodexSetupExecutionLease(lease, prepared.intent));
-            const result = await withCodexSetupSessionSender({ scope, vault, lease }, () => bootstrapFromCodexSetupScope(scope));
-            await scope.step(() => assertCodexSetupExecutionLease(lease, prepared.intent));
-            const workflow = result.workflowReadiness;
-            if (result.ok !== true || result.stage !== 'complete' || !workflow
-                || !['synchronized', 'no_eligible_history', 'denied_disclosure'].includes(String(workflow.firstLearning))) {
-                return { state: 'unconfirmed', code: 'setup_execution_unconfirmed' };
-            }
-            firstLearning = workflow.firstLearning;
-            return readiness.record(lease);
+            try {
+                await scope.step(() => assertCodexSetupExecutionLease(lease, prepared.intent));
+                const result = await withCodexSetupSessionSender({ scope, vault, lease }, () => bootstrapFromCodexSetupScope(scope, observeFailure));
+                await scope.step(() => assertCodexSetupExecutionLease(lease, prepared.intent));
+                const workflow = result.workflowReadiness;
+                if (result.ok !== true || result.stage !== 'complete' || !workflow
+                    || !['synchronized', 'no_eligible_history', 'denied_disclosure'].includes(String(workflow.firstLearning))) {
+                    if (observeFailure)
+                        reportCodexSetupFailure(observeFailure, new Error(typeof result.stage === 'string' ? result.stage : 'setup_execution_unconfirmed'), 'completion');
+                    return { state: 'unconfirmed', code: 'setup_execution_unconfirmed' };
+                }
+                firstLearning = workflow.firstLearning;
+                return await readiness.record(lease);
+            }
+            catch (error) {
+                if (observeFailure)
+                    reportCodexSetupFailure(observeFailure, error, 'completion');
+                throw error;
+            }
         },
         verify: readiness.verify,
     });
@@ -2816,7 +2836,8 @@ export async function openCodexBootstrapNativeHost(input) {
             }
         });
         void settled.catch(() => { });
-        return Object.freeze({ threadId: host.threadId, turnId: host.turnId, close, settled });
+        return Object.freeze({ threadId: host.threadId, turnId: host.turnId, close, settled,
+            get diagnostics() { return ownedHost.diagnostics; } });
     }
     catch {
         let cleanupFailed = false;
@@ -2909,7 +2930,10 @@ export async function startCodexBootstrapNativeHost(input) {
     const root = resolve(dharmaHome(), 'vault');
     let completion;
     let ownerScope;
-    return startCodexSetupNativeHost({ ...input,
+    const failures = [];
+    const observeFailure = failure => { if (failures.length < 16)
+        failures.push(failure); };
+    const host = await startCodexSetupNativeHost({ ...input,
         openJournal: async (scope) => {
             let vault;
             try {
@@ -2918,7 +2942,7 @@ export async function startCodexBootstrapNativeHost(input) {
                     // The original ALS scope selects the scoped LocalVault overload.
                     vault = await openBootstrapVault({ root });
                 });
-                completion = await createCodexBootstrapCompletionOwner(scope, vault);
+                completion = await createCodexBootstrapCompletionOwner(scope, vault, observeFailure);
                 ownerScope = scope;
                 return Object.freeze({
                     claim: (operationId, intentDigest) => vault.claimCodexSetupOperation(operationId, intentDigest),
@@ -2947,6 +2971,7 @@ export async function startCodexBootstrapNativeHost(input) {
                 return false;
             return completion.verify(receiptId, intent, digest);
         }, });
+    return Object.freeze({ ...host, get diagnostics() { return Object.freeze([...failures]); } });
 }
 async function bootstrap(flags, hostScope) {
     const step = (operation) => hostScope ? hostScope.step(operation) : operation();