@akagilnc/pi-workflow-roles 0.1.2152 → 0.1.2169

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

@@ -1,10 +1,11 @@
 /**
- * Durable Role run lifecycle for public CLI (ADR 0052 / #11 / #108).
+ * Durable Role run lifecycle for public CLI (ADR 0052 / #11 / #108 / #416).
  * States: admitted → running → resumable | terminal.
- * v1 resume is limited to an observed typed HTTP 429 on Codex/xAI with no
- * lawful role terminal result. Prose is never regex-classified as quota evidence.
+ * #416 (owner 2026-08-22): resume no longer gates on terminal/resumable or typed 429 —
+ * any existing run with an available Pi session principal may be resumed; caller decides.
+ * Prose is never regex-classified as quota evidence.
  */
-import { lstat, open, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { chmod, lstat, open, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 import {
@@ -38,7 +39,9 @@ import {
   type InvocationEffectiveModel,
 } from "./invocation.ts";
 
-/** Providers eligible for v1 typed-429 resume (Codex / xAI only). */
+/** Providers eligible for v1 typed-429 resume (Codex / xAI only).
+ * @deprecated v1 429-only gate removed by #416 (owner 2026-08-22: "根本不要有限制"). Kept for compatibility; do not use for new branching.
+ */
 export const V1_RESUMABLE_PROVIDERS = ["openai-codex", "xai"] as const;
 export type V1ResumableProvider = (typeof V1_RESUMABLE_PROVIDERS)[number];
 
@@ -49,6 +52,9 @@ export type TypedHttp429Observation = {
   readonly provider: V1ResumableProvider;
 };
 
+/** Per single LLM call auto-resume retries (call-local, no persistence). See #416 scope correction 2026-08-22. */
+export const AUTO_RESUME_LIMIT = 2 as const;
+
 export type RoleRunRecord = {
   readonly runId: string;
   readonly role:
@@ -69,7 +75,9 @@ export type RoleRunRecord = {
   readonly admittedRequestPath: string;
   /** Coder/Fixer — preserved for resume continuation. */
   readonly phase?: CoderPhase | FixerPhase;
-  /** Present only while state === "resumable". */
+  /** Present only while state === "resumable".
+   * @deprecated retained only for historical 429 runs; #416 no longer gates resume on this field.
+   */
   readonly resumable?: TypedHttp429Observation;
 };
 
@@ -79,12 +87,14 @@ export const RESUME_TRANSPORT_ENVELOPE = "[ak-role:resume-continue]" as const;
 const RUN_STATE_FILE = "run-state.json";
 const WRITER_LOCK_FILE = "writer.lock";
 
+/** @deprecated #416: 429-only classification removed; kept for compatibility. */
 export function isV1ResumableProvider(
   provider: string,
 ): provider is V1ResumableProvider {
   return (V1_RESUMABLE_PROVIDERS as readonly string[]).includes(provider);
 }
 
+/** @deprecated #416: 429-only observation no longer gates resume; kept for historical runs. */
 export async function readTypedHttp429Observation(
   runDirectory: string,
 ): Promise<TypedHttp429Observation | undefined> {
@@ -96,6 +106,7 @@ export async function readTypedHttp429Observation(
 }
 
 /**
+ * @deprecated #416: 429-only resumability predicate removed from gating. Kept for compatibility.
  * True only when a typed HTTP 429 was observed and no lawful terminal exists.
  * Callers must pass the lawful-terminal fact from settlement, not re-infer it.
  */
@@ -266,6 +277,7 @@ export async function markRunRunning(
   });
 }
 
+/** @deprecated #416: 429-only resumable marker; kept for historical runs. */
 export async function markRunResumable(
   runDirectory: string,
   observation: TypedHttp429Observation,
@@ -328,13 +340,52 @@ export type RunWriterLease = {
   release(): Promise<void>;
 };
 
+/**
+ * True error identity for diagnostics — name/code/message as-is, never a
+ * guessed label (failure-honesty constitution).
+ */
+function describeErrorIdentity(error: unknown): string {
+  const candidate = error as { name?: unknown; code?: unknown; message?: unknown };
+  const name =
+    typeof candidate?.name === "string" && candidate.name !== ""
+      ? candidate.name
+      : typeof error;
+  const code =
+    typeof candidate?.code === "string" || typeof candidate?.code === "number"
+      ? ` code=${String(candidate.code)}`
+      : "";
+  const message =
+    typeof candidate?.message === "string" && candidate.message !== ""
+      ? `: ${candidate.message}`
+      : "";
+  return `${name}${code}${message}`;
+}
+
 /**
  * Acquire the one-writer lease for a Role run. Concurrent acquire rejects
  * without dispatch. Exclusive create — no second writer.
+ *
+ * `onCleanupFailure` receives a non-terminal diagnostic line when release-time
+ * lock cleanup fails. Release stays best-effort (a stale lock resurfaces as
+ * RunWriterLeaseHeldError on next acquire), but the true error identity must
+ * still land somewhere observable — silent swallowing is forbidden.
  */
 export async function acquireRunWriterLease(
   runDirectory: string,
+  onCleanupFailure?: (diagnostic: string) => void,
 ): Promise<RunWriterLease> {
+  const reportCleanupFailure = (error: unknown): void => {
+    // Sink isolation: a throwing onCleanupFailure must not propagate through
+    // release() — release stays best-effort by contract. The true cleanup
+    // cause has already been handed to the sink as its argument.
+    try {
+      onCleanupFailure?.(
+        `writer lease lock cleanup failed (best-effort continue; stale lock resurfaces as lease-held on next acquire) at ${join(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`,
+      );
+    } catch {
+      // diagnostic-sink failure is itself best-effort; never break release().
+    }
+  };
   const lockPath = join(runDirectory, WRITER_LOCK_FILE);
   try {
     const handle = await open(lockPath, "wx");
@@ -352,7 +403,23 @@ export async function acquireRunWriterLease(
         if (released) return;
         released = true;
         await handle.close().catch(() => undefined);
-        await unlink(lockPath).catch(() => undefined);
+        try {
+          await unlink(lockPath);
+        } catch (error) {
+          if ((error as { code?: unknown }).code === "EACCES") {
+            try {
+              await chmod(runDirectory, 0o755);
+              await unlink(lockPath);
+            } catch (retryError) {
+              // best-effort cleanup: stale lock will surface as lease-held on next acquire (exit 2),
+              // but the true chmod/unlink cause must be recorded, not swallowed.
+              reportCleanupFailure(retryError);
+            }
+          } else {
+            // non-EACCES unlink failure is best-effort settlement cleanup; record true cause.
+            reportCleanupFailure(error);
+          }
+        }
       },
     };
   } catch (error) {
@@ -453,7 +520,7 @@ async function loadResumableRunRecord(
   runId: string,
 ): Promise<{
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  readonly observation?: TypedHttp429Observation;
   readonly admittedFields: LoadedAdmittedRequestFields;
 }> {
   const runDirectory = await findRunDirectoryById(home, runId);
@@ -464,12 +531,8 @@ async function loadResumableRunRecord(
   if (run === undefined) {
     throw new CliUsageError(`unknown role run id: ${runId}`);
   }
-  if (run.state === "terminal") {
-    throw new CliUsageError(`role run is already terminal: ${runId}`);
-  }
-  if (run.state !== "resumable" || run.resumable === undefined) {
-    throw new CliUsageError(`role run is not resumable: ${runId}`);
-  }
+  // #416: removed terminal/resumable gates per owner decision "根本不要有限制" (2026-08-22).
+  // Only the exact Pi session principal check remains as honest failure.
   // Exact Pi session principal must be present before resume dispatches.
   if (!(await isSessionPrincipalAvailable(run.sessionFile))) {
     throw new CliUsageError(
@@ -618,7 +681,7 @@ async function loadResumableRunRecord(
   }
   return {
     run,
-    observation: run.resumable,
+    ...(run.resumable === undefined ? {} : { observation: run.resumable }),
     admittedFields: {
       instruction,
       instructionEmpty,
@@ -641,25 +704,26 @@ async function loadResumableRunRecord(
 export type LoadedResumableJudgeRun = {
   readonly admitted: AdmittedJudgeInvocation;
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  /** @deprecated #416: resumable observation no longer gates resume; may be undefined. */
+  readonly observation?: TypedHttp429Observation;
 };
 
 export type LoadedResumableCoderRun = {
   readonly admitted: AdmittedCoderInvocation;
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  readonly observation?: TypedHttp429Observation;
 };
 
 export type LoadedResumableFixerRun = {
   readonly admitted: AdmittedFixerInvocation;
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  readonly observation?: TypedHttp429Observation;
 };
 
 export type LoadedResumableReviewerRun = {
   readonly admitted: AdmittedReviewerInvocation;
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  readonly observation?: TypedHttp429Observation;
 };
 
 /**
@@ -693,7 +757,7 @@ export async function loadResumableJudgeRun(
   return {
     admitted,
     run: loaded.run,
-    observation: loaded.observation,
+    ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
   };
 }
 
@@ -747,7 +811,7 @@ export async function loadResumableCoderRun(
   return {
     admitted,
     run: loaded.run,
-    observation: loaded.observation,
+    ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
   };
 }
 
@@ -806,7 +870,7 @@ export async function loadResumableFixerRun(
   return {
     admitted,
     run: loaded.run,
-    observation: loaded.observation,
+    ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
   };
 }
 
@@ -853,14 +917,14 @@ export async function loadResumableReviewerRun(
   return {
     admitted,
     run: loaded.run,
-    observation: loaded.observation,
+    ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
   };
 }
 
 export type LoadedResumableMergerRun = {
   readonly admitted: AdmittedMergerInvocation;
   readonly run: RoleRunRecord;
-  readonly observation: TypedHttp429Observation;
+  readonly observation?: TypedHttp429Observation;
 };
 
 /**
@@ -913,7 +977,7 @@ export async function loadResumableMergerRun(
   return {
     admitted,
     run: loaded.run,
-    observation: loaded.observation,
+    ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
   };
 }
 

package/src/public-cli/settlement.ts

@@ -4,7 +4,8 @@
  * Controlled failures and audit human decisions settle here without washing causes.
  */
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, open, readFile, readdir, writeFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { appendFile, lstat, mkdir, open, readFile, readdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
 import { isAuditEscalationResult } from "../audit-escalation.ts";
@@ -14,6 +15,7 @@ import { JUDGE_AUDIT_TOOL_NAME } from "../judge-auditor.ts";
 import { REVIEWER_AUDIT_TOOL_NAME } from "../reviewer-auditor.ts";
 import { knownFailureFromProviderStop, type ExplicitInternalKnownFailure, readReviewerDispatchRejection } from "./explicit-internal.ts";
 import {
+  RESUME_TRANSPORT_ENVELOPE,
   isV1ResumableProvider,
   readLatestTypedProviderHttpObservation,
   readTypedHttp429Observation,
@@ -725,12 +727,24 @@ export async function readBoundAuditorKnownFailure(
   }
   const parentId = parentEntries.find((entry) => entry.type === "session")?.id;
   if (parentId === undefined) return undefined;
+  const RESUME_ENVELOPE = RESUME_TRANSPORT_ENVELOPE;
+  const isResumeEnvelope = (msg: unknown): boolean => {
+    if (!isRecord(msg) || msg.role !== "user") return false;
+    const text = typeof msg.text === "string" ? msg.text : typeof (msg as { content?: unknown }).content === "string" ? (msg as { content: string }).content : undefined;
+    if (text === RESUME_ENVELOPE) return true;
+    const content = (msg as { content?: unknown }).content;
+    if (Array.isArray(content)) {
+      return content.some((p) => isRecord(p) && (p.text === RESUME_ENVELOPE || p.content === RESUME_ENVELOPE));
+    }
+    return false;
+  };
   let latestParentUserIndex = -1;
   for (let i = parentEntries.length - 1; i >= 0; i -= 1) {
-    if (parentEntries[i]?.type === "message" && parentEntries[i]?.message?.role === "user") {
-      latestParentUserIndex = i;
-      break;
-    }
+    const entry = parentEntries[i];
+    if (entry?.type !== "message" || entry.message?.role !== "user") continue;
+    if (isResumeEnvelope(entry.message)) continue;
+    latestParentUserIndex = i;
+    break;
   }
   const childDirectory = join(dirname(sessionFile), "auditor-roles");
   let names: string[];
@@ -740,6 +754,12 @@ export async function readBoundAuditorKnownFailure(
     if (isMissingPathError(error)) return undefined;
     throw sessionReadFailure(error, "failed to read bound auditor session directory");
   }
+  // Auto-resume seam (owner A): stale check must ignore resume envelope and
+  // prioritize retention. Previous `attemptEntryIndex < latest` discarded the
+  // first attempt's child after resume advanced latest, losing retentionFailure
+  // when retry had no compliance entry. Fix: ignore envelope for staleness and
+  // prefer any valid compliance failure before falling back to primary.
+  const validAuditorFiles: Array<{ file: string; entries: SessionEntry[]; attemptEntryId?: string }> = [];
   for (const file of names.filter((name) => name.endsWith(".jsonl")).sort().reverse()) {
     let entries: SessionEntry[];
     try {
@@ -754,7 +774,10 @@ export async function readBoundAuditorKnownFailure(
     const attemptEntryId = typeof bindingParent?.attemptEntryId === "string" ? bindingParent.attemptEntryId : undefined;
     const attemptEntryIndex = attemptEntryId === undefined ? -1 : parentEntries.findIndex((entry) => entry.id === attemptEntryId);
     if (bindingParent?.sessionId !== parentId || bindingParent.sessionFile !== sessionFile || attemptEntryIndex < latestParentUserIndex) continue;
-
+    validAuditorFiles.push({ file, entries, ...(attemptEntryId === undefined ? {} : { attemptEntryId }) });
+  }
+  // Prefer compliance failure (retention) from any valid attempt, newest first.
+  for (const { entries, attemptEntryId } of validAuditorFiles) {
     const stop = extractSessionProviderStop(entries);
     if (stop === undefined) continue;
     for (let i = entries.length - 1; i >= 0; i -= 1) {
@@ -774,6 +797,11 @@ export async function readBoundAuditorKnownFailure(
         ...(isRecord(failure.details) ? { details: failure.details } : {}),
       };
     }
+  }
+  // No compliance failure: fall back to most recent provider stop (auto-resume latest attempt).
+  for (const { entries } of validAuditorFiles) {
+    const stop = extractSessionProviderStop(entries);
+    if (stop === undefined) continue;
     const primary = knownFailureFromProviderStop(stop)!;
     return {
       ...primary,
@@ -1852,26 +1880,131 @@ async function ensureAuditEvidenceDirectory(runDirectory: string): Promise<strin
   return artifactsDir;
 }
 
-/** Publish the retained residual with exclusive, complete-write semantics. */
+/**
+ * #419 per-attempt process history. 史必追加，指针可覆盖；指针可以覆盖的前提是史已落。
+ * Reuses the run session principal's append-only JSONL custom-entry shape
+ * (plain custom entries are state records and never enter LLM context), so no
+ * second ledger mechanism is introduced.
+ */
+export const ATTEMPT_HISTORY_ENTRY_TYPE = "ak_run_attempt_history" as const;
+
+/** Complete per-attempt result as recorded in the appended history. */
+type AttemptHistoryOutcome =
+  | TerminalRoleOutcome
+  | ({ kind: "failure"; role: string } & ControlledFailure);
+
+type AttemptHistorySource = {
+  readonly role: string;
+  readonly runId: string;
+  readonly sessionFile: string;
+};
+
+/**
+ * Append one attempt's complete result to the run's session principal.
+ * Append failure throws — callers must not overwrite a pointer artifact when
+ * the history entry backing the overwrite did not land (fail closed).
+ */
+export async function appendRunAttemptHistory(
+  admitted: AttemptHistorySource,
+  outcome: AttemptHistoryOutcome,
+): Promise<void> {
+  const entries = await readBoundSessionEntries(admitted.sessionFile);
+  let parentId: string | null = null;
+  let priorEntries = 0;
+  for (const entry of entries) {
+    if (typeof entry.id === "string" && entry.type !== "session") parentId = entry.id;
+    if (
+      entry.type === "custom" &&
+      entry.customType === ATTEMPT_HISTORY_ENTRY_TYPE
+    ) {
+      priorEntries += 1;
+    }
+  }
+  const timestamp = new Date().toISOString();
+  // Shape mirrors pi SessionManager.appendCustomEntry.
+  const line = `${JSON.stringify({
+    type: "custom",
+    customType: ATTEMPT_HISTORY_ENTRY_TYPE,
+    data: {
+      sequence: priorEntries + 1,
+      role: admitted.role,
+      runId: admitted.runId,
+      recordedAt: timestamp,
+      outcome,
+    },
+    id: randomUUID(),
+    parentId,
+    timestamp,
+  })}\n`;
+  await appendFile(admitted.sessionFile, line, "utf8");
+}
+
+/**
+ * Publish the retained residual with complete-write semantics (#419: the
+ * previous attempt's pointer file is a rebuildable view once this attempt's
+ * complete result is in the appended history; planted symlinks/directories
+ * still fail loudly with their #182-A identities).
+ */
 export async function publishComplianceAuditIncompleteEvidence(
   admitted: AdmittedRoleInvocation,
   outcome: ReturnType<typeof buildAuditIncompleteTerminalOutcome>,
 ): Promise<TerminalArtifactRef> {
+  await appendRunAttemptHistory(admitted, outcome);
+  if (
+    typeof fsConstants.O_NOFOLLOW !== "number" ||
+    typeof fsConstants.O_NONBLOCK !== "number"
+  ) {
+    // #418 fail-closed: on platforms without O_NOFOLLOW (e.g. Windows,
+    // nodejs/node#41590) the JS bitwise-or below would silently drop the flag
+    // and the #182-A anti-symlink protection would vanish. Refuse loudly via
+    // the existing publication-failure channel instead of publishing
+    // unprotected; the complete attempt result above stays in appended history.
+    throw auditArtifactPublicationError(
+      "audit evidence publication requires O_NOFOLLOW|O_NONBLOCK open-flag support (anti-symlink/anti-planted protection must not be silently dropped); refusing to publish",
+      "ENOSYS",
+    );
+  }
   const artifactsDir = await ensureAuditEvidenceDirectory(admitted.runDirectory);
   const evidencePath = join(artifactsDir, "audit-incomplete.json");
+  let existing: Awaited<ReturnType<typeof lstat>> | undefined;
   try {
-    const existing = await lstat(evidencePath);
-    throw auditArtifactPublicationError(
-      existing.isSymbolicLink()
-        ? "audit evidence destination is a symlink"
-        : "audit evidence destination collision",
-      existing.isSymbolicLink() ? "ELOOP" : "EEXIST",
-    );
+    existing = await lstat(evidencePath);
   } catch (error) {
     if (!isMissingPathError(error)) throw error;
   }
-  const handle = await open(evidencePath, "wx", 0o600);
+  if (existing?.isSymbolicLink()) {
+    throw auditArtifactPublicationError(
+      "audit evidence destination is a symlink",
+      "ELOOP",
+    );
+  }
+  if (existing && !existing.isFile()) {
+    throw auditArtifactPublicationError(
+      "audit evidence destination is not a regular file",
+      "EEXIST",
+    );
+  }
+  // #182-A protection restored atomically at this open seam: O_NOFOLLOW makes
+  // the open itself refuse symlinks (ELOOP), so one swapped in after the lstat
+  // above can never be followed or written through; O_NONBLOCK keeps a
+  // race-planted FIFO from blocking this open forever. The fstat below
+  // backstops any non-regular object that wins the window.
+  const handle = await open(
+    evidencePath,
+    fsConstants.O_WRONLY |
+      fsConstants.O_CREAT |
+      fsConstants.O_TRUNC |
+      fsConstants.O_NOFOLLOW |
+      fsConstants.O_NONBLOCK,
+    0o600,
+  );
   try {
+    if (!(await handle.stat()).isFile()) {
+      throw auditArtifactPublicationError(
+        "audit evidence destination is not a regular file",
+        "EEXIST",
+      );
+    }
     await handle.writeFile(`${JSON.stringify(outcome, null, 2)}\n`, "utf8");
     await handle.sync();
   } finally {
@@ -2213,6 +2346,9 @@ export async function publishJudgeArtifacts(
   roleOutcome: TerminalRoleOutcome,
   sessionDirectory: string,
 ): Promise<TerminalArtifactRef[]> {
+  // #419: history first — report/evidence stay last-write-wins views only
+  // because every attempt's complete result has already been appended.
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2268,6 +2404,7 @@ export async function publishCoderArtifacts(
     readonly coderOutput?: CoderOutput;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2573,6 +2710,7 @@ export async function publishFixerArtifacts(
     readonly fixerOutput?: FixerOutput;
   },
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2732,6 +2870,7 @@ export async function publishCollectorArtifacts(
     readonly collectorReceipt?: CollectorReceipt;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2891,6 +3030,7 @@ export async function publishDoctorArtifacts(
     readonly doctorOutput?: DoctorOutput;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -3155,6 +3295,7 @@ export async function publishReviewerArtifacts(
     readonly reviewerReceipt?: RuntimeReviewerReceiptV2;
   },
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -3412,6 +3553,7 @@ export async function publishMergerArtifacts(
     readonly mergerOutput?: MergerOutput;
   },
 ): Promise<TerminalArtifactRef[]> {
+  await appendRunAttemptHistory(admitted, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -3746,6 +3888,19 @@ export async function publishFailureArtifacts(
   );
   const priorIssues: PublicationAttempt[] =
     baseAttempt === undefined ? [] : [baseAttempt];
+  // #419: each attempt's complete failure result joins the appended history
+  // before any fixed-name artifact view is rewritten. History failure must not
+  // strand the original controlled failure outside settlement — it rides
+  // publicationIssues instead of aborting durability.
+  try {
+    await appendRunAttemptHistory(admitted, {
+      kind: "failure",
+      role: admitted.role,
+      ...failure,
+    });
+  } catch (error) {
+    priorIssues.push(publicationAttemptFromError(admitted.sessionFile, error));
+  }
 
   // Prefer conventional names; unique fallback dirs keep colliding fixed paths
   // from stranding the original failure outside settlement. Include the ledger

package/src/public-cli/terminal.ts

@@ -231,11 +231,16 @@ export function redactExactRunId(text: string, runId: string): string {
  * One admitted Role run's typed Terminal aggregate.
  * Resumable failures carry `resume` and must not re-disclose the run ID via
  * top-level `runId` or public artifact path components — only `resume.command`.
+ * #416: autoResumeCount (0..2) is a call-local observation of how many in-place
+ * auto-resumes occurred during this single LLM call; it is not persisted to
+ * run-state.json and does not participate in limit decisions.
  */
 export type TerminalResult = {
   roleOutcome: TerminalRoleOutcome;
   navigator: TerminalNavigatorFact;
   artifacts: readonly TerminalArtifactRef[];
+  /** Call-local auto-resume observation (0..2) for this single LLM call; read-only, not persisted. */
+  autoResumeCount?: number;
 } & (
   | {
       /** Resumable failure: run ID appears only inside resume.command. */
@@ -330,5 +335,8 @@ export function formatTerminalResult(result: TerminalResult): string {
   } else if (result.runId !== undefined) {
     lines.push(`run\t${encodeTerminalField(result.runId)}`);
   }
+  if (result.autoResumeCount !== undefined) {
+    lines.push(`autoResumeCount\t${encodeTerminalField(String(result.autoResumeCount))}`);
+  }
   return `${lines.join("\n")}\n`;
 }