impel-cli 0.20.11 → 0.20.13

package/RELEASE_NOTES.md

@@ -1,5 +1,22 @@
 # Release notes
 
+## 0.20.13 — Allocation publication race
+
+- Retries allocation when a competing process moves the published lock between
+  the expected create collision and inspection.
+- Prevents a harmless `ENOENT` publication race from escaping as an MCP error
+  or consuming an agent inference turn.
+- Adds a deterministic regression test for the exact production interleaving.
+
+## 0.20.12 — Internal admission retry
+
+- Absorbs brief local run-allocation lock contention inside the transport
+  instead of returning a model-visible busy error.
+- Keeps cancellation bounded while preserving the same single persisted
+  idempotency key and authoritative run identity.
+- Prevents a transient concurrency collision from adding a second agent tool
+  call or wrapper inference turn.
+
 ## 0.20.11 — Managed profile upgrade compatibility
 
 - Recognizes every discovery-root manifest from v2 through the current schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impel-cli",
-  "version": "0.20.11",
+  "version": "0.20.13",
   "description": "Prepare isolated Claude and Codex workspaces for every accessible Impel tenant",
   "type": "module",
   "bin": {

package/src/nativeAgentTransport.js

@@ -52,6 +52,8 @@ const DEFAULT_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
 const DEFAULT_MAX_STATE_BYTES = 512 * 1024;
 const DEFAULT_LOCK_LEASE_MS = 75_000;
 const DEFAULT_ADMISSION_LEASE_MS = 10_000;
+const DEFAULT_ADMISSION_RETRY_ATTEMPTS = 40;
+const DEFAULT_ADMISSION_RETRY_INTERVAL_MS = 25;
 const STATE_COMMIT_LEASE_MARGIN_MS = 5_000;
 const CIBI_START_IN_PROGRESS_CODE = "eve_run_drain_start_in_progress";
 const CIBI_START_IN_PROGRESS_MESSAGE = "The durable Eve drain workflow is still being enqueued; retry this idempotent start.";
@@ -167,6 +169,30 @@ function throwIfAborted(signal) {
   if (signal?.aborted) throw abortError();
 }
 
+function abortableDelay(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeout = null;
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      cleanup();
+      reject(abortError());
+    };
+    timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
+}
+
 function boundedAttachmentSignal(parentSignal, timeoutMs) {
   const controller = new AbortController();
   let timedOut = false;
@@ -1362,7 +1388,13 @@ export class NativeAgentCompositeTransport {
           throw error;
         }
         fs.rmSync(generationPath, { recursive: true, force: true });
-        const stat = fs.lstatSync(lockPath);
+        let stat;
+        try {
+          stat = fs.lstatSync(lockPath);
+        } catch (statError) {
+          if (statError?.code === "ENOENT") continue;
+          throw statError;
+        }
         if (stat.isSymbolicLink()) throw new Error("refusing to use symlinked native-agent run lock");
         let current = null;
         let legacy = null;
@@ -1660,11 +1692,15 @@ export class NativeAgentCompositeTransport {
     };
   }
 
-  allocateState(startArguments, { startMode = "durable" } = {}) {
+  async allocateState(startArguments, { startMode = "durable", signal } = {}) {
     let admission = null;
     try {
       this.ensureRoots();
-      admission = this.acquireAdmissionLock();
+      for (let attempt = 0; attempt < DEFAULT_ADMISSION_RETRY_ATTEMPTS; attempt += 1) {
+        admission = this.acquireAdmissionLock();
+        if (admission) break;
+        await abortableDelay(DEFAULT_ADMISSION_RETRY_INTERVAL_MS, signal);
+      }
       if (!admission) {
         throw new Error("native-agent run allocation is busy; retry without changing the request");
       }
@@ -1726,7 +1762,7 @@ export class NativeAgentCompositeTransport {
         ...(args.context !== undefined ? { context: args.context } : {}),
         contextKeys: args.contextKeys ?? [],
       }, prepared.agent);
-      state = this.allocateState(startArguments, { startMode: "answer" });
+      state = await this.allocateState(startArguments, { startMode: "answer", signal: attachment.signal });
       lock = this.acquireLock(state.invocationId);
       if (!lock) return handleForState(state);
       const result = await this.attach(state, prepared, {
@@ -1770,7 +1806,7 @@ export class NativeAgentCompositeTransport {
     try {
       const prepared = await this.prepareNewSession(attachment.signal);
       const startArguments = this.normalizeRunArguments(args, prepared.agent);
-      state = this.allocateState(startArguments);
+      state = await this.allocateState(startArguments, { signal: attachment.signal });
       // The durable identity and exact retry arguments exist before the first
       // upstream byte is sent.
       lock = this.acquireLock(state.invocationId);