@akagilnc/pi-workflow-roles 0.1.1883 → 0.1.1918

package/src/navigator-attendance.ts

@@ -18,6 +18,12 @@ import { renderPublicAkRoleCommand } from "./public-command-renderer.ts";
 import { issueRoot, subjectPath } from "./work-subject-identity.ts";
 import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.ts";
 import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.ts";
+import { recordTypedProviderHttpStatus } from "./typed-provider-http.ts";
+import {
+  hasUpstreamErrorTestimony,
+  isNonSuccessHttpStatus,
+  projectConfirmedRemotePayload,
+} from "./upstream-error-testimony.ts";
 
 export const NAVIGATOR_EVENT_TYPE = "ak-navigator-attendance" as const;
 export const NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare" as const;
@@ -1092,19 +1098,37 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
       }
       assignProviderFailure(navigatorProviderFailureFromStatus(status));
     };
-    const humanProviderError = <T extends Record<string, unknown>>(error: T): T => {
-      const human = { ...error };
-      delete human.statusCode;
-      delete human.code;
-      delete human.navigatorFailure;
-      return human;
+    /** Project only fields actually held on the call surface — never forge upstream payload. */
+    const projectHeldUpstream = (error: unknown): Record<string, unknown> => {
+      if (!exactRecord(error)) return {};
+      // Shape reading stays local; testimony + confirmed-remote payload use shared authority.
+      const status = typeof error.statusCode === "number"
+        ? error.statusCode
+        : typeof error.status === "number"
+          ? error.status
+          : typeof error.httpStatus === "number"
+            ? error.httpStatus
+            : undefined;
+      const httpStatus = isNonSuccessHttpStatus(status) ? status : undefined;
+      const diagnostics = Array.isArray(error.diagnostics) && error.diagnostics.length > 0
+        ? error.diagnostics
+        : undefined;
+      const testimony = hasUpstreamErrorTestimony({
+        ...(httpStatus === undefined ? {} : { httpStatus }),
+        ...(diagnostics === undefined ? {} : { diagnostics }),
+      });
+      return {
+        ...(httpStatus === undefined ? {} : { statusCode: httpStatus, status: httpStatus }),
+        ...(diagnostics === undefined ? {} : { diagnostics }),
+        ...(testimony ? projectConfirmedRemotePayload(error) : {}),
+      };
     };
-    let providerFailureEvidenceNumber = 0;
-    let providerFailureEvidence: { id: string; error: unknown } | undefined;
-    const retainProviderFailure = (error: unknown): string => {
-      const id = `navigator-provider-failure-${++providerFailureEvidenceNumber}`;
-      providerFailureEvidence = { id, error };
-      return id;
+    /** Keep held upstream fields; strip only the local navigatorFailure classification marker. */
+    const retainUpstreamMessage = <T extends Record<string, unknown>>(error: T): T => {
+      if (!("navigatorFailure" in error)) return error;
+      const copy = { ...error };
+      delete copy.navigatorFailure;
+      return copy;
     };
     const setupFailureMessage = (error: unknown) => ({
       role: "assistant" as const,
@@ -1115,15 +1139,27 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
       usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
       stopReason: "error" as const,
       errorMessage: error instanceof Error ? error.message : String(error),
-      navigatorFailureEvidenceId: retainProviderFailure(error),
       timestamp: Date.now(),
+      ...projectHeldUpstream(error),
     });
+    const persistNavigatorHttpObservation = async (
+      status: number,
+      model: unknown,
+    ): Promise<void> => {
+      const runDir = process.env.AK_ROLE_RUN_DIR;
+      if (typeof runDir !== "string" || runDir.trim() === "") return;
+      const provider = exactRecord(model) && typeof model.provider === "string" && model.provider.trim() !== ""
+        ? model.provider
+        : undefined;
+      if (provider === undefined) return;
+      await recordTypedProviderHttpStatus(runDir, { httpStatus: status, provider });
+    };
     const instrumentProvider = <TProvider extends NonNullable<typeof provider>>(sourceProvider: TProvider): TProvider => {
       type StreamFn = TProvider["stream"];
       type StreamSimpleFn = TProvider["streamSimple"];
       type StreamOptionsArg = Parameters<StreamFn>[2];
       type StreamSimpleOptionsArg = Parameters<StreamSimpleFn>[2];
-      const instrumentStreamOptions = <TOptions>(options: TOptions): TOptions => {
+      const instrumentStreamOptions = <TOptions>(options: TOptions, observedStatus: { value?: number }): TOptions => {
         const record = (exactRecord(options) ? options : {}) as Record<string, unknown>;
         const previous = typeof record.onResponse === "function"
           ? record.onResponse as (response: { status: number; headers: Record<string, string> }, model: unknown) => void | Promise<void>
@@ -1131,12 +1167,23 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
         return {
           ...record,
           onResponse: async (response: { status: number; headers: Record<string, string> }, model: unknown) => {
+            observedStatus.value = response.status;
             classifyProviderResponseStatus(response.status);
+            // Durable run-dossier sink for typed non-success HTTP (2xx clears).
+            await persistNavigatorHttpObservation(response.status, model);
             await previous?.(response, model);
           },
         } as TOptions;
       };
-      const wrapProviderStream = (source: ReturnType<StreamFn>): ReturnType<StreamFn> => {
+      /** Attach a directly observed non-success HTTP status when the terminal message lacks one. */
+      const withObservedStatus = <T extends Record<string, unknown>>(message: T, observedStatus: number | undefined): T => {
+        if (observedStatus === undefined || observedStatus >= 200 && observedStatus < 300) return message;
+        if (typeof message.statusCode === "number" || typeof message.status === "number" || typeof message.httpStatus === "number") {
+          return message;
+        }
+        return { ...message, statusCode: observedStatus, status: observedStatus };
+      };
+      const wrapProviderStream = (source: ReturnType<StreamFn>, observedStatus: { value?: number }): ReturnType<StreamFn> => {
         const wrapped = createAssistantMessageEventStream();
         void (async () => {
           let result: Awaited<ReturnType<typeof source.result>> | undefined;
@@ -1147,13 +1194,14 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
                 sawTerminal = true;
                 if (event.type === "done" && exactRecord(event.message)) {
                   assignProviderFailure(navigatorProviderFailureFromDiagnostics(event.message.diagnostics));
-                  result = humanProviderError(event.message) as typeof event.message;
+                  // Keep held message/status/body/code/errno/diagnostics on the session surface.
+                  result = withObservedStatus(retainUpstreamMessage(event.message), observedStatus.value) as typeof event.message;
                   wrapped.push({ ...event, message: result });
                   continue;
                 }
                 if (event.type === "error" && exactRecord(event.error)) {
                   classifyProviderStreamError(event.error);
-                  result = humanProviderError(event.error) as typeof event.error;
+                  result = withObservedStatus(retainUpstreamMessage(event.error), observedStatus.value) as typeof event.error;
                   wrapped.push({ ...event, error: result });
                   continue;
                 }
@@ -1163,24 +1211,24 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
             // Only await result after a terminal done/error event. end(undefined) leaves result() unresolved forever.
             if (sawTerminal) {
               const terminal = await source.result();
-              if (result === undefined && exactRecord(terminal)) result = humanProviderError(terminal) as typeof terminal;
-              else if (result === undefined) result = terminal;
+              if (result === undefined && exactRecord(terminal)) {
+                result = withObservedStatus(retainUpstreamMessage(terminal), observedStatus.value) as typeof terminal;
+              } else if (result === undefined) result = terminal;
             }
           } catch (error) {
-            // Contract: README.md#Navigator-attendance — synthetic provider errors retain a stable pointer to the raw rejection while exposing only human-safe text.
+            // Stream throw: project held upstream fields onto the synthetic terminal message (session is durable).
             classifyProviderStreamError(error);
-            if (providerFailure === undefined) providerFailure = { source: "transport", cause: "transport" };
+            if (providerFailure === undefined) providerFailure = { source: "unknown", cause: "unknown" };
             if (!sawTerminal) {
-              const message = setupFailureMessage(error);
+              const message = withObservedStatus(setupFailureMessage(error), observedStatus.value);
               wrapped.push({ type: "error", reason: "error", error: message });
               result = message;
               sawTerminal = true;
             }
           } finally {
-            // No terminal stream event means the provider produced no response.
-            // Emit a synthetic error so callers do not hang waiting for done/error, and never await an unresolved source.result().
+            // No terminal stream event: unknown only — do not forge upstream payload.
             if (!sawTerminal) {
-              if (providerFailure === undefined) providerFailure = { source: "transport", cause: "transport" };
+              if (providerFailure === undefined) providerFailure = { source: "unknown", cause: "unknown" };
               const message = setupFailureMessage(new Error("Navigator provider produced no response"));
               wrapped.push({ type: "error", reason: "error", error: message });
               result = message;
@@ -1191,15 +1239,16 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
         })();
         return wrapped as ReturnType<StreamFn>;
       };
-      const invokeInstrumentedStream = (invoke: () => ReturnType<StreamFn>): ReturnType<StreamFn> => {
+      const invokeInstrumentedStream = (invoke: (observedStatus: { value?: number }) => ReturnType<StreamFn>): ReturnType<StreamFn> => {
         // Reset before invoking the selected provider so setup throws cannot leave a prior call's fact.
         providerFailure = undefined;
+        const observedStatus: { value?: number } = {};
         try {
-          return wrapProviderStream(invoke());
+          return wrapProviderStream(invoke(observedStatus), observedStatus);
         } catch (error) {
-          // Contract: README.md#Navigator-attendance — setup failures become terminal synthetic errors, with the raw rejection retained by stable evidence pointer.
+          // Setup failures become terminal synthetic errors with held upstream fields projected when present.
           classifyProviderStreamError(error);
-          if (providerFailure === undefined) providerFailure = { source: "transport", cause: "transport" };
+          if (providerFailure === undefined) providerFailure = { source: "unknown", cause: "unknown" };
           const wrapped = createAssistantMessageEventStream();
           const message = setupFailureMessage(error);
           queueMicrotask(() => {
@@ -1212,12 +1261,16 @@ export function createNativeNavigatorSessionFactory(defaultModelSettingPath = na
       return {
         ...sourceProvider,
         stream(model: Parameters<StreamFn>[0], streamContext: Parameters<StreamFn>[1], options: StreamOptionsArg) {
-          const instrumented = instrumentStreamOptions(options);
-          return invokeInstrumentedStream(() => sourceProvider.stream(model, streamContext, instrumented) as ReturnType<StreamFn>) as ReturnType<StreamFn>;
+          return invokeInstrumentedStream((observedStatus) => {
+            const instrumented = instrumentStreamOptions(options, observedStatus);
+            return sourceProvider.stream(model, streamContext, instrumented) as ReturnType<StreamFn>;
+          }) as ReturnType<StreamFn>;
         },
         streamSimple(model: Parameters<StreamSimpleFn>[0], streamContext: Parameters<StreamSimpleFn>[1], options: StreamSimpleOptionsArg) {
-          const instrumented = instrumentStreamOptions(options);
-          return invokeInstrumentedStream(() => sourceProvider.streamSimple(model, streamContext, instrumented) as ReturnType<StreamFn>) as ReturnType<StreamSimpleFn>;
+          return invokeInstrumentedStream((observedStatus) => {
+            const instrumented = instrumentStreamOptions(options, observedStatus);
+            return sourceProvider.streamSimple(model, streamContext, instrumented) as ReturnType<StreamFn>;
+          }) as ReturnType<StreamSimpleFn>;
         },
       } as TProvider;
     };

package/src/public-cli/cli.ts

@@ -61,6 +61,69 @@ export {
 export { CliUsageError } from "./cli-errors.ts";
 export type { CliIo } from "./cli-io.ts";
 
+/**
+ * Sole production map: public role command → argv parser.
+ * cli handlers consume this table; no parallel set.
+ */
+export const PUBLIC_ROLE_ARGV = {
+  judge: { parse: parseJudgeArgv },
+  coder: { parse: parseCoderArgv },
+  fixer: { parse: parseFixerArgv },
+  collector: { parse: parseCollectorArgv },
+  doctor: { parse: parseDoctorArgv },
+  merger: { parse: parseMergerArgv },
+  reviewer: { parse: parseReviewerArgv },
+} as const;
+
+type TakenPublicGlobalFlag =
+  | { flag: "help"; consume: 1 }
+  | { flag: "model"; consume: 1 | 2; value: string | undefined }
+  | { flag: "thinking"; consume: 1 | 2; raw: string | undefined };
+
+/**
+ * If `argv[index]` is a public global flag, describe its span and payload.
+ * Sole global-flag grammar for parseArgv.
+ */
+function takePublicGlobalFlag(
+  argv: readonly string[],
+  index: number,
+): TakenPublicGlobalFlag | undefined {
+  const token = argv[index];
+  if (token === undefined) return undefined;
+  if (token === "--help" || token === "-h") {
+    return { flag: "help", consume: 1 };
+  }
+  if (token === "--model") {
+    const value = argv[index + 1];
+    if (value === undefined) {
+      return { flag: "model", consume: 1, value: undefined };
+    }
+    return { flag: "model", consume: 2, value };
+  }
+  if (token.startsWith("--model=")) {
+    return {
+      flag: "model",
+      consume: 1,
+      value: token.slice("--model=".length),
+    };
+  }
+  if (token === "--thinking") {
+    const raw = argv[index + 1];
+    if (raw === undefined) {
+      return { flag: "thinking", consume: 1, raw: undefined };
+    }
+    return { flag: "thinking", consume: 2, raw };
+  }
+  if (token.startsWith("--thinking=")) {
+    return {
+      flag: "thinking",
+      consume: 1,
+      raw: token.slice("--thinking=".length),
+    };
+  }
+  return undefined;
+}
+
 export type CliEnv = {
   home?: string;
   agentDir?: string;
@@ -167,44 +230,38 @@ function parseArgv(argv: readonly string[]): ParsedGlobal {
 
   // Global flags may appear before or after the subcommand
   // (`ak-role --model x roles` and `ak-role roles --model x`).
+  // Grammar authority: takePublicGlobalFlag above.
   while (args.length > 0) {
-    const token = args.shift()!;
-    if (token === "--") {
+    if (args[0] === "--") {
+      args.shift();
       positional.push(...args);
       break;
     }
-    if (token === "--help" || token === "-h") {
-      help = true;
-      continue;
-    }
-    if (token === "--model") {
-      const value = args.shift();
-      if (value === undefined) throw new CliUsageError("--model requires a value");
-      model = value;
-      continue;
-    }
-    if (token.startsWith("--model=")) {
-      model = token.slice("--model=".length);
-      continue;
-    }
-    if (token === "--thinking") {
-      const value = args.shift();
-      if (value === undefined) throw new CliUsageError("--thinking requires a value");
-      thinking = parseThinking(value);
-      continue;
-    }
-    if (token.startsWith("--thinking=")) {
-      thinking = parseThinking(token.slice("--thinking=".length));
-      continue;
-    }
-    if (token.startsWith("-") && token !== "-") {
-      // Subcommands may own additional flags later; only reject unknowns at the
-      // top level when they appear before any positional command is collected
-      // and the command is one that does not accept free flags (enforced below).
-      positional.push(token);
+    const taken = takePublicGlobalFlag(args, 0);
+    if (taken !== undefined) {
+      if (taken.flag === "help") {
+        help = true;
+        args.splice(0, taken.consume);
+        continue;
+      }
+      if (taken.flag === "model") {
+        if (taken.value === undefined) {
+          throw new CliUsageError("--model requires a value");
+        }
+        model = taken.value;
+        args.splice(0, taken.consume);
+        continue;
+      }
+      if (taken.raw === undefined) {
+        throw new CliUsageError("--thinking requires a value");
+      }
+      thinking = parseThinking(taken.raw);
+      args.splice(0, taken.consume);
       continue;
     }
-    positional.push(token);
+    // Subcommands may own additional flags later; unknown dashed tokens stay
+    // positional here (same as pre-unification parseArgv).
+    positional.push(args.shift()!);
   }
 
   const [command, ...rest] = positional;
@@ -626,7 +683,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseJudgeArgv,
+        PUBLIC_ROLE_ARGV.judge.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -669,7 +726,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseCoderArgv,
+        PUBLIC_ROLE_ARGV.coder.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -712,7 +769,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseFixerArgv,
+        PUBLIC_ROLE_ARGV.fixer.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -755,7 +812,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseCollectorArgv,
+        PUBLIC_ROLE_ARGV.collector.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -798,7 +855,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseReviewerArgv,
+        PUBLIC_ROLE_ARGV.reviewer.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -841,7 +898,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseDoctorArgv,
+        PUBLIC_ROLE_ARGV.doctor.parse,
       );
       return {
         exitCode: result.exitCode,
@@ -884,7 +941,7 @@ export async function runAkRole(
           ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         },
         io,
-        parseMergerArgv,
+        PUBLIC_ROLE_ARGV.merger.parse,
       );
       return {
         exitCode: result.exitCode,

package/src/public-cli/coder-run.ts

@@ -41,11 +41,11 @@ import {
   markRunResumable,
   markRunRunning,
   markRunTerminal,
-  readTypedHttp429Observation,
   renderResumeCommand,
   RESUME_TRANSPORT_ENVELOPE,
   RunWriterLeaseHeldError,
   type RunWriterLease,
+  type TypedProviderHttpObservation,
 } from "./run-lifecycle.ts";
 import {
   classifyPostAdmissionFailure,
@@ -58,7 +58,9 @@ import {
   presentFailureTerminal,
   presentStructuralRejection,
   explicitInternalKnownFailureClassificationInput,
-  resolveAuditedRunnerKnownFailure,
+  resolveAuditedRunnerFailureResolution,
+  resolveControlledFailureResumeObservation,
+  controlledFailureInputFromResolution,
   settleFailureTerminalResult,
   trySettleCoderTerminalResult,
 } from "./settlement.ts";
@@ -196,6 +198,8 @@ async function presentControlledFailure(
       readonly code?: string | number;
     };
     knownDiagnostic?: string;
+    typedHttpObservationSettled?: true;
+    typedHttpObservation?: TypedProviderHttpObservation;
   },
   io: CliIo,
 ): Promise<{
@@ -204,10 +208,23 @@ async function presentControlledFailure(
   terminal: TerminalResult;
 }> {
   const hasThrown = Object.hasOwn(failureInput, "thrown");
+  const resumeObservation = await resolveControlledFailureResumeObservation({
+    runDirectory: admitted.runDirectory,
+    ...(failureInput.typedHttpObservationSettled === true
+      ? {
+        typedHttpObservationSettled: true as const,
+        ...(failureInput.typedHttpObservation === undefined
+          ? {}
+          : { typedHttpObservation: failureInput.typedHttpObservation }),
+      }
+      : {}),
+  });
+  const knownFailure =
+    failureInput.knownFailure ?? resumeObservation.observationReadFailure;
   const session =
     !hasThrown &&
     !failureInput.timedOut &&
-    failureInput.knownFailure === undefined &&
+    knownFailure === undefined &&
     failureInput.knownCause === undefined
       ? await inspectJudgeSession(admitted.sessionFile)
       : undefined;
@@ -216,7 +233,7 @@ async function presentControlledFailure(
     code: failureInput.code,
     stderr: failureInput.stderr,
     ...(hasThrown ? { thrown: failureInput.thrown } : {}),
-    ...explicitInternalKnownFailureClassificationInput(failureInput.knownFailure),
+    ...explicitInternalKnownFailureClassificationInput(knownFailure),
     ...(failureInput.knownCause === undefined
       ? {}
       : { knownCause: failureInput.knownCause }),
@@ -230,7 +247,7 @@ async function presentControlledFailure(
   });
 
   const hasLawfulTerminalResult = await hasLawfulCoderTerminalResult(admitted);
-  const typedHttp429 = await readTypedHttp429Observation(admitted.runDirectory);
+  const typedHttp429 = resumeObservation.typedHttp429;
   const sessionPrincipalAvailable = await isSessionPrincipalAvailable(
     admitted.sessionFile,
   );
@@ -296,8 +313,9 @@ async function dispatchAdmittedCoder(input: {
       PI_CODING_AGENT_DIR: env.agentDir,
       AK_ROLE_RUN_DIR: admitted.runDirectory,
     };
-    if (env.correlationId !== undefined && env.correlationId.trim() !== "") {
-      childEnv.AK_CORRELATION_ID = env.correlationId;
+    const correlationId = admitted.correlationId ?? env.correlationId;
+    if (correlationId !== undefined && correlationId.trim() !== "") {
+      childEnv.AK_CORRELATION_ID = correlationId;
     }
 
     let result: ExplicitInternalPiResult;
@@ -369,10 +387,11 @@ async function dispatchAdmittedCoder(input: {
       env.model,
       env.credentials,
     );
-    const knownFailure = await resolveAuditedRunnerKnownFailure({
+    const resolution = await resolveAuditedRunnerFailureResolution({
       runner: result.knownFailure,
       sessionFile: admitted.sessionFile,
       credential: credentialFailure,
+      runDirectory: admitted.runDirectory,
     });
     return await presentControlledFailure(
       admitted,
@@ -380,7 +399,7 @@ async function dispatchAdmittedCoder(input: {
         timedOut: result.timedOut,
         code: result.code,
         stderr: result.stderr,
-        ...(knownFailure === undefined ? {} : { knownFailure }),
+        ...controlledFailureInputFromResolution(resolution),
       },
       io,
     );
@@ -469,7 +488,10 @@ export async function runPublicCoder(
 
   return await dispatchAdmittedCoder({
     admitted,
-    env,
+    env: {
+      ...env,
+      ...(admitted.correlationId === undefined ? {} : { correlationId: admitted.correlationId }),
+    },
     io,
     extraArgs,
     lease,
@@ -563,7 +585,10 @@ export async function runPublicCoderResume(
 
   return await dispatchAdmittedCoder({
     admitted,
-    env,
+    env: {
+      ...env,
+      ...(admitted.correlationId === undefined ? {} : { correlationId: admitted.correlationId }),
+    },
     io,
     extraArgs,
     lease,

package/src/public-cli/collector-run.ts

@@ -211,8 +211,9 @@ async function dispatchAdmittedCollector(input: {
       PI_CODING_AGENT_DIR: env.agentDir,
       AK_ROLE_RUN_DIR: admitted.runDirectory,
     };
-    if (env.correlationId !== undefined && env.correlationId.trim() !== "") {
-      childEnv.AK_CORRELATION_ID = env.correlationId;
+    const correlationId = admitted.correlationId ?? env.correlationId;
+    if (correlationId !== undefined && correlationId.trim() !== "") {
+      childEnv.AK_CORRELATION_ID = correlationId;
     }
 
     let result: ExplicitInternalPiResult;
@@ -299,6 +300,7 @@ async function dispatchAdmittedCollector(input: {
             }),
       sessionFile: admitted.sessionFile,
       credential: credentialFailure,
+      runDirectory: admitted.runDirectory,
     });
     return await presentControlledFailure(
       admitted,
@@ -367,7 +369,10 @@ export async function runPublicCollector(
 
   return await dispatchAdmittedCollector({
     admitted,
-    env,
+    env: {
+      ...env,
+      ...(admitted.correlationId === undefined ? {} : { correlationId: admitted.correlationId }),
+    },
     io,
     extraArgs,
     lease,

package/src/public-cli/doctor-run.ts

@@ -280,6 +280,7 @@ async function dispatchAdmittedDoctor(input: {
       runner: result.knownFailure,
       sessionFile: admitted.sessionFile,
       credential: credentialFailure,
+      runDirectory: admitted.runDirectory,
     });
     return await presentControlledFailure(
       admitted,