@akagilnc/pi-workflow-roles 0.1.4759 → 0.1.4772

package/dist/public-cli/post-admission.js

@@ -10,11 +10,12 @@ import { writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 import { buildAutoResumeContinuationPrompt, buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
-import { bindAdmittedTicketNumber, buildInstructionTransportPrompt, freezeAttachmentsIntoRun, } from "./invocation.js";
+import { bindAdmittedTicketNumber, buildInstructionTransportPrompt, freezeAttachmentsIntoRun, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { readRecordedSubmissionRows } from "../submission-ledger.js";
 import { pathContainedIn } from "../activation-ledger-topology.js";
 import { pickEngineAxis } from "../package-resources/engine-material.js";
 import { resolveHostAwareSessionAvailability } from "../session-identity.js";
+import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
 import { isOfficerReviewSeat } from "../host-contracts.js";
 import { deliverCaseDossierAsAttachment } from "./case-dossier-delivery.js";
 /** Original error bytes, never relabeled — a secondary fact riding beside a classified cause. */
@@ -41,6 +42,25 @@ import { homeFromRunDirectory } from "../activation-ledger-topology.js";
 import { attemptProducedFreshSubmission, classifyPostAdmissionFailure, controlledFailureInputFromResolution, exitCodeForTerminalOutcome, explicitInternalKnownFailureClassificationInput, formatCliDiagnostic, formatTerminalResult, inspectJudgeSession, isLawfulTypedTerminalOutcome, presentFailureTerminal, presentStructuralRejection, resolveAuditedRunnerFailureResolution, resolveControlledFailureResumeObservation, settleFailureTerminalResult, settleHostEndedNoReceipt, attachRecordedSubmissions, } from "./settlement.js";
 import {} from "./terminal.js";
 import { ensureRealArtifactsDirectory, persistReturnedRunState, runWithAutoResumeLoop, TurnDispatchedFailure, } from "./auto-resume.js";
+function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
+    const rewrite = (value) => rewriteRunDirectoryPathValue(value, relocation.oldRunDirectory, relocation.newRunDirectory);
+    const mutableRequest = request;
+    mutableRequest.runDirectory = admitted.runDirectory;
+    mutableRequest.principal = admitted.principal;
+    const activation = mutableRequest.activation;
+    if (activation !== null && typeof activation === "object" && !Array.isArray(activation)) {
+        for (const field of ["taskPath", "packetPath", "prerequisitesPath", "inputPath", "requestManifestPath"]) {
+            const record = activation;
+            if (field in record)
+                record[field] = rewrite(record[field]);
+        }
+    }
+    if (result.terminal !== undefined) {
+        for (const artifact of result.terminal.artifacts) {
+            artifact.path = rewrite(artifact.path);
+        }
+    }
+}
 /** #855: process-cancel settlement never re-enters auto-resume. */
 function withProcessCancelSkipAutoResume(result, signal) {
     if (processCancelSignalName(signal) === undefined) {
@@ -333,6 +353,12 @@ export async function dispatchPostAdmissionTurn(input) {
                 if (ticketNumber !== undefined)
                     await bindAdmittedTicketNumber(admitted, ticketNumber);
             }
+            // #863: shared post-admission bind must relocate unbound→ticket in-home
+            // before lease release (work-seat self-report and any prior board bind).
+            const relocation = await relocateAdmittedRunToTicket(admitted, env.principalAuthority, lease);
+            if (relocation !== undefined) {
+                projectRelocatedTurnIdentity(request, result, admitted, relocation);
+            }
             if (adapters.afterDispatch !== undefined)
                 await adapters.afterDispatch(admitted, lease);
             return result;

package/dist/public-cli/run-lifecycle.js

@@ -15,6 +15,7 @@ import { readLatestTypedProviderHttpObservation, } from "../typed-provider-http.
 export { clearTypedProviderHttpObservation, recordTypedProviderHttpStatus, readLatestTypedProviderHttpObservation, } from "../typed-provider-http.js";
 import { parseCollectorRepository } from "../collector-config.js";
 import { interpretDurableCourtTicketNumbers, sameCourtTicketNumbers, } from "../diarist-contracts.js";
+import { rewriteAdmittedRoleRunPage, rewriteRunDirectoryPathValue, } from "../role-run-relocation.js";
 import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
 import { recordEffectiveInvocationModel, requireAuthorityRef, isReviewerLens, } from "./invocation.js";
 /** Providers eligible for v1 typed-429 resume (Codex / xAI only).
@@ -209,14 +210,15 @@ async function readRoleRunStateDisk(runDirectory) {
         return undefined;
     if (typeof record.admittedRequestPath !== "string")
         return undefined;
-    const runDir = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
+    const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
         ? record.runDirectory
         : runDirectory;
+    const runDir = runDirectory;
     // Principal wire stays uninterpreted — authority owns legacy sessionFile fallback.
     const principalWire = {
-        sessionDirectory: record.sessionDirectory,
+        sessionDirectory: rewriteRunDirectoryPathValue(record.sessionDirectory, storedRunDirectory, runDirectory),
         ...(typeof record.sessionFile === "string"
-            ? { sessionFile: record.sessionFile }
+            ? { sessionFile: rewriteRunDirectoryPathValue(record.sessionFile, storedRunDirectory, runDirectory) }
             : {}),
     };
     let resumable;
@@ -242,7 +244,7 @@ async function readRoleRunStateDisk(runDirectory) {
         bookKey: record.bookKey,
         projectRoot: record.projectRoot,
         runDirectory: runDir,
-        admittedRequestPath: record.admittedRequestPath,
+        admittedRequestPath: rewriteRunDirectoryPathValue(record.admittedRequestPath, storedRunDirectory, runDirectory),
         principalWire,
         ...(phase === undefined ? {} : { phase }),
         ...(resumable === undefined ? {} : { resumable }),
@@ -1017,6 +1019,13 @@ async function loadResumableRunRecord(home, runId, authority) {
         const raw = JSON.parse(await readFile(run.admittedRequestPath, "utf8"));
         if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
             const record = raw;
+            const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
+                ? record.runDirectory
+                : run.runDirectory;
+            rewriteAdmittedRoleRunPage(record, [{
+                    oldRunDirectory: storedRunDirectory,
+                    newRunDirectory: run.runDirectory,
+                }]);
             if (typeof record.instruction === "string") {
                 instruction = record.instruction;
             }
@@ -1201,6 +1210,18 @@ async function loadResumableRunRecord(home, runId, authority) {
     else if (mergedSet.tickets !== undefined) {
         courtTicketNumbers = mergedSet.tickets;
     }
+    const sourceRunLeaf = basename(sourceRunPath ?? "").split("@");
+    const referencedRunId = sourceRun?.runId ?? sourceRunLeaf[0];
+    const referencedRole = sourceRun?.role ?? sourceRunLeaf[1];
+    if (referencedRunId !== undefined && referencedRunId !== "") {
+        const currentSourceRunDirectory = await findRunDirectoryById(home, referencedRunId, run.bookKey, referencedRole);
+        if (currentSourceRunDirectory !== undefined) {
+            sourceRunPath = currentSourceRunDirectory;
+            if (sourceRun !== undefined) {
+                sourceRun = { ...sourceRun, runDirectory: currentSourceRunDirectory };
+            }
+        }
+    }
     return {
         run,
         principal,

package/dist/role-run-relocation.js

@@ -132,6 +132,21 @@ function rewriteSummonsMaterials(value, rewrites) {
         value.attachmentPaths = value.attachmentPaths.map((path) => rewriteRunDirectoryPathValueAgainstRewrites(path, rewrites));
     }
 }
+/** Project one admitted page in memory after its containing run moved. */
+export function rewriteAdmittedRoleRunPage(page, rewrites) {
+    rewriteRunDirectoryPathFieldsAgainstRewrites(page, ADMITTED_PAGE_FIELDS, rewrites);
+    rewriteSourceRunLocator(page.sourceRun, rewrites);
+    if (Array.isArray(page.attachments)) {
+        for (const attachment of page.attachments) {
+            if (isPlainObject(attachment)) {
+                rewriteRunDirectoryPathFieldsAgainstRewrites(attachment, ["frozenPath"], rewrites);
+            }
+        }
+    }
+    if (isPlainObject(page.principal)) {
+        rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, ["sessionDirectory", "sessionFile"], rewrites);
+    }
+}
 async function rewriteJsonObjectFile(path, fields, rewrites) {
     if (!existsSync(path))
         return;
@@ -307,9 +322,9 @@ async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
 /**
  * Rewrite admitted-request / invocation / run-state path fields (attachment
  * frozenPath / summons.attachmentPaths pointers only), then nested package-owned
- * session seams, after the run directory has already been moved or copied.
- * `pagesDirectory` is where the pages now live; path strings still naming an
- * old run directory become the matching new directory. `crossRunRewrites`
+ * session seams. Callers may rewrite before or after the filesystem move/copy:
+ * `pagesDirectory` is where the pages currently live on disk; path strings that
+ * still name `oldRunDirectory` become `newRunDirectory`. `crossRunRewrites`
  * covers officer/parent pointers that landed under a different final placement.
  */
 export async function rewriteRoleRunDurablePages(input) {
@@ -318,21 +333,7 @@ export async function rewriteRoleRunDurablePages(input) {
     const admittedPath = join(pagesDirectory, "admitted-request.json");
     if (existsSync(admittedPath)) {
         const page = JSON.parse(await readFile(admittedPath, "utf8"));
-        rewriteRunDirectoryPathFieldsAgainstRewrites(page, ADMITTED_PAGE_FIELDS, rewrites);
-        // Nested notary typed locator — same value family as top-level sourceRunPath.
-        rewriteSourceRunLocator(page.sourceRun, rewrites);
-        if (Array.isArray(page.attachments)) {
-            for (const attachment of page.attachments) {
-                if (isPlainObject(attachment)) {
-                    // Pointer only — never open or mutate frozen attachment bytes.
-                    rewriteRunDirectoryPathFieldsAgainstRewrites(attachment, ["frozenPath"], rewrites);
-                }
-            }
-        }
-        // Nested principal wire (sessionDirectory/sessionFile) when present.
-        if (isPlainObject(page.principal)) {
-            rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, ["sessionDirectory", "sessionFile"], rewrites);
-        }
+        rewriteAdmittedRoleRunPage(page, rewrites);
         await writeFile(admittedPath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
     }
     const invocationPath = join(pagesDirectory, "invocation.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.4759",
+  "version": "0.1.4772",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/book-topology-migration-placement.ts

@@ -397,7 +397,15 @@ export async function findPlacedMigratingRun(
     const preferred = destPathFromSourceRelative(booksDirectory, bookKey, sourceRelative);
     if (preferred !== undefined) {
       const hit = matches.find((path) => path === preferred);
-      return hit === undefined ? undefined : placedRunFromPath(hit);
+      if (hit !== undefined) return placedRunFromPath(hit);
+      // T9 may have used the board ticket to move an historical unbound leaf
+      // under `<ticket>/runs`. The complete leaf is the placement identity;
+      // when it remains unique, downstream record/mixed/T11 consumers must
+      // follow that authoritative T9 result rather than re-derive unbound.
+      if (sourceRelative.replaceAll("\\", "/").startsWith("unbound/runs/")) {
+        return uniquePlacedRun(leafName, matches);
+      }
+      return undefined;
     }
     // Historical flat `runs/<leaf>` alias after T9 nested the unique complete leaf.
     if (isFlatRunsRelative(sourceRelative, leafName)) {

package/src/book-topology-runs-migrator.ts

@@ -2,9 +2,10 @@
  * #865 T9: migrate retained runs into ticket-scoped or unbound placement.
  * Inventory covers legacy flat `runs/`, existing `<ticket>/runs/`, and
  * `unbound/runs/`. Attribution reuses the shared migrating-run helper;
- * already-canonical trees copy as-is.
+ * already-canonical ticket trees copy as-is. Unbound leaves that already
+ * hold a board typed ticketNumber place under that ticket (#863 stock).
  */
-import { cp, mkdir, stat, writeFile } from "node:fs/promises";
+import { cp, mkdir, rename, readdir, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, sep } from "node:path";
 
 import {
@@ -16,16 +17,21 @@ import {
   resolveMigratingRunTicket,
 } from "./book-topology-migration-placement.ts";
 import {
+  assertBookTopologyMigrationPrerequisites,
   reconcileMigrationPartition,
   type BookTopologyMigrationContext,
   type BookTopologyPartitionMigrator,
   type MigrationItemOutcome,
 } from "./book-topology-migration.ts";
+import { listBookRunDirectories } from "./role-run-placement.ts";
 import {
   rewriteRoleRunDurablePages,
   type RunDirectoryPathRewrite,
 } from "./role-run-relocation.ts";
-import { MIGRATION_TICKET_DERIVATION_PAGE } from "./run-ticket-number.ts";
+import {
+  MIGRATION_TICKET_DERIVATION_PAGE,
+  readBoardTicketNumber,
+} from "./run-ticket-number.ts";
 
 const RUNS_PARTITION = "runs";
 
@@ -141,9 +147,38 @@ async function planBookMoves(
         historicalRunDirectory = join(booksDirectory, bookKey, leaf.relativePath);
       }
       derivation = undefined;
+    } else if (leaf.layout === "unbound") {
+      // #863: board typed ticket on an unbound leaf → place under that ticket.
+      // No board ticket → stay unbound. Never invent from prose or derivation.
+      const boardTicket = leaf.isDirectory
+        ? await readBoardTicketNumber(leaf.sourcePath)
+        : undefined;
+      if (parsed !== undefined && boardTicket !== undefined) {
+        targetPath = destinationRunDirectory(
+          booksDirectory,
+          bookKey,
+          boardTicket,
+          parsed.runId,
+          parsed.role,
+        );
+        disposition = "placed";
+        historicalRunDirectory = join(
+          booksDirectory,
+          bookKey,
+          "unbound",
+          "runs",
+          leaf.leafName,
+        );
+      } else {
+        targetPath = join(booksDirectory, bookKey, leaf.relativePath);
+        disposition = "unbound";
+        historicalRunDirectory = undefined;
+      }
+      derivation = undefined;
     } else if (leaf.layout !== "flat") {
+      // Already-canonical `<ticket>/runs/` — copy as-is.
       targetPath = join(booksDirectory, bookKey, leaf.relativePath);
-      disposition = leaf.layout === "unbound" ? "unbound" : "placed";
+      disposition = "placed";
       historicalRunDirectory = undefined;
       derivation = undefined;
     } else if (parsed === undefined) {
@@ -242,3 +277,120 @@ export const bookTopologyRunsMigrator: BookTopologyPartitionMigrator = {
     return reconcileMigrationPartition(RUNS_PARTITION, "entries", outcomes);
   },
 };
+
+export type BoardBoundUnboundRelocation = {
+  readonly from: string;
+  readonly to: string;
+  readonly ticketNumber: number;
+};
+
+type PlannedBoardBoundMove = {
+  readonly sourcePath: string;
+  readonly targetPath: string;
+  readonly ticketNumber: number;
+};
+
+/**
+ * Live in-place repair for already-migrated trees (#863 stock): plan the full
+ * board-bound unbound→ticket batch first, refuse any overwrite before mutation,
+ * rewrite durable pages (including batch `crossRunRewrites`) while sources still
+ * sit at unbound, then rename. Parse/write failures therefore leave sources in
+ * place so a retry can finish the same closure; rename-only retries still find
+ * remaining unbound sources. Leaves without a board ticket stay unbound.
+ */
+export async function relocateBoardBoundUnboundRunsInBook(
+  bookDirectory: string,
+): Promise<readonly BoardBoundUnboundRelocation[]> {
+  const bookKey = basename(bookDirectory);
+  const booksDirectory = dirname(bookDirectory);
+  const unboundRuns = join(bookDirectory, "unbound", "runs");
+  let entries;
+  try {
+    entries = await readdir(unboundRuns, { withFileTypes: true });
+  } catch (error) {
+    if (isMigrationEnoent(error)) return [];
+    throw error;
+  }
+
+  const planned: PlannedBoardBoundMove[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const parsed = parseRunLeaf(entry.name);
+    if (parsed === undefined) continue;
+    const sourcePath = join(unboundRuns, entry.name);
+    const boardTicket = await readBoardTicketNumber(sourcePath);
+    if (boardTicket === undefined) continue;
+    const targetPath = destinationRunDirectory(
+      booksDirectory,
+      bookKey,
+      boardTicket,
+      parsed.runId,
+      parsed.role,
+    );
+    planned.push({
+      sourcePath,
+      targetPath,
+      ticketNumber: boardTicket,
+    });
+  }
+
+  if (planned.length === 0) return [];
+
+  for (const move of planned) {
+    if (await pathExists(move.targetPath)) {
+      throw new Error(
+        `board-bound unbound relocate refuses to overwrite ${move.targetPath} with ${move.sourcePath}`,
+      );
+    }
+  }
+
+  const crossRunRewrites: RunDirectoryPathRewrite[] = planned.map((move) => ({
+    oldRunDirectory: move.sourcePath,
+    newRunDirectory: move.targetPath,
+  }));
+  const relocatedBySource = new Map(
+    planned.map((move) => [move.sourcePath, move] as const),
+  );
+
+  // Rewrite before any rename so durable-page failures remain retryable from
+  // the same unbound sources (failure-honesty: no relocatedCount=0 whitewash).
+  for (const runDir of await listBookRunDirectories(bookDirectory)) {
+    const move = relocatedBySource.get(runDir);
+    await rewriteRoleRunDurablePages({
+      pagesDirectory: runDir,
+      oldRunDirectory: move?.sourcePath ?? runDir,
+      newRunDirectory: move?.targetPath ?? runDir,
+      crossRunRewrites,
+    });
+  }
+
+  for (const move of planned) {
+    await mkdir(dirname(move.targetPath), { recursive: true });
+    await rename(move.sourcePath, move.targetPath);
+  }
+
+  return planned.map((move) => ({
+    from: move.sourcePath,
+    to: move.targetPath,
+    ticketNumber: move.ticketNumber,
+  }));
+}
+
+/**
+ * Walk every book under `booksDirectory` and relocate board-bound unbound
+ * runs in place. Requires zero live writer locks (same gate as topology migrate).
+ */
+export async function relocateBoardBoundUnboundRunsInBooks(
+  booksDirectory: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<readonly BoardBoundUnboundRelocation[]> {
+  await assertBookTopologyMigrationPrerequisites(booksDirectory, env);
+  const relocated: BoardBoundUnboundRelocation[] = [];
+  for (const bookKey of await listMigrationBookKeys(booksDirectory)) {
+    const batch = await relocateBoardBoundUnboundRunsInBook(
+      join(booksDirectory, bookKey),
+    );
+    relocated.push(...batch);
+  }
+  return relocated;
+}

package/src/notary-source-run.ts

@@ -87,7 +87,8 @@ export async function resolveNotarySourceRunLocator(options: {
 
   const ledgerHome = resolveActivationLedgerHome(options.home);
   const bookKey = resolveBookKeyFromGit(options.projectRoot);
-  const bookRunsRoot = join(activationBookDirectory(ledgerHome, bookKey), "runs");
+  const bookDirectory = activationBookDirectory(ledgerHome, bookKey);
+  const bookRunsRoot = join(bookDirectory, "runs");
 
   let candidate: string;
   const bare = parseRunDirectoryName(raw);
@@ -96,12 +97,27 @@ export async function resolveNotarySourceRunLocator(options: {
       ?? join(bookRunsRoot, `${bare.runId}@${bare.role}`);
   } else {
     candidate = isAbsolute(raw) ? raw : resolve(options.projectRoot, raw);
+    const identity = parseRunDirectoryName(basename(candidate));
+    const subjectDirectory = dirname(dirname(candidate));
+    const isLegacyUnboundLocator =
+      identity !== undefined &&
+      basename(dirname(candidate)) === "runs" &&
+      basename(subjectDirectory) === "unbound" &&
+      resolve(dirname(subjectDirectory)) === resolve(bookDirectory);
+    if (isLegacyUnboundLocator) {
+      candidate = (await findRunDirectoryById(
+        options.home,
+        identity.runId,
+        bookKey,
+        identity.role,
+      )) ?? candidate;
+    }
   }
 
   const real = await requireRunDirectory(candidate, raw);
   const identity = parseRunDirectoryName(basename(real))!;
 
-  const bookIdentity = physicalPathIdentity(activationBookDirectory(ledgerHome, bookKey));
+  const bookIdentity = physicalPathIdentity(bookDirectory);
   const parentIdentity = physicalPathIdentity(dirname(real));
   const subjectBookIdentity = physicalPathIdentity(dirname(dirname(dirname(real))));
   if (

package/src/public-cli/invocation.ts

@@ -41,7 +41,6 @@ import {
   requireSafePositiveTicketNumber,
 } from "../run-ticket-number.ts";
 import {
-  rewriteRoleRunDurablePages,
   rewriteRunDirectoryPathFields,
   rewriteRunDirectoryPathValue,
 } from "../role-run-relocation.ts";
@@ -628,8 +627,8 @@ export async function relocateAdmittedRunToTicket(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
   heldLease?: { relocate(runDirectory: string): void },
-): Promise<void> {
-  if (admitted.ticketNumber === undefined || !admitted.runDirectory.includes(`${sep}unbound${sep}runs${sep}`)) return;
+): Promise<{ oldRunDirectory: string; newRunDirectory: string } | undefined> {
+  if (admitted.ticketNumber === undefined || !admitted.runDirectory.includes(`${sep}unbound${sep}runs${sep}`)) return undefined;
   const oldRunDirectory = admitted.runDirectory;
   const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(oldRunDirectory));
   const target = roleRunPlacement(ledgerHome, {
@@ -639,7 +638,17 @@ export async function relocateAdmittedRunToTicket(
     role: admitted.role,
   });
   ensureRoleRunDirectory(ledgerHome, dirname(target.runDirectory));
+  // Host sealing is pure identity projection, but may reject the coordinates.
+  // Keep that failure before the filesystem commit point.
+  const principal = authority.seal(target);
+
+  // Rename is the only durable commit. Persisted paths are resolved from typed
+  // run identity on read, so online relocation never writes unleased peers or
+  // pretends a directory rename plus page rewrites form one transaction.
   await rename(oldRunDirectory, target.runDirectory);
+
+  // rename moved the open lock inode with the directory. Transfer cleanup
+  // ownership immediately after the commit.
   heldLease?.relocate(target.runDirectory);
 
   const admittedRecord = admitted as unknown as Record<string, unknown>;
@@ -664,14 +673,9 @@ export async function relocateAdmittedRunToTicket(
       target.runDirectory,
     ) as string;
   }
-  const principal = authority.seal(target);
   (admitted as { principal: DurablePrincipal }).principal = principal;
 
-  await rewriteRoleRunDurablePages({
-    pagesDirectory: target.runDirectory,
-    oldRunDirectory,
-    newRunDirectory: target.runDirectory,
-  });
+  return { oldRunDirectory, newRunDirectory: target.runDirectory };
 }
 
 /**

package/src/public-cli/post-admission.ts

@@ -22,11 +22,13 @@ import {
   bindAdmittedTicketNumber,
   buildInstructionTransportPrompt,
   freezeAttachmentsIntoRun,
+  relocateAdmittedRunToTicket,
 } from "./invocation.ts";
 import { readRecordedSubmissionRows } from "../submission-ledger.ts";
 import { pathContainedIn } from "../activation-ledger-topology.ts";
 import { pickEngineAxis } from "../package-resources/engine-material.ts";
 import { resolveHostAwareSessionAvailability } from "../session-identity.ts";
+import { rewriteRunDirectoryPathValue } from "../role-run-relocation.ts";
 
 import type {
   ControlledFailureCause,
@@ -117,6 +119,34 @@ import {
   TurnDispatchedFailure,
 } from "./auto-resume.ts";
 
+function projectRelocatedTurnIdentity(
+  request: RoleTurnRequest,
+  result: { readonly terminal?: TerminalResult },
+  admitted: AdmittedRoleInvocation,
+  relocation: { readonly oldRunDirectory: string; readonly newRunDirectory: string },
+): void {
+  const rewrite = (value: unknown) => rewriteRunDirectoryPathValue(
+    value,
+    relocation.oldRunDirectory,
+    relocation.newRunDirectory,
+  );
+  const mutableRequest = request as unknown as Record<string, unknown>;
+  mutableRequest.runDirectory = admitted.runDirectory;
+  mutableRequest.principal = admitted.principal;
+  const activation = mutableRequest.activation;
+  if (activation !== null && typeof activation === "object" && !Array.isArray(activation)) {
+    for (const field of ["taskPath", "packetPath", "prerequisitesPath", "inputPath", "requestManifestPath"] as const) {
+      const record = activation as Record<string, unknown>;
+      if (field in record) record[field] = rewrite(record[field]);
+    }
+  }
+  if (result.terminal !== undefined) {
+    for (const artifact of result.terminal.artifacts) {
+      artifact.path = rewrite(artifact.path) as string;
+    }
+  }
+}
+
 /** #855: process-cancel settlement never re-enters auto-resume. */
 function withProcessCancelSkipAutoResume<T extends object>(
   result: T,
@@ -703,6 +733,12 @@ export async function dispatchPostAdmissionTurn<
           : (asserted as { ticketNumber: number }).ticketNumber;
         if (ticketNumber !== undefined) await bindAdmittedTicketNumber(admitted, ticketNumber);
       }
+      // #863: shared post-admission bind must relocate unbound→ticket in-home
+      // before lease release (work-seat self-report and any prior board bind).
+      const relocation = await relocateAdmittedRunToTicket(admitted, env.principalAuthority, lease);
+      if (relocation !== undefined) {
+        projectRelocatedTurnIdentity(request, result, admitted, relocation);
+      }
       if (adapters.afterDispatch !== undefined) await adapters.afterDispatch(admitted, lease);
       return result;
     } catch (error) {

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

@@ -40,6 +40,10 @@ import {
 } from "../diarist-contracts.ts";
 import type { DoctorCaseIdentity } from "../doctor-contracts.ts";
 import type { NotarySourceRunLocator } from "../notary-contracts.ts";
+import {
+  rewriteAdmittedRoleRunPage,
+  rewriteRunDirectoryPathValue,
+} from "../role-run-relocation.ts";
 import {
   appendEngineSessionMaterial,
   engineSessionMaterialFromOptions,
@@ -419,15 +423,20 @@ async function readRoleRunStateDisk(
   if (typeof record.projectRoot !== "string") return undefined;
   if (typeof record.sessionDirectory !== "string") return undefined;
   if (typeof record.admittedRequestPath !== "string") return undefined;
-  const runDir =
+  const storedRunDirectory =
     typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
       ? record.runDirectory
       : runDirectory;
+  const runDir = runDirectory;
   // Principal wire stays uninterpreted — authority owns legacy sessionFile fallback.
   const principalWire: RoleRunPrincipalWire = {
-    sessionDirectory: record.sessionDirectory,
+    sessionDirectory: rewriteRunDirectoryPathValue(
+      record.sessionDirectory,
+      storedRunDirectory,
+      runDirectory,
+    ) as string,
     ...(typeof record.sessionFile === "string"
-      ? { sessionFile: record.sessionFile }
+      ? { sessionFile: rewriteRunDirectoryPathValue(record.sessionFile, storedRunDirectory, runDirectory) as string }
       : {}),
   };
   let resumable: TypedHttp429Observation | undefined;
@@ -458,7 +467,11 @@ async function readRoleRunStateDisk(
     bookKey: record.bookKey,
     projectRoot: record.projectRoot,
     runDirectory: runDir,
-    admittedRequestPath: record.admittedRequestPath,
+    admittedRequestPath: rewriteRunDirectoryPathValue(
+      record.admittedRequestPath,
+      storedRunDirectory,
+      runDirectory,
+    ) as string,
     principalWire,
     ...(phase === undefined ? {} : { phase }),
     ...(resumable === undefined ? {} : { resumable }),
@@ -1433,6 +1446,14 @@ async function loadResumableRunRecord(
     );
     if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
       const record = raw as Record<string, unknown>;
+      const storedRunDirectory =
+        typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
+          ? record.runDirectory
+          : run.runDirectory;
+      rewriteAdmittedRoleRunPage(record, [{
+        oldRunDirectory: storedRunDirectory,
+        newRunDirectory: run.runDirectory,
+      }]);
       if (typeof record.instruction === "string") {
         instruction = record.instruction;
       }
@@ -1649,6 +1670,23 @@ async function loadResumableRunRecord(
   } else if (mergedSet.tickets !== undefined) {
     courtTicketNumbers = mergedSet.tickets;
   }
+  const sourceRunLeaf = basename(sourceRunPath ?? "").split("@");
+  const referencedRunId = sourceRun?.runId ?? sourceRunLeaf[0];
+  const referencedRole = sourceRun?.role ?? sourceRunLeaf[1];
+  if (referencedRunId !== undefined && referencedRunId !== "") {
+    const currentSourceRunDirectory = await findRunDirectoryById(
+      home,
+      referencedRunId,
+      run.bookKey,
+      referencedRole,
+    );
+    if (currentSourceRunDirectory !== undefined) {
+      sourceRunPath = currentSourceRunDirectory;
+      if (sourceRun !== undefined) {
+        sourceRun = { ...sourceRun, runDirectory: currentSourceRunDirectory };
+      }
+    }
+  }
   return {
     run,
     principal,