impel-cli 0.20.17 → 0.20.19

package/RELEASE_NOTES.md

@@ -1,5 +1,24 @@
 # Release notes
 
+## 0.20.19 — Recovered Codex stream accounting
+
+- Counts a zero-exit, completed Codex turn with a final agent message and one
+  native-agent start as successful even when the host reports transient stream
+  retry events before recovering.
+- Records recovered error-event counts separately in private attempt records
+  and aggregate analysis instead of silently discarding the successful sample.
+- Prevents generated Codex specialists from using collaboration messages to
+  report their terminal result, and refreshes already-fresh managed profiles
+  onto the tightened adapter instructions.
+
+## 0.20.18 — Recoverable Codex profiling cohorts
+
+- Widens the bounded retry window for transient current-tenant reads while
+  still rejecting an exact tenant mismatch before a Codex attempt starts.
+- Stops scheduling new work after an attempt-infrastructure failure, waits for
+  active workers to settle, and retains an explicitly incomplete private
+  aggregate so valid samples are not silently lost.
+
 ## 0.20.17 — Managed desktop task views
 
 - Enables the reviewed MCP Apps renderer only in exact managed Codex Desktop

package/package.json

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

package/scripts/analyze-native-codex.mjs

@@ -89,6 +89,7 @@ export function summarizeCodexEvents(events) {
   let outputTokens = 0;
   let turnCompleted = false;
   let errorEvents = 0;
+  let agentMessages = 0;
   let codeCells = 0;
   let codeWaits = 0;
 
@@ -102,6 +103,7 @@ export function summarizeCodexEvents(events) {
 
     const item = eventItem(event);
     const itemType = safeEventType(item.type);
+    if (type === "item.completed" && itemType === "agent_message") agentMessages += 1;
     const tool = eventTool(item);
     increment(toolCounts, tool);
     if (itemType && /(?:code_mode|command_execution|code_cell)/u.test(itemType)) codeCells += 1;
@@ -123,6 +125,7 @@ export function summarizeCodexEvents(events) {
     threadCount: threads.size,
     turnCompleted,
     errorEvents,
+    agentMessages,
     codeCells,
     codeWaits,
     inputTokens,
@@ -410,6 +413,8 @@ export function analyzeAggregates(aggregates) {
         timeout: attempts.filter((attempt) => attempt.timedOut).length,
         invalidJson: attempts.filter((attempt) => !attempt.jsonValid).length,
         descendantsRemaining: attempts.filter((attempt) => attempt.descendantsRemaining === true).length,
+        attemptsWithRecoveredErrors: successful.filter((attempt) => (attempt.errorEvents || 0) > 0).length,
+        recoveredErrorEvents: successful.reduce((total, attempt) => total + (attempt.errorEvents || 0), 0),
       },
     };
     report.gates = report.mode === "direct" ? directGate(report) : compatibleGate(report);

package/scripts/profile-native-codex.mjs

@@ -14,6 +14,7 @@ const PROFILE_SCHEMA = "impel.native-codex-profile.v1";
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
 const DEFAULT_GRACE_MS = 5_000;
 const MAX_CAPTURE_BYTES = 256 * 1024 * 1024;
+const TENANT_PREFLIGHT_RETRY_DELAYS_MS = [250, 750, 1_500];
 
 function privateDirectory(directory) {
   if (fs.existsSync(directory) && fs.lstatSync(directory).isSymbolicLink()) {
@@ -211,16 +212,17 @@ function runCaptured(command, args, { environment = process.env, timeoutMs = 60_
 }
 
 async function currentTenant(impelBinary, environment) {
-  for (let attempt = 0; attempt < 2; attempt += 1) {
+  for (let attempt = 0; attempt <= TENANT_PREFLIGHT_RETRY_DELAYS_MS.length; attempt += 1) {
     const invocation = impelInvocation(impelBinary, ["tenant", "current"], environment);
     const result = await runCaptured(invocation.command, invocation.args, { environment });
     const lines = result.stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
     if (result.code === 0 && lines.length === 1 && /^[A-Za-z0-9_.:-]{1,160}$/u.test(lines[0])) {
       return lines[0];
     }
-    if (attempt === 0) await delay(250);
+    const retryDelay = TENANT_PREFLIGHT_RETRY_DELAYS_MS[attempt];
+    if (retryDelay !== undefined) await delay(retryDelay);
   }
-  throw new Error("could not establish one exact current Impel tenant after two bounded attempts");
+  throw new Error("could not establish one exact current Impel tenant after bounded attempts");
 }
 
 export async function assertExpectedTenant({ expectedTenant, impelBinary = "impel", environment = process.env }) {
@@ -372,7 +374,7 @@ function parseArguments(argv) {
   return { ...options, help: false };
 }
 
-function safeAttemptRecord({ options, index, processResult, summary, jsonValid, parseError }) {
+export function safeAttemptRecord({ options, index, processResult, summary, jsonValid, parseError }) {
   const codex = summary?.codex || {};
   const telemetry = summary?.telemetry || {};
   const durationMs = processResult.endedAtMs - processResult.startedAtMs;
@@ -387,7 +389,7 @@ function safeAttemptRecord({ options, index, processResult, summary, jsonValid,
     && processResult.descendantsRemaining !== true
     && jsonValid
     && codex.turnCompleted === true
-    && (codex.errorEvents || 0) === 0
+    && (codex.agentMessages || 0) >= 1
     && (telemetry.localFailures || 0) === 0
     && startCalls === 1;
   return {
@@ -410,6 +412,8 @@ function safeAttemptRecord({ options, index, processResult, summary, jsonValid,
     parseFailureClass: parseError ? "invalid-jsonl" : null,
     success,
     eventCount: codex.eventCount || 0,
+    agentMessages: codex.agentMessages || 0,
+    errorEvents: codex.errorEvents || 0,
     threadCount: codex.threadCount || 0,
     toolCounts: codex.toolCounts || {},
     parentToolCounts: codex.parentToolCounts || {},
@@ -495,19 +499,38 @@ async function profileAttempt(options, sessionDir, index) {
   return record;
 }
 
-async function runWorkers(options, sessionDir) {
+function profilerFailureClass(error) {
+  if (/could not establish one exact current Impel tenant/u.test(error?.message || "")) {
+    return "tenant-preflight-unavailable";
+  }
+  if (/selected tenant .* does not match expected tenant/u.test(error?.message || "")) {
+    return "tenant-mismatch";
+  }
+  return "attempt-infrastructure";
+}
+
+export async function runWorkers(options, sessionDir, profileAttemptImpl = profileAttempt) {
   const results = new Array(options.attempts);
   let next = 0;
+  let abort = null;
   const worker = async () => {
     for (;;) {
+      if (abort) return;
       const index = next;
       next += 1;
       if (index >= options.attempts) return;
-      results[index] = await profileAttempt(options, sessionDir, index);
+      try {
+        results[index] = await profileAttemptImpl(options, sessionDir, index);
+      } catch (error) {
+        abort ||= {
+          failureClass: profilerFailureClass(error),
+          attemptId: `${options.cohort}-${String(index + 1 + options.attemptOffset).padStart(3, "0")}`,
+        };
+      }
     }
   };
   await Promise.all(Array.from({ length: options.concurrency }, () => worker()));
-  return results;
+  return { attempts: results.filter(Boolean), abort };
 }
 
 async function restoreTenant(originalTenant, options) {
@@ -553,7 +576,7 @@ async function main(argv) {
   privateDirectory(sessionDir);
   let restored = false;
   try {
-    const attempts = await runWorkers(options, sessionDir);
+    const result = await runWorkers(options, sessionDir);
     const aggregate = {
       schema: PROFILE_SCHEMA,
       sessionId,
@@ -564,12 +587,18 @@ async function main(argv) {
       cohort: options.cohort,
       cliVersion: options.hostBuild,
       promptSha256: options.promptSha256,
-      attempts,
+      complete: result.abort === null && result.attempts.length === options.attempts,
+      expectedAttempts: options.attempts,
+      abort: result.abort,
+      attempts: result.attempts,
     };
     const aggregatePath = path.join(sessionDir, "aggregate.json");
     privateWrite(aggregatePath, `${JSON.stringify(aggregate, null, 2)}\n`);
     process.stderr.write(`Private Codex profile written under ${sessionDir}\n`);
     process.stdout.write(`${JSON.stringify(aggregate)}\n`);
+    if (!aggregate.complete) {
+      throw new Error(`cohort aborted (${aggregate.abort?.failureClass || "incomplete"}); partial aggregate retained`);
+    }
   } finally {
     restored = await restoreTenant(originalTenant, options);
     if (!restored) process.stderr.write("profile-native-codex: could not verify restoration of the original tenant\n");

package/src/agents.js

@@ -52,7 +52,7 @@ export const NATIVE_AGENT_RUN_TOOL = "run_native_agent";
 export const NATIVE_AGENT_RESUME_TOOL = "resume_native_agent_run";
 export const NATIVE_AGENT_RECOVER_TOOL = "recover_native_agent_runs";
 export const MANAGED_AGENT_MCP_SERVER = "impel_agent";
-export const MANAGED_AGENT_MANIFEST_VERSION = 10;
+export const MANAGED_AGENT_MANIFEST_VERSION = 11;
 
 const NATIVE_AGENT_TOOL_NAMES = [
   NATIVE_AGENT_RUN_TOOL,
@@ -650,6 +650,7 @@ function codexAdapterInstructions(tenantId, agent) {
   const callerGuidance = usesVerbatimRelay(agent)
     ? adapterCallerSpawnGuidance("Codex")
     : null;
+  const collaborationConstraint = `Never call spawn_agent, wait_agent, send_message, followup_task, interrupt_agent, or any other collaboration tool. Communicate with the caller only by returning one final response after the native-agent transport reaches terminal.`;
   if (usesDirectAnswer(agent)) {
     const completionGuidance = usesVerbatimRelay(agent)
       ? adapterAnswerVerbatimCompletionGuidance()
@@ -657,6 +658,7 @@ function codexAdapterInstructions(tenantId, agent) {
     return [
       `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
       ...(callerGuidance ? [callerGuidance] : []),
+      collaborationConstraint,
       `Do not perform the assigned task yourself, do not delegate to any other agent, and do not independently synthesize the result.`,
       `Confirm that the assigned request fits the cataloged capabilities ${JSON.stringify(agent.capabilities)} and none of the exclusions ${JSON.stringify(agent.exclusions)} before answering.${contextRequirement}`,
       sideEffectInstruction,
@@ -671,6 +673,7 @@ function codexAdapterInstructions(tenantId, agent) {
   return [
     `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
     ...(callerGuidance ? [callerGuidance] : []),
+    collaborationConstraint,
     `Do not perform the assigned task yourself, do not delegate to any other agent, and do not independently synthesize or rewrite the result.`,
     `Confirm that the assigned request fits the cataloged capabilities ${JSON.stringify(agent.capabilities)} and none of the exclusions ${JSON.stringify(agent.exclusions)} before starting.${contextRequirement}`,
     sideEffectInstruction,
@@ -683,6 +686,7 @@ function codexAdapterInstructions(tenantId, agent) {
 function retiredAdapterInstructions(tenantId, agent) {
   return [
     `You are a recovery-only transport adapter for retired Impel native-agent binding ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
+    `Never call spawn_agent, wait_agent, send_message, followup_task, interrupt_agent, or any other collaboration tool. Communicate with the caller only by returning one final response after the native-agent transport reaches terminal.`,
     `You cannot start new work. Never call run_native_agent and never perform or recreate the assigned task yourself.`,
     `Call ${nativeToolName(NATIVE_AGENT_RECOVER_TOOL)} with {} to obtain integrity-validated pending handles for this fixed binding, then call ${nativeToolName(NATIVE_AGENT_RESUME_TOOL)} with the intended handle until it returns a terminal result. If multiple handles cannot be safely associated with the request, report them instead of choosing.`,
     `Return successful finalText byte-for-byte. For failure, return the preserved runId, output, and error without inventing a replacement result.`,