@runuai/host 0.9.169 → 0.9.171

package/lib/credentials-activation-authority.ts

@@ -65,6 +65,14 @@
  * transition the authority does. Should saying so fail, the
  * runner is pending again, withdraws what it advertised, and says so later.
  *
+ * What stops the switch is said to the cloud as well as logged (`status`,
+ * on every capability frame; `onStatusChange` when it changes): the latest
+ * refusal or blocker, who gave it (the cloud's answer, or this runner), each
+ * blocker apart and every Compose project the retirement could not prove
+ * Uai's. A transient one (the container runtime still preparing after a
+ * reconnect, an unanswered ask) never replaces a substantive one: an
+ * operator reading Connections sees what to fix, not what fixes itself.
+ *
  * The record holds no secret: `{"schemaVersion":1,"step":"local",
  * "stopped":[{"taskId":"…","runEpoch":3}]}`. One the runner cannot read
  * counts as `local`, never as `legacy`: a damaged record may stand for a
@@ -88,6 +96,14 @@ import {
 import { dirname } from "node:path";
 
 import type { CredentialsActivationPhase } from "../src/cloud-credentials";
+import {
+  MAX_CREDENTIALS_SWITCH_BLOCKER_CHARS,
+  MAX_CREDENTIALS_SWITCH_BLOCKERS,
+  MAX_CREDENTIALS_SWITCH_DETAIL_CHARS,
+  MAX_CREDENTIALS_SWITCH_PROJECTS,
+  type CredentialsSwitchCapability,
+  type CredentialsSwitchStuck,
+} from "../src/protocol";
 import type { CredentialsMode } from "./cloud-credential-host";
 import type { RetirementPlan } from "./legacy-runtime-retirement";
 import { isSafeHostTaskId } from "./task-identity";
@@ -167,6 +183,12 @@ export interface ActivationAuthorityDeps<Retirement = RetirementPlan> {
   /** Ask the runner's supervisor for a restart. */
   restart: (why: string) => void;
   log: (line: string) => void;
+  /** `status()` changed: advertise it again. */
+  onStatusChange?: () => void;
+  /** What `status()` says of a blocker, made fit to leave the machine (the
+   *  home directory as `~`). */
+  redact?: (text: string) => string;
+  now?: () => number;
 }
 
 export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
@@ -191,6 +213,14 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
   #lastNote: string | null = null;
   /** Leaving the runner's own credentials failed in this process. */
   #stuck = false;
+  /** What stops the switch now, as `status()` says it. */
+  #blocker: CredentialsSwitchStuck | null = null;
+  /** Every Compose project the current blocker names, past the status's
+   *  bound too: what the log lists, and what tells one blocker from another
+   *  when only names past that bound changed. */
+  #blockerProjects = "";
+  /** `status()` as last told to `onStatusChange`'s caller. */
+  #published: string | null = null;
 
   constructor(deps: ActivationAuthorityDeps<Retirement>) {
     this.#deps = deps;
@@ -218,6 +248,13 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
     return this.#record?.step ?? null;
   }
 
+  /** Where the switch stands, for the capability frame (see the header). */
+  status(): CredentialsSwitchCapability {
+    const state = this.mode();
+    const stuck = state === "active" ? null : this.#blocker;
+    return stuck === null ? { state } : { state, stuck: { ...stuck } };
+  }
+
   mode(): CredentialsMode {
     if (this.#record === null) {
       return this.#initiallyPending ? "pending" : "legacy";
@@ -249,9 +286,12 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
   advance(): Promise<void> {
     if (this.#advancing === null) {
       this.#advancing = this.#advanceOnce()
-        .catch((error: unknown) => this.#note(`activation stopped: ${message(error)}; it tries again later`))
+        .catch((error: unknown) =>
+          this.#block("runner", error, `activation stopped: ${message(error)}; it tries again later`),
+        )
         .finally(() => {
           this.#advancing = null;
+          this.#publish();
         });
     }
     return this.#advancing;
@@ -266,10 +306,13 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
     }
     let plan: Retirement | null = null;
     if (this.#record === null) {
-      if (!this.#deps.eligible()) return;
-      const prepared = await this.#deps.ask("prepare");
+      if (!this.#deps.eligible()) {
+        this.#blocker = null;
+        return;
+      }
+      const prepared = await this.#ask("prepare");
       if (!prepared.ok) {
-        this.#note(`the cloud did not agree to cloud credentials yet: ${prepared.error}`);
+        this.#block("cloud", prepared.error, `the cloud did not agree to cloud credentials yet: ${prepared.error}`);
         return;
       }
       const paused = this.#deps.pauseLegacyStarts();
@@ -287,7 +330,9 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
         this.#record ??= readActivationRecord(this.#deps.recordPath);
         if (this.#record === null) {
           paused.resume();
-          this.#note(
+          this.#block(
+            "runner",
+            error,
             this.#initiallyPending
               ? `the v1-required task machine stays pending, with no v0 fallback: ${message(error)}`
               : `the runner stays on its own credentials, nothing changed: ${message(error)}`,
@@ -295,6 +340,7 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
           return;
         }
       }
+      this.#blocker = null;
       this.#deps.log("[credentials] switching to cloud credentials: leaving the runner's own");
     }
     if (!this.#synced()) return;
@@ -319,11 +365,16 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
       plan ??= await this.#deps.planRetirement();
       await this.#retire(plan);
       await this.#deps.claimFloor();
-      const committed = await this.#deps.ask("commit");
+      const committed = await this.#ask("commit");
       if (!committed.ok) {
-        this.#note(`the cloud did not record this runner's switch yet: ${committed.error}; it runs no task meanwhile`);
+        this.#block(
+          "cloud",
+          committed.error,
+          `the cloud did not record this runner's switch yet: ${committed.error}; it runs no task meanwhile`,
+        );
         return;
       }
+      this.#blocker = null;
       this.#write({ ...this.#record, step: "cloud" });
     }
     if (this.#record?.step === "cloud") {
@@ -350,7 +401,9 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
         this.#write(record);
       }
     } catch (error) {
-      this.#note(
+      this.#block(
+        "runner",
+        error,
         `the activation record is not known to be on disk yet (${message(error)}): the switch waits, running no task, ` +
           "until it is",
       );
@@ -373,7 +426,9 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
       try {
         await this.#deps.sweep();
       } catch (error) {
-        this.#note(
+        this.#block(
+          "runner",
+          error,
           `the recovery sweep failed (${message(error)}): the runner stays pending, running no task, and sweeps again later`,
         );
         return;
@@ -397,10 +452,15 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
     }
     if (failure === null) {
       this.#announced = true;
+      this.#blocker = null;
       this.#deps.log("[credentials] tasks run on cloud credentials");
       return;
     }
-    this.#note(`saying the runner is active failed (${message(failure)}): it is pending again, and tries again later`);
+    this.#block(
+      "runner",
+      failure,
+      `saying the runner is active failed (${message(failure)}): it is pending again, and tries again later`,
+    );
     try {
       this.#deps.onActiveWithdrawn();
     } catch (error) {
@@ -441,6 +501,67 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
     this.#durable = true;
   }
 
