@akagilnc/pi-workflow-roles 0.1.5679 → 0.1.5698

package/dist/external-host-turn-loop.js

@@ -30,16 +30,17 @@ export async function resolveLiveRunDirectoryPath(recordedPath, home) {
 /**
  * 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.
+ * exit-copy / fault notes stay on the new leaf. Authority is required so opaque
+ * principal wire is resealed — never shape-guessed in place (#1183).
  */
-export async function syncTurnRequestLivePlacement(request) {
+export async function syncTurnRequestLivePlacement(request, authority) {
     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, live);
+        projectTurnRequestLiveRunDirectory(request, live, authority);
     }
     return live;
 }
@@ -47,34 +48,51 @@ export async function syncTurnRequestLivePlacement(request) {
  * 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) {
+export async function trySyncTurnRequestLivePlacement(request, authority) {
     try {
-        return { runDirectory: await syncTurnRequestLivePlacement(request) };
+        return { runDirectory: await syncTurnRequestLivePlacement(request, authority) };
     }
     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).
+ * Retain a package fault on the live leaf when locatable. Directory lookup only —
+ * does not mutate live principal identity (#1183). Lookup failure must not replace
+ * the original fault or block later cleanup.
  */
 export async function retainPackageFaultBesideLivePlacement(request, input) {
-    const live = await trySyncTurnRequestLivePlacement(request);
-    if ("resolveError" in live) {
-        const resolveDiagnostic = `live run path resolve failed beside fault: ${describeErrorIdentity(live.resolveError)}`;
+    let runDirectory = request.runDirectory;
+    if (!existsSync(runDirectory)) {
         try {
-            process.stderr.write(`${input.diagnostic}\n`);
-            process.stderr.write(`${resolveDiagnostic}\n`);
+            const found = await resolveLiveRunDirectoryPath(request.runDirectory, request.home);
+            if (found === undefined) {
+                const resolveDiagnostic = `live run path resolve failed beside fault: admitted run missing under ${request.home}`;
+                try {
+                    process.stderr.write(`${input.diagnostic}\n`);
+                    process.stderr.write(`${resolveDiagnostic}\n`);
+                }
+                catch {
+                    // Best-effort presentation beside an already-chosen terminal.
+                }
+                return;
+            }
+            runDirectory = found;
         }
-        catch {
-            // Best-effort presentation beside an already-chosen terminal.
+        catch (resolveError) {
+            const resolveDiagnostic = `live run path resolve failed beside fault: ${describeErrorIdentity(resolveError)}`;
+            try {
+                process.stderr.write(`${input.diagnostic}\n`);
+                process.stderr.write(`${resolveDiagnostic}\n`);
+            }
+            catch {
+                // Best-effort presentation beside an already-chosen terminal.
+            }
+            return;
         }
-        return;
     }
     await retainPackageFault({
-        runDirectory: live.runDirectory,
+        runDirectory,
         diagnostic: input.diagnostic,
         ...(Object.hasOwn(input, "error") ? { error: input.error } : {}),
     });