@akagilnc/pi-workflow-roles 0.1.5614 → 0.1.5650

package/src/acp-host/role-turn-host.ts

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 
 import type { RoleTurnHost, RoleTurnRequest, RoleTurnResult } from "../host-contracts.ts";
-import { sessionDirectoryOf } from "../role-run-placement.ts";
+import { sessionDirectoryOf, sessionFileOf } from "../role-run-placement.ts";
 import {
   createSerializedRoleTurnHost,
   driveExternalRoleTurnRounds,
@@ -10,9 +10,12 @@ import {
   externalHostFailure as failure,
   raceAgainstHostAbort,
   recordTurnDelivery,
+  retainPackageFaultBesideLivePlacement,
+  syncTurnRequestLivePlacement,
+  trySyncTurnRequestLivePlacement,
 } from "../external-host-turn-loop.ts";
 import { describeErrorIdentity } from "../public-cli/run-lifecycle.ts";
-import { projectThrownFailureLeaf, retainPackageFault } from "../public-cli/settlement.ts";
+import { projectThrownFailureLeaf } from "../public-cli/settlement.ts";
 
 import {
   copyAndRecordHostDossier,
@@ -260,7 +263,9 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
     let sessionId: string | undefined;
     let sessionOpened = false;
     let accepted = false;
-    const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+    // Re-resolve after mid-turn report-ticket may have moved principal (#1171).
+    const liveSessionParent = (): string =>
+      config.sessionIdentity.resolveSessionFile(request.principal);
     let outcome: RoleTurnResult = failure("session", "AcpNoOutcome", "no-outcome");
     let reportedFailure: RoleTurnResult["knownFailure"];
     let packageFailure: RoleTurnResult["knownFailure"];
@@ -321,7 +326,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             ? loaded.sessionId
             : bindSessionId;
           if (config.hostName !== "hermes") recordNativeSessionPointer({
-            host: config.hostName, sessionId: loadedId, cwd: request.cwd, sessionParent, home: request.home,
+            host: config.hostName, sessionId: loadedId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home,
           });
           return loadedId;
         };
@@ -350,7 +355,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             sessionReady = false;
           } else {
             if (config.hostName !== "hermes") recordNativeSessionPointer({
-              host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home,
+              host: config.hostName, sessionId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home,
             });
             sessionOpened = true;
             await config.sessionIdentity.bind(request.principal, sessionId);
@@ -377,7 +382,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             // MCP advertises tool.parameters; prepared.jsonSchema is the headless
             // draft-07 stamp of that clone — record the delivered parameters face.
             const { $schema: _headlessStamp, ...deliveredSchema } = prepared.jsonSchema;
-            await recordTurnDelivery(request.runDirectory, {
+            await recordTurnDelivery(await syncTurnRequestLivePlacement(request), {
               systemPrompt: systemPromptOverride,
               outputSchema: deliveredSchema,
             }, "acp-host");
@@ -440,8 +445,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
       const native = connection?.result?.();
       reportedFailure = native?.knownFailure;
       outcome = native ?? { code: null, stderr: connection?.stderr?.() ?? "", timedOut: false };
-      await retainPackageFault({
-        runDirectory: request.runDirectory,
+      await retainPackageFaultBesideLivePlacement(request, {
         diagnostic: `ACP turn exception beside native host facts: ${describeErrorIdentity(error)}`,
         error,
       });
@@ -458,8 +462,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
         if (sessionId !== undefined && !accepted) {
           try { connection.notify("session/cancel", { sessionId }); }
           catch (error) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `session cancel failed beside host terminal: ${describeErrorIdentity(error)}`,
               error,
             });
@@ -467,8 +470,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
         }
         try { naturalTermination = await connection.close(); }
         catch (error) {
-          await retainPackageFault({
-            runDirectory: request.runDirectory,
+          await retainPackageFaultBesideLivePlacement(request, {
             diagnostic: `connection close failed beside host terminal: ${describeErrorIdentity(error)}`,
             error,
           });
@@ -489,31 +491,39 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
           || (naturalTermination !== undefined && (native.timedOut || native.signal !== undefined));
         let knownFailure = outcome.knownFailure;
         if (nativeFailed && knownFailure !== undefined && knownFailure !== reportedFailure) {
-          if (knownFailure !== packageFailure) await retainPackageFault({
-            runDirectory: request.runDirectory,
-            diagnostic: knownFailure.diagnostic ?? "ACP package failure beside late native termination",
-            error: knownFailure,
-          });
+          if (knownFailure !== packageFailure) {
+            await retainPackageFaultBesideLivePlacement(request, {
+              diagnostic: knownFailure.diagnostic ?? "ACP package failure beside late native termination",
+              error: knownFailure,
+            });
+          }
           knownFailure = reportedFailure;
         }
         const { knownFailure: _nativeFailure, ...facts } = native;
         outcome = { ...facts, ...(knownFailure === undefined ? {} : { knownFailure }) };
       }
       if (config.hostName !== "hermes" && sessionOpened && sessionId !== undefined) {
-        try {
-          copyAndRecordHostDossier({
-            host: config.hostName,
-            sessionId,
-            cwd: request.cwd,
-            sessionDirectory: sessionDirectoryOf(request.runDirectory),
-            sessionParent,
-            ...(request.home !== undefined ? { home: request.home } : {}),
-          });
-        } catch (error) {
-          await retainPackageFault({
-            runDirectory: request.runDirectory,
-            diagnostic: `host dossier copy failed beside host terminal: ${describeErrorIdentity(error)}`,
-            error,
+        const live = await trySyncTurnRequestLivePlacement(request);
+        if ("runDirectory" in live) {
+          try {
+            copyAndRecordHostDossier({
+              host: config.hostName,
+              sessionId,
+              cwd: request.cwd,
+              sessionDirectory: sessionDirectoryOf(live.runDirectory),
+              sessionParent: sessionFileOf(live.runDirectory),
+              ...(request.home !== undefined ? { home: request.home } : {}),
+            });
+          } catch (error) {
+            await retainPackageFaultBesideLivePlacement(request, {
+              diagnostic: `host dossier copy failed beside host terminal: ${describeErrorIdentity(error)}`,
+              error,
+            });
+          }
+        } else {
+          await retainPackageFaultBesideLivePlacement(request, {
+            diagnostic: `host dossier copy skipped: live run path resolve failed beside host terminal: ${describeErrorIdentity(live.resolveError)}`,
+            error: live.resolveError,
           });
         }
       }

package/src/activation-ledger-topology.ts

@@ -45,6 +45,22 @@ export function tryHomeFromAkRolesPath(path: string): string | undefined {
   return path.slice(0, match.index);
 }
 
+/**
+ * Soft derive: book key owning a path under `.ak-roles/books/<bookKey>/…`.
+ * Same topology family as tryHomeFromAkRolesPath — no cross-book invent.
+ */
+export function tryBookKeyFromAkRolesPath(path: string): string | undefined {
+  const home = tryHomeFromAkRolesPath(path);
+  if (home === undefined || home.length === 0) return undefined;
+  const booksRoot = join(resolveActivationLedgerHome(home), "books");
+  const rel = relative(booksRoot, resolve(path));
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    return undefined;
+  }
+  const bookKey = rel.split(sep)[0];
+  return bookKey === undefined || bookKey === "" ? undefined : bookKey;
+}
+
 /**
  * Hard derive: package home owning a run/session path under `.ak-roles/`.
  * Fails typed when the path is not ledger topology (no HOME fallback).

package/src/external-host-turn-loop.ts

@@ -3,6 +3,9 @@
  * One copy: serial, abort merge/race, closeRound re-ask rounds,
  * host-aborted, round-limit. Last hop = ExternalHostTurnDriver (four verbs).
  */
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+
 import type {
   RoleTurnHost,
   RoleTurnKnownFailure,
@@ -10,12 +13,105 @@ import type {
   RoleTurnResult,
 } from "./host-contracts.ts";
 import type { PreparedRoleTurn } from "./prepared-role-turn.ts";
+import { tryBookKeyFromAkRolesPath } from "./activation-ledger-topology.ts";
 import { projectThrownFailureLeaf, retainPackageFault } from "./public-cli/settlement.ts";
-import { describeErrorIdentity } from "./public-cli/run-lifecycle.ts";
+import { describeErrorIdentity, findRunDirectoryById } from "./public-cli/run-lifecycle.ts";
 import { deliveryLimitFromConfig } from "./receipt-delivery-policy.ts";
+import { parseRunLeaf } from "./role-run-placement.ts";
+import { projectTurnRequestLiveRunDirectory } from "./role-run-relocation.ts";
 import { reportRunRecord } from "./sitian-facade.ts";
 import { isOneShotWorkerReminderCode } from "./submission-errors.ts";
 
+/**
+ * #1171: mid-turn report-ticket may have moved the leg. Prefer the recorded
+ * path when it still exists; otherwise re-locate by run id inside the book.
+ * Undefined means vanished and unlocatable — callers must not revive the dead leaf.
+ */
+export async function resolveLiveRunDirectoryPath(
+  recordedPath: string,
+  home: string,
+): Promise<string | undefined> {
+  if (existsSync(recordedPath)) return recordedPath;
+  const parsed = parseRunLeaf(basename(recordedPath));
+  const bookKey = tryBookKeyFromAkRolesPath(recordedPath);
+  if (parsed === undefined || bookKey === undefined) return undefined;
+  return await findRunDirectoryById(
+    home,
+    parsed.runId,
+    bookKey,
+    parsed.role,
+  );
+}
+
+/**
+ * Prefer the request path when it still exists; otherwise re-locate by run id
+ * (resolveLiveRunDirectoryPath). Mutates the live request so later turn-record /
+ * exit-copy / fault notes stay on the new leaf.
+ */
+export async function syncTurnRequestLivePlacement(
+  request: RoleTurnRequest,
+): Promise<string> {
+  const live = await resolveLiveRunDirectoryPath(request.runDirectory, request.home);
+  if (live === undefined) {
+    const parsed = parseRunLeaf(basename(request.runDirectory));
+    throw new Error(
+      `admitted run ${parsed?.runId ?? "(unparseable)"} missing after host turn; not found under ${request.home}`,
+    );
+  }
+  if (live !== request.runDirectory) {
+    projectTurnRequestLiveRunDirectory(
+      request as {
+        runDirectory: string;
+        principal: { sessionDirectory?: string; sessionFile?: string };
+      },
+      live,
+    );
+  }
+  return live;
+}
+
+/**
+ * Soft live-path sync for cleanup / dossier work: lookup failure stays beside the
+ * caller and never revives a vanished leaf. Same authority as syncTurnRequestLivePlacement.
+ */
+export async function trySyncTurnRequestLivePlacement(
+  request: RoleTurnRequest,
+): Promise<{ readonly runDirectory: string } | { readonly resolveError: unknown }> {
+  try {
+    return { runDirectory: await syncTurnRequestLivePlacement(request) };
+  } catch (resolveError) {
+    return { resolveError };
+  }
+}
+
+/**
+ * Retain a package fault on the live leaf when locatable. Lookup failure must not
+ * replace the original fault or block later cleanup — reuse retainPackageFault when
+ * the leaf exists; otherwise present both causes on stderr (Pi transport path shape).
+ */
+export async function retainPackageFaultBesideLivePlacement(
+  request: RoleTurnRequest,
+  input: { readonly diagnostic: string; readonly error?: unknown },
+): Promise<void> {
+  const live = await trySyncTurnRequestLivePlacement(request);
+  if ("resolveError" in live) {
+    const resolveDiagnostic =
+      `live run path resolve failed beside fault: ${describeErrorIdentity(live.resolveError)}`;
+    try {
+      process.stderr.write(`${input.diagnostic}\n`);
+      process.stderr.write(`${resolveDiagnostic}\n`);
+    } catch {
+      // Best-effort presentation beside an already-chosen terminal.
+    }
+    return;
+  }
+  await retainPackageFault({
+    runDirectory: live.runDirectory,
+    diagnostic: input.diagnostic,
+    ...(Object.hasOwn(input, "error") ? { error: input.error } : {}),
+  });
+}
+
 /**
  * What one host start was given: one `turn-delivery` row of history.jsonl per start. History is
  * the volume whose write failure does not stop a run (#833), so a row that cannot be
@@ -187,8 +283,7 @@ export async function driveExternalRoleTurnRounds(
     try {
       closure = await prepared.closeRound();
     } catch (error) {
-      await retainPackageFault({
-        runDirectory: request.runDirectory,
+      await retainPackageFaultBesideLivePlacement(request, {
         diagnostic: `round closure failed beside host terminal: ${describeErrorIdentity(error)}`,
         error,
       });
@@ -199,8 +294,7 @@ export async function driveExternalRoleTurnRounds(
     if (closure.accepted) {
       try { await driver.afterAccepted?.(); }
       catch (error) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
+        await retainPackageFaultBesideLivePlacement(request, {
           diagnostic: `post-acceptance close failed beside host terminal: ${describeErrorIdentity(error)}`,
           error,
         });
@@ -208,8 +302,7 @@ export async function driveExternalRoleTurnRounds(
       return result;
     }
     if ("failure" in closure) {
-      await retainPackageFault({
-        runDirectory: request.runDirectory,
+      await retainPackageFaultBesideLivePlacement(request, {
         diagnostic: `round closure failed beside host terminal: ${JSON.stringify(closure.failure)}`,
       });
       // This is an explicit envelope failure (e.g. required audit/ledger failure),
@@ -225,8 +318,7 @@ export async function driveExternalRoleTurnRounds(
     else {
       countedReasks += 1;
       if (countedReasks > countedReaskLimit) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
+        await retainPackageFaultBesideLivePlacement(request, {
           diagnostic: `${driver.roundLimitName}: round-retry-limit`,
         });
         return result;
@@ -242,14 +334,13 @@ export async function driveExternalRoleTurnRounds(
  * failure stays primary. Ordinary cleanup is handled at its owning seam. */
 export async function disposeExternalRoleTurn(
   prepared: Pick<PreparedRoleTurn, "dispose">,
-  request: Pick<RoleTurnRequest, "runDirectory">,
+  request: RoleTurnRequest,
   outcome: RoleTurnResult,
 ): Promise<RoleTurnResult> {
   try {
     await prepared.dispose?.();
   } catch (error) {
-    await retainPackageFault({
-      runDirectory: request.runDirectory,
+    await retainPackageFaultBesideLivePlacement(request, {
       diagnostic: `required envelope shutdown failed beside host terminal: ${describeErrorIdentity(error)}`,
       error,
     });

package/src/headless-host/role-turn-host.ts

@@ -11,7 +11,7 @@ import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 
 import type { RoleTurnHost, RoleTurnRequest, RoleTurnResult } from "../host-contracts.ts";
-import { sessionDirectoryOf } from "../role-run-placement.ts";
+import { sessionDirectoryOf, sessionFileOf } from "../role-run-placement.ts";
 import {
   createSerializedRoleTurnHost,
   driveExternalRoleTurnRounds,
@@ -20,9 +20,12 @@ import {
   hostAbortedError,
   isHostAbortedError,
   recordTurnDelivery,
+  retainPackageFaultBesideLivePlacement,
+  syncTurnRequestLivePlacement,
+  trySyncTurnRequestLivePlacement,
 } from "../external-host-turn-loop.ts";
 import { describeErrorIdentity } from "../public-cli/run-lifecycle.ts";
-import { projectThrownFailureLeaf, retainPackageFault } from "../public-cli/settlement.ts";
+import { projectThrownFailureLeaf } from "../public-cli/settlement.ts";
 import {
   renderSystemPromptOverride,
   resolveBoundHostSessionId,
@@ -467,7 +470,9 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
       // CLI start-up inputs (system prompt / schema / MCP config files) are not
       // dossier: they live in a throwaway directory, and what was delivered is
       // recorded once per actual start as a history.jsonl `turn-delivery` row.
-      const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+      // Re-resolve after mid-turn report-ticket may have moved principal (#1171).
+      const liveSessionParent = (): string =>
+        config.sessionIdentity.resolveSessionFile(request.principal);
       const inputsDirectory = await mkdtemp(join(tmpdir(), "ak-role-headless-"));
       const systemPromptPath = join(inputsDirectory, "system-prompt.txt");
       let mcpConfigPath: string | undefined;
@@ -500,8 +505,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
         try {
           await rm(inputsDirectory, { recursive: true, force: true });
         } catch (cleanupError) {
-          await retainPackageFault({
-            runDirectory: request.runDirectory,
+          await retainPackageFaultBesideLivePlacement(request, {
             diagnostic: `headless turn inputs cleanup failed beside setup failure: ${describeErrorIdentity(cleanupError)}`,
             error: cleanupError,
           });
@@ -552,13 +556,13 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
               host: config.hostName,
               sessionId,
               cwd: request.cwd,
-              sessionParent,
+              sessionParent: liveSessionParent(),
               home: request.home,
             }) !== undefined;
           }
 
           // What this CLI start was given: one history record per start.
-          await recordTurnDelivery(request.runDirectory, {
+          await recordTurnDelivery(await syncTurnRequestLivePlacement(request), {
             systemPrompt,
             ...(startedWithSchema === undefined ? {} : { outputSchema: startedWithSchema }),
           }, "headless-host");
@@ -587,7 +591,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                 if (!codex && typeof event === "object" && event !== null && "session_id" in event
                   && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
                   sessionId = event.session_id;
-                  recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
+                  recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home });
                 }
                 if (codex && !codexIdObserved) {
                   const tid = codexObserver?.result().threadId;
@@ -597,7 +601,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                       host: config.hostName,
                       sessionId: tid,
                       cwd: request.cwd,
-                      sessionParent,
+                      sessionParent: liveSessionParent(),
                       home: request.home,
                     }) !== undefined;
                   }
@@ -608,7 +612,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
             exitedSessionId = roundSessionId;
             if (codex && roundSessionId !== undefined && roundSessionId !== "" && !pointerRecorded) {
               try {
-                recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
+                recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home });
               } catch (error) {
                 spawned.packageErrors = [...spawned.packageErrors, error];
               }
@@ -626,8 +630,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           }
 
           for (const error of spawned.packageErrors) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `headless transport handling failed beside host terminal: ${describeErrorIdentity(error)}`,
               error,
             });
@@ -635,8 +638,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
 
           try {
           const noteBeside = async (error: unknown, what: string): Promise<void> => {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `${what}: ${describeErrorIdentity(error)}`,
               error,
             });
@@ -729,8 +731,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           }
           return deliveredFromSpawned(spawned);
           } catch (error) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `required turn handling failed beside host terminal: ${describeErrorIdentity(error)}`,
               error,
             });
@@ -742,24 +743,39 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
         },
       });
       } finally {
+        // Cleanup must not depend on live-path sync: lookup failure stays beside
+        // the original cleanup/copy work and never skips rm(inputsDirectory).
+        const live = await trySyncTurnRequestLivePlacement(request);
+        const liveRunDirectory = "runDirectory" in live ? live.runDirectory : undefined;
+        if (liveRunDirectory === undefined && "resolveError" in live) {
+          await retainPackageFaultBesideLivePlacement(request, {
+            diagnostic: `headless cleanup live path resolve failed beside host terminal: ${describeErrorIdentity(live.resolveError)}`,
+            error: live.resolveError,
+          });
+        }
         try {
           await rm(inputsDirectory, { recursive: true, force: true });
         } catch (error) {
-          await retainPackageFault({
-            runDirectory: request.runDirectory,
+          await retainPackageFaultBesideLivePlacement(request, {
             diagnostic: `headless turn inputs cleanup failed beside host terminal: ${describeErrorIdentity(error)}`,
             error,
           });
         }
         try {
-          if (exitedSessionId !== undefined && exitedSessionId !== "") copyAndRecordHostDossier({
-            host: config.hostName, sessionId: exitedSessionId, cwd: request.cwd,
-            sessionDirectory: sessionDirectoryOf(request.runDirectory), sessionParent,
-            ...(request.home !== undefined ? { home: request.home } : {}),
-          });
+          if (
+            exitedSessionId !== undefined
+            && exitedSessionId !== ""
+            && liveRunDirectory !== undefined
+          ) {
+            copyAndRecordHostDossier({
+              host: config.hostName, sessionId: exitedSessionId, cwd: request.cwd,
+              sessionDirectory: sessionDirectoryOf(liveRunDirectory),
+              sessionParent: sessionFileOf(liveRunDirectory),
+              ...(request.home !== undefined ? { home: request.home } : {}),
+            });
+          }
         } catch (error) {
-          await retainPackageFault({
-            runDirectory: request.runDirectory,
+          await retainPackageFaultBesideLivePlacement(request, {
             diagnostic: `host dossier copy failed beside host terminal: ${describeErrorIdentity(error)}`,
             error,
           });

package/src/pi/role-turn-host.ts

@@ -5,6 +5,7 @@
  */
 import { execFile, spawn } from "node:child_process";
 import { constants } from "node:fs";
+import { existsSync } from "node:fs";
 import { access, appendFile, realpath } from "node:fs/promises";
 import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { platform } from "node:process";
@@ -27,6 +28,12 @@ import { projectActivationFlags } from "../role-activation-flags.ts";
 import { encodeUserDialogueStdin } from "../user-dialogue-stdin.ts";
 import { readLedgerSessionJsonlLines, readStrictPiSessionJsonl } from "../ledger-session-read.ts";
 import { copyAndRecordHostDossier } from "../host-session-record.ts";
+import {
+  resolveLiveRunDirectoryPath,
+  retainPackageFaultBesideLivePlacement,
+  syncTurnRequestLivePlacement,
+} from "../external-host-turn-loop.ts";
+import { homeFromRunDirectory } from "../activation-ledger-topology.ts";
 import { projectThrownFailureLeaf, retainPackageFault } from "../public-cli/settlement.ts";
 import { describeErrorIdentity } from "../public-cli/run-lifecycle.ts";
 import { RECEIPT_DELIVERY_LIMIT_ENV } from "../receipt-delivery-policy.ts";
@@ -358,7 +365,34 @@ export function createDefaultPiSpawnRunner(options: {
           if (stdinDeliveryError !== undefined) packageErrors.push(stdinDeliveryError);
           for (const error of packageErrors) {
             const diagnostic = `Pi transport handling failed beside host terminal: ${describeErrorIdentity(error)}`;
-            const runDirectory = spawnOptions.env.AK_ROLE_RUN_DIR;
+            // #1171 F4: spawn-time path may have been renamed; reuse
+            // resolveLiveRunDirectoryPath (same authority as syncTurnRequestLivePlacement).
+            const spawnDir = spawnOptions.env.AK_ROLE_RUN_DIR;
+            let runDirectory: string | undefined;
+            if (typeof spawnDir === "string" && spawnDir.trim() !== "") {
+              try {
+                runDirectory = await resolveLiveRunDirectoryPath(
+                  spawnDir,
+                  homeFromRunDirectory(spawnDir),
+                );
+              } catch (resolveError) {
+                // Resolve threw beside an already-closed child: keep both causes
+                // on the existing retain/stderr presentation path (失败诚实).
+                runDirectory = existsSync(spawnDir) ? spawnDir : undefined;
+                const resolveDiagnostic =
+                  `live run path resolve failed beside Pi transport fault: ${describeErrorIdentity(resolveError)}`;
+                if (runDirectory !== undefined) {
+                  await retainPackageFault({
+                    runDirectory,
+                    diagnostic: resolveDiagnostic,
+                    error: resolveError,
+                  });
+                } else {
+                  try { process.stderr.write(`${resolveDiagnostic}\n`); }
+                  catch { /* Best-effort presentation beside the already closed child. */ }
+                }
+              }
+            }
             if (runDirectory !== undefined) {
               await retainPackageFault({ runDirectory, diagnostic, error });
             } else {
@@ -474,6 +508,7 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
       // bind projects host.sessions; copy records the landing. Host adapters do
       // not write current.json — public bind/settlement seams own that render.
       try {
+        await syncTurnRequestLivePlacement(request);
         const { sessionFile, sessionDirectory } = config.principalAuthority.decode(request.principal);
         const sessionId = await readPiSessionHeaderId(sessionFile);
         if (sessionId !== undefined) {
@@ -491,8 +526,7 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
           });
         }
       } catch (error) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
+        await retainPackageFaultBesideLivePlacement(request, {
           diagnostic: `pi host dossier record failed beside host terminal: ${describeErrorIdentity(error)}`,
           error,
         });