+  /** One phase asked of the cloud. An ask that could not be made or was not
+   *  answered says nothing about the switch: transient. */
+  async #ask(phase: CredentialsActivationPhase): Promise<ActivationAnswer> {
+    try {
+      return await this.#deps.ask(phase);
+    } catch (error) {
+      throw new TransientActivationError(message(error));
+    }
+  }
+
+  /** A refusal or blocker: logged, and what `status()` says unless it is
+   *  transient and a substantive one is already said (see the header). */
+  #block(by: CredentialsSwitchStuck["by"], why: unknown, line: string): void {
+    this.#note(line);
+    const transient = isTransient(why);
+    if (transient && this.#blocker !== null && this.#blocker.transient !== true) return;
+    const redact = this.#deps.redact ?? ((text: string) => text);
+    const detail = bounded(redact(oneLine(typeof why === "string" ? why : message(why))), MAX_CREDENTIALS_SWITCH_DETAIL_CHARS);
+    const next: CredentialsSwitchStuck = { by, detail, since: (this.#deps.now ?? Date.now)() };
+    const structured = why as { blockers?: unknown; unprovenProjects?: unknown } | null;
+    const blockers = stringList(structured?.blockers);
+    if (blockers.length > 0) {
+      next.blockers = blockers
+        .slice(0, MAX_CREDENTIALS_SWITCH_BLOCKERS)
+        .map((blocker) => bounded(redact(oneLine(blocker)), MAX_CREDENTIALS_SWITCH_BLOCKER_CHARS));
+    }
+    const projects = stringList(structured?.unprovenProjects);
+    if (projects.length > 0) {
+      next.composeProjects = { names: projects.slice(0, MAX_CREDENTIALS_SWITCH_PROJECTS), total: projects.length };
+    }
+    if (transient) next.transient = true;
+    const previous = this.#blocker;
+    const allProjects = projects.join(" ");
+    // The same blocker again keeps when it was first seen. "The same" counts
+    // every project, not only the ones the status has room for.
+    if (previous !== null && sameBlocker(previous, next) && allProjects === this.#blockerProjects) return;
+    this.#blocker = next;
+    this.#blockerProjects = allProjects;
+    // The status names at most MAX_CREDENTIALS_SWITCH_PROJECTS, and the
+    // line above is cut short: the log names every one, once per blocker,
+    // for the operator Connections sends here for the rest.
+    if (projects.length > 0) {
+      this.#deps.log(
+        `[credentials] Compose projects nothing proves Uai's (${projects.length}), each to remove ` +
+          `(docker compose -p <name> down) or rename: ${allProjects}`,
+      );
+    }
+  }
+
+  /** `onStatusChange` when `status()` says something new. */
+  #publish(): void {
+    const now = JSON.stringify(this.status());
+    if (now === this.#published) return;
+    this.#published = now;
+    try {
+      this.#deps.onStatusChange?.();
+    } catch (error) {
+      this.#note(`advertising the switch's status failed: ${message(error)}`);
+    }
+  }
+
   /** The same note twice in a row is logged once: a refusal is asked about
    *  again every few minutes. */
   #note(line: string): void {
@@ -450,6 +571,33 @@ export class CredentialsActivationAuthority<Retirement = RetirementPlan> {
   }
 }
 
+class TransientActivationError extends Error {
+  readonly transient = true;
+}
+
+function isTransient(why: unknown): boolean {
+  return why !== null && typeof why === "object" && (why as { transient?: unknown }).transient === true;
+}
+
+function sameBlocker(a: CredentialsSwitchStuck, b: CredentialsSwitchStuck): boolean {
+  const { since: _a, ...left } = a;
+  const { since: _b, ...right } = b;
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function stringList(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item !== "") : [];
+}
+
+function oneLine(text: string): string {
+  return text.replace(/\s*\n\s*(?:- )?/g, "; ").trim();
+}
+
+function bounded(text: string, max: number): string {
+  const nonEmpty = text === "" ? "unknown" : text;
+  return nonEmpty.length <= max ? nonEmpty : `${nonEmpty.slice(0, max - 1)}…`;
+}
+
 /** The record; null when there is none. One the runner cannot read is
  *  `local` with nothing owed (see the header). */
 export function readActivationRecord(path: string): ActivationRecord | null {

package/lib/legacy-runtime-retirement.ts

@@ -22,7 +22,12 @@
  *   isolation), and which the operator removes or renames. A row with no
  *   runtime (a task that went down keeps its row, its runtime fields
  *   cleared) neither blocks nor vouches for anything. The plan records the
- *   engine it was made against.
+ *   engine it was made against. Its rejection is a `RetirementBlockedError`:
+ *   each blocker apart, and every unproven project named, so the cloud can
+ *   show the operator all of them with the command that clears each
+ *   (ADR-154 §13 build notes, 2026-10-27). Such a project is never removed
+ *   here: a Compose label proves neither who made a stack nor that nothing
+ *   uses it now (another runner may share this Docker and workspace root).
  * - `retireLegacyTaskRuntimes` carries a plan out, only after the runner has
  *   committed to the switch. Each task's check, Stop and removal share its
  *   lifecycle slot: before its assignment closes and again before anything
@@ -117,6 +122,26 @@ export interface RetirementDeps extends RetirementPlanDeps {
   log: (line: string) => void;
 }
 
+/**
+ * The plan's refusal: every blocker apart (`blockers`), and apart from them
+ * the `task-*` Compose projects nothing proves Uai's (all of them, for the
+ * operator to remove or rename). The message names both, as the log has.
+ * `transient`: nothing is wrong yet, the runner only cannot look now (its
+ * container runtime is still preparing); the next attempt looks again.
+ */
+export class RetirementBlockedError extends Error {
+  readonly blockers: string[];
+  readonly unprovenProjects: string[];
+  readonly transient: boolean;
+  constructor(message: string, options: { blockers?: string[]; unprovenProjects?: string[]; transient?: boolean } = {}) {
+    super(message);
+    this.name = "RetirementBlockedError";
+    this.blockers = options.blockers ?? [];
+    this.unprovenProjects = options.unprovenProjects ?? [];
+    this.transient = options.transient === true;
+  }
+}
+
 export interface RetirementReport {
   /** Tasks whose runtime is gone (or was already). */
   retired: string[];
@@ -136,8 +161,9 @@ export async function planLegacyTaskRuntimeRetirement(deps: RetirementPlanDeps):
   const blockers: string[] = [];
   const snapshot = deps.snapshot();
   if (snapshot.runtimeProblem !== null || snapshot.machine === null) {
-    throw new Error(
+    throw new RetirementBlockedError(
       `task runtimes cannot be retired now: the container runtime is not ready (${snapshot.runtimeProblem ?? "no engine is pinned"})`,
+      { transient: true },
     );
   }
   if (!snapshot.fence.ok) blockers.push(snapshot.fence.detail ?? "the task rows do not match the pinned container runtime");
@@ -183,6 +209,7 @@ export async function planLegacyTaskRuntimeRetirement(deps: RetirementPlanDeps):
   }
 
   const appleOrphans: string[] = [];
+  const unprovenProjects: string[] = [];
   try {
     if (deps.apple) {
       const named = new Set(rows.map((task) => `task-${task.taskId}-app`));
@@ -193,18 +220,26 @@ export async function planLegacyTaskRuntimeRetirement(deps: RetirementPlanDeps):
       const named = new Set(rows.map((task) => `task-${task.taskId}`));
       for (const project of await listTaskProjects(deps.docker)) {
         if (named.has(project)) continue;
-        blockers.push(
-          `Compose project ${project} has containers but no task on this runner: nothing proves it Uai's, so it is not removed. ` +
-            `If it was a task's, remove it (docker compose -p ${project} down); otherwise rename it`,
-        );
+        unprovenProjects.push(project);
       }
     }
   } catch (error) {
     blockers.push(`the task runtime inventory failed: ${message(error)}`);
   }
 
-  if (blockers.length > 0) {
-    throw new Error(`task runtimes cannot all be retired: ${blockers.join("; ").slice(0, 1500)}`);
+  if (blockers.length > 0 || unprovenProjects.length > 0) {
+    const all = [
+      ...blockers,
+      ...unprovenProjects.map(
+        (project) =>
+          `Compose project ${project} has containers but no task on this runner: nothing proves it Uai's, so it is not removed. ` +
+          `If it was a task's, remove it (docker compose -p ${project} down); otherwise rename it`,
+      ),
+    ];
+    throw new RetirementBlockedError(`task runtimes cannot all be retired: ${all.join("; ").slice(0, 1500)}`, {
+      blockers,
+      unprovenProjects,
+    });
   }
   return { machine: snapshot.machine, removals, appleOrphans };
 }

package/lib/orchestrator.ts

@@ -40,6 +40,7 @@ import { inArray } from "drizzle-orm";
 
 import { getDb, schema } from "./db";
 import { newId } from "./ulid";
+import { agentErrorMessage, reportAgentError } from "./agent-errors";
 import { mockAgentFactory } from "./agents/mock";
 import { realAgentFactory } from "./agents/factory";
 import { resolveAgentMode } from "./agents/mode";
@@ -50,6 +51,7 @@ import {
 } from "./agents/session-state";
 import {
   type AgentEvent,
+  type AgentEventHandler,
   type AgentSession,
   type AgentSessionFactory,
   type Roster,
@@ -709,7 +711,11 @@ const BROWSER_RETRY_COOLDOWN_MS = 60_000;
  * poisons the runtime generation synchronously; normal detection/recovery owns
  * the eventual ready edge and deferred-prompt replay.
  */
-async function agentTerminationLostContainerRuntime(): Promise<boolean> {
+async function agentTerminationLostContainerRuntime(channel: Channel): Promise<boolean> {
+  // Machine/self tasks have no Docker/Apple daemon. A failed Docker probe
+  // there would turn a real engine failure into silent runtime recovery.
+  if (isEnvironmentTransportProvider(channel.agentHandle?.descriptor.locator.provider) ||
+    isEnvironmentTransportProvider(getHostTask(channel.taskId)?.environmentProvider)) return false;
   if (!backgroundContainerWorkAllowed()) return true;
   let reachable = false;
   try {
@@ -809,6 +815,7 @@ export interface OrchestratorTaskStopResult {
 }
 
 export class Orchestrator {
+  private readonly sessionEventHandlers = new WeakMap<AgentSession, AgentEventHandler>();
   private readonly channels = new Map<string, Channel>();
   private readonly channelSpecs = new Map<string, ChannelEnsureInput>();
   /** Teardown tombstones prevent a cloud ensure from reopening a task between
@@ -2915,7 +2922,7 @@ export class Orchestrator {
     // transport emission order across that await; otherwise the later boundary
     // can consume/reorder prompt state while the earlier error still owns it.
     let eventTail: Promise<void> = Promise.resolve();
-    session.onEvent((event) => {
+    const onEvent: AgentEventHandler = (event) => {
       this.markChannelActivity(channel.taskId);
       // Recycle/teardown deletes the old session before calling close().
       // Adapters deliberately emit a final exit event; without this identity
@@ -2957,7 +2964,9 @@ export class Orchestrator {
         () => channel.eventOperations.delete(operation),
         () => channel.eventOperations.delete(operation),
       );
-    });
+    };
+    this.sessionEventHandlers.set(session, onEvent);
+    session.onEvent(onEvent);
   }
 
   /**
@@ -4616,11 +4625,11 @@ export class Orchestrator {
     }
   }
 
-  /** Consume one queued/active turn and report how many remain. */
-  private decrementActiveTurns(channel: Channel, agentId: string): number {
+  /** Consume deliveries settled by one provider boundary. */
+  private decrementActiveTurns(channel: Channel, agentId: string, settles = 1): number {
     const remaining = Math.max(
       0,
-      (channel.activeTurns.get(agentId) ?? 1) - 1,
+      (channel.activeTurns.get(agentId) ?? 1) - settles,
     );
     if (remaining === 0) channel.activeTurns.delete(agentId);
     else channel.activeTurns.set(agentId, remaining);
@@ -4759,26 +4768,29 @@ export class Orchestrator {
     this.incrementActiveTurns(channel, agentId);
     void session.send(text).catch((err: unknown) => {
       if (turn) journal?.failed(sessionId, turn.turnId);
+      const diagnosticMessage = `Could not send the message to ${agentId}: ${err instanceof Error ? err.message : String(err)}`;
+      reportAgentError(diagnosticMessage, { taskId: channel.taskId, agentId, engine: session.kind },
+        { capture: !(err instanceof ContainerRuntimeUnavailableError) });
       if (channel.sessions.get(agentId) === session) {
-        this.removeAcceptedPrompt(channel, agentId, accepted);
-        const remaining = this.decrementActiveTurns(channel, agentId);
-        if (
-          remaining === 0 &&
-          channel.lastPrompt.get(agentId) === accepted
-        ) {
-          channel.lastPrompt.delete(agentId);
-        }
         if (err instanceof ContainerRuntimeUnavailableError) {
+          this.removeAcceptedPrompt(channel, agentId, accepted);
+          const remaining = this.decrementActiveTurns(channel, agentId);
+          if (remaining === 0 && channel.lastPrompt.get(agentId) === accepted) {
+            channel.lastPrompt.delete(agentId);
+          }
           this.deferPromptUntilRuntimeReady(channel, agentId, accepted);
         } else {
-          this.startNextPendingPrompt(channel, agentId);
+          // Share the ordered terminal-event path with adapter failures. It
+          // retires the active count and publishes the error/aborted boundary;
+          // a concurrent adapter error or exit can consume it only once.
+          this.sessionEventHandlers.get(session)?.({
+            type: "error",
+            message: agentErrorMessage(diagnosticMessage),
+            diagnosticMessage,
+            aborted: true,
+          });
         }
       }
-      console.warn(
-        `[orchestrator] ${channel.taskId}/${agentId}: send failed: ${
-          err instanceof Error ? err.message : String(err)
-        }`,
-      );
     });
   }
 
@@ -4794,13 +4806,14 @@ export class Orchestrator {
     if (prompts.length === 0) channel.acceptedPrompts.delete(agentId);
   }
 
-  private completeNextAcceptedPrompt(
+  private completeAcceptedPrompts(
     channel: Channel,
     agentId: string,
+    settles = 1,
   ): void {
     const prompts = channel.acceptedPrompts.get(agentId);
     if (!prompts) return;
-    prompts.shift();
+    prompts.splice(0, settles);
     if (prompts.length === 0) channel.acceptedPrompts.delete(agentId);
   }
 
@@ -5257,8 +5270,13 @@ export class Orchestrator {
         });
         break;
       }
+      case "notice": {
+        this.emitSystemNote(channel.taskId, agentErrorMessage(`${agentId}: ${event.message}`));
+        break;
+      }
       case "error": {
-        if (await agentTerminationLostContainerRuntime()) {
+        const diagnosticMessage = event.diagnosticMessage ?? event.message;
+        if (await agentTerminationLostContainerRuntime(channel)) {
           // `error` and `exit` can arrive back-to-back while the daemon probe
           // is pending. Only the first terminal event still owns this session.
           if (channel.sessions.get(agentId) !== session) break;
@@ -5272,7 +5290,7 @@ export class Orchestrator {
         if (channel.sessions.get(agentId) !== session) break;
         // The turn died with the session — drop its turn-state flags so a
         // respawned session starts clean.
-        const abortBoundaryOnRosterChange =
+        let abortBoundaryOnRosterChange =
           this.needsAbortedTurnBoundary(channel, agentId);
         this.retainRetiredTurnBoundary(
           channel,
@@ -5280,6 +5298,14 @@ export class Orchestrator {
           abortBoundaryOnRosterChange,
         );
         this.retireRunnerGeneration(channel, agentId);
+        if (event.aborted) {
+          this.emitRetiredTurnAbort(channel, agentId);
+          const change = channel.rosterSessionChanges.get(agentId);
+          if (change) change.abortPublished = true;
+          // A recovery may replay the prompt, but the failed turn already
+          // ended. Do not publish a second boundary for this generation.
+          abortBoundaryOnRosterChange = false;
+        }
         // Claude under load (especially Docker Desktop macOS) occasionally
         // unlinks ~/.claude.json mid-write during atomic config rewrites,
         // and a concurrent claude spawn lands during the gap and exits 0
@@ -5325,7 +5351,7 @@ export class Orchestrator {
         if (
           agent &&
           agent.kind !== "claude" &&
-          isCredentialInvalidSignal(agent.kind, event.message)
+          isCredentialInvalidSignal(agent.kind, diagnosticMessage)
         ) {
           console.warn(
             `[orchestrator] ${channel.taskId}/${agentId}: ${agent.kind} credential-invalid pattern matched: ${event.message.slice(0, 300)}`,
@@ -5407,7 +5433,7 @@ export class Orchestrator {
           }
         }
         const isClaude = agent?.kind === "claude";
-        if (isClaude && agent && isClaudeAuthRevoked(event.message)) {
+        if (isClaude && agent && isClaudeAuthRevoked(diagnosticMessage)) {
           // Token revoked/expired: the env-injected credential only changes on
           // a fresh runner. Re-spawn on the re-resolved account (picks up a
           // reconnected token); bounded so a still-bad token can't loop.
@@ -5424,7 +5450,7 @@ export class Orchestrator {
           break;
         }
         const configMissing = CLAUDE_CONFIG_MISSING_PATTERNS.some((re) =>
-          re.test(event.message),
+          re.test(diagnosticMessage),
         );
         if (isClaude && configMissing) {
           // This recovery path deliberately starts the next queued turn rather
@@ -5439,7 +5465,7 @@ export class Orchestrator {
           break;
         }
         channel.lastPrompt.delete(agentId);
-        channel.retiredTurnBoundaries.delete(agentId);
+        this.emitRetiredTurnAbort(channel, agentId);
         this.emitHost({
           kind: "agent.exit",
           taskId: channel.taskId,
@@ -5469,9 +5495,11 @@ export class Orchestrator {
         // turn's messages and wakes the mentioned peers with the full turn.
         // An interrupted (ESC'd) turn goes out `aborted`: it's a half-turn, so
         // the cloud discards the buffer instead of handing it to peers.
-        const aborted = channel.interrupted.delete(agentId);
-        this.completeNextAcceptedPrompt(channel, agentId);
-        const remainingTurns = this.decrementActiveTurns(channel, agentId);
+        const aborted = channel.interrupted.delete(agentId) || event.aborted === true;
+        const settles = event.settles !== undefined && Number.isSafeInteger(event.settles) && event.settles > 0
+          ? event.settles : 1;
+        this.completeAcceptedPrompts(channel, agentId, settles);
+        const remainingTurns = this.decrementActiveTurns(channel, agentId, settles);
         channel.openTurns.delete(agentId);
         // ADR-076: a turn that completed means the current account is healthy —
         // reset its rotation budget so a LATER rate-limit gets a fresh failover.
@@ -5522,7 +5550,15 @@ export class Orchestrator {
         break;
       }
       case "exit":
-        if (await agentTerminationLostContainerRuntime()) {
+        if (event.code === 0 && this.needsAbortedTurnBoundary(channel, agentId)) {
+          await this.handleAgentEvent(channel, agentId, session, {
+            type: "error",
+            message: `${session.kind} stopped before replying to the message. Please try again.`,
+            aborted: true,
+          });
+          break;
+        }
+        if (await agentTerminationLostContainerRuntime(channel)) {
           if (channel.sessions.get(agentId) !== session) break;
           await this.retireSessionForRuntimeLoss(
             channel,
@@ -7319,7 +7355,10 @@ export function buildSystemPreamble(
         `${taskBranch}\` from inside the project, then open a PR with \`gh pr`,
         "create` (the container has gh authenticated). For multi-project",
         "tasks, each project's PR is independent — open one per project whose",
-        "worktree you actually changed.",
+        "worktree you actually changed. For a separate branch, create it in",
+        "this task's namespace — `git switch -c \"$(uai branch name fix-foo)\"`",
+        "makes `uai/<taskId>/fix-foo`. Only task-branch and namespace PRs link to",
+        "this task (reviews, `--pr`, Usage); a PR from any other branch does not.",
         "",
         "The `.uai/` directory under each task is uai's own scaffolding",
         "(rendered Dockerfile, compose file, container scripts) — it is NOT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.169",
+  "version": "0.9.171",
   "description": "Uai host \u2014 runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/src/main.ts

@@ -784,6 +784,9 @@ const credentialsActivation = new CredentialsActivationAuthority<CredentialsReti
     requestManagedHostRestart();
   },
   log: (line) => console.warn(line),
+  // What stops the switch reaches the cloud too, not only this log.
+  onStatusChange: () => sendCapabilities(),
+  redact: redactHomeDirectory,
 });
 setCredentialsModeSource(() => credentialsActivation.mode());
 /** ADR-154 §13: the steady/operator cadence. Active runners report their
@@ -1581,9 +1584,18 @@ function buildCapabilities(): HostCapabilities {
     engineAccounts: engineAccountSummaries(),
     engines: engineCatalogCapabilities(),
     githubUsers: connectedUserIds(),
+    // ADR-154 §13: where the switch to cloud credentials stands, and why.
+    credentialsSwitch: credentialsActivation.status(),
   };
 }
 
+/** A path under the home directory, as `~/…`: a status line leaves the
+ *  machine, and the account name in a path is not the cloud's to keep. */
+function redactHomeDirectory(text: string): string {
+  const home = homedir();
+  return home.length > 1 ? text.split(home).join("~") : text;
+}
+
 // engineCliStatuses probes binaries asynchronously; capabilities build
 // synchronously. The snapshot starts empty (cliInstalled: false) and each
 // build kicks a refresh that re-advertises only when the answer changed.