@akagilnc/pi-workflow-roles 0.1.5365 → 0.1.5368

package/dist/migrate-book-topology.js

@@ -214,6 +214,9 @@ function roleRunPlacement(ledgerHome, input) {
 function roleRunArtifactsDirectory(runDirectory) {
   return join3(runDirectory, "artifacts");
 }
+function isUnboundRunDirectory(runDirectory) {
+  return runDirectory.replaceAll("\\", "/").includes("/unbound/runs/");
+}
 var init_role_run_placement = __esm({
   "src/role-run-placement.ts"() {
     "use strict";
@@ -195140,9 +195143,6 @@ async function resolveMigratingRunTicket(runDirectory) {
     }
   };
 }
-function isUnboundRunDirectory(runDirectory) {
-  return runDirectory.replaceAll("\\", "/").includes("/unbound/runs/");
-}
 function bookHistoricalRoots(booksDirectory, backupBooksDirectory, bookKey) {
   return [join17(booksDirectory, bookKey), join17(backupBooksDirectory, bookKey)];
 }

package/dist/public-cli/auto-resume.js

@@ -155,7 +155,7 @@ function jsonSafeReplacer() {
  * + O_NOFOLLOW where the platform provides it (a planted symlink is never
  * followed) — mirrors settlement.ts's own hardened artifact writers.
  */
-async function writeHardenedArtifactFile(artifactsDir, namePrefix, payload) {
+export async function writeHardenedArtifactFile(artifactsDir, namePrefix, payload) {
     const filePath = join(artifactsDir, `${namePrefix}-${randomUUID()}.json`);
     const body = `${JSON.stringify(payload, jsonSafeReplacer(), 2)}\n`;
     const noFollowFlag = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;

package/dist/public-cli/cli.js

@@ -3,19 +3,19 @@ import { piDurablePrincipalAuthority } from "../pi/durable-principal.js";
  * Public ak-role CLI dispatcher (roles / config / layered help / Judge run).
  */
 import { realpath } from "node:fs/promises";
-import { join } from "node:path";
 import { packageMachineHome } from "../activation-ledger-topology.js";
 import { assertLegalEngineModel, assertLegalEngineName, pickEngineAxis, } from "../package-resources/engine-material.js";
 import { resolveConfiguredProvinceOfficer, } from "../institutional-resolution.js";
-import { clearPersistentSeatConfig, effectiveSeatConfigurations, formatModelSpec, isGateOfficerSeat, loadCredentialProviders, loadPublicCliConfig, missingResolvedSeatModelMessage, parseModelSpec, resolveEffectiveSeat, resolvedSeatWithModel, savePublicCliConfig, setAutoResumeLimit, setPersistentSeatConfig, setPersistentSeatEngine, setPersistentSeatEngineModel, setPersistentSeatHost, validatePublicCliConfigAxes, } from "./config.js";
-import { loadHostProvidersTable, projectHostFacingProvider, renderHostProvidersTable, } from "./host-providers.js";
+import { clearPersistentSeatConfig, effectiveSeatConfigurations, formatModelSpec, isGateOfficerSeat, loadCredentialProviders, loadPublicCliConfig, missingResolvedSeatModelMessage, parseModelSpec, resolveEffectiveSeat, savePublicCliConfig, setAutoResumeLimit, setPersistentSeatConfig, setPersistentSeatEngine, setPersistentSeatEngineModel, setPersistentSeatHost, resolvePublicAgentDir, validatePublicCliConfigAxes, } from "./config.js";
+import { loadHostProvidersTable, renderHostProvidersTable, } from "./host-providers.js";
 import { packagedModelParent } from "../packaged-role-registry.js";
 import { seatModelOnly } from "./registry.js";
 import { CliUsageError } from "./cli-errors.js";
 import { runMachineSkillSetup } from "./machine-method-skills.js";
 import { presentLocatedResumeFailure, } from "./post-admission.js";
 import { appendPiSessionCustomEntry } from "../pi/role-turn-host.js";
-import { composeRoleTurnHostAdapters, formatHostSelectionFailure, HostSelectionError, selectRoleTurnHost, } from "./role-turn-host-resolution.js";
+import { openRoleSeatRuntime } from "./role-seat-runtime.js";
+import { formatHostSelectionFailure, HostSelectionError, } from "./role-turn-host-resolution.js";
 import { parseAnalystArgv, parsePublicSeatArgv, } from "./invocation.js";
 import { createTypedOptionConsumer, optionsForOwner, projectCommandHelp, projectOwnerOptions, PUBLIC_NAVIGATOR_HELP_NOTE, PUBLIC_ROLE_OPTION_OWNERS, renderHumanOwnerOptionLines, } from "./option-definitions.js";
 import { TurnDispatchedFailure } from "./auto-resume.js";
@@ -89,43 +89,41 @@ function takePublicGlobalFlag(argv, index, options) {
 function createRoleEnvironment(env, options, 
 /** #178: after host selection, before missing-model — structural argv parse once. */
 afterHost) {
-    const role = options.role;
     const extraPiArgs = env.extraPiArgs;
     const timeoutMs = env.timeoutMs;
-    // #617/#178/#788/#840: host first, then model; nested child seat selects own host.
-    const hostAdapters = composeRoleTurnHostAdapters({
-        packageRoot: env.packageRoot,
-        ...(env.roleTurnHost === undefined ? {} : { roleTurnHost: env.roleTurnHost }),
-        ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
-        ...(extraPiArgs === undefined ? {} : { extraPiArgs }),
-        ...(timeoutMs === undefined ? {} : { timeoutMs }),
-    }, env.principalAuthority);
-    const roleTurnHost = selectRoleTurnHost(hostAdapters, {
-        role,
+    const opened = openRoleSeatRuntime({
+        resolution: {
+            packageRoot: env.packageRoot,
+            ...(env.roleTurnHost === undefined ? {} : { roleTurnHost: env.roleTurnHost }),
+            ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+            ...(extraPiArgs === undefined ? {} : { extraPiArgs }),
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        },
+        principalAuthority: env.principalAuthority,
+        role: options.role,
         seat: options.seat,
+        home: options.home,
+        ...(afterHost === undefined ? {} : { afterHost }),
     });
-    // #178: host → argv (afterHost) → missing-model → provider projection.
-    afterHost?.();
-    const seatWithModel = resolvedSeatWithModel(options.seat);
-    if (seatWithModel === undefined) {
+    if (!opened.ok) {
         // Direct CLI has --model; dual remediation is intentional here (#178 / #916).
         throw new CliUsageError(missingResolvedSeatModelMessage(options.seat.seat, "invocation-or-config"));
     }
-    const hostFacingSelection = projectHostFacingProvider(seatWithModel.selection, seatWithModel.host, loadHostProvidersTable(options.home), options.home);
     return {
         home: options.home,
         principalAuthority: env.principalAuthority,
         agentDir: options.agentDir,
         sessionAppender: appendPiSessionCustomEntry,
         packageRoot: env.packageRoot,
-        roleTurnHost,
-        hostAdapters,
+        roleTurnHost: opened.roleTurnHost,
+        hostAdapters: opened.hostAdapters,
         cwd: options.cwd,
         ...(options.credentials === undefined ? {} : { credentials: options.credentials }),
         ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-        ...(hostFacingSelection === undefined ? {} : { model: hostFacingSelection }),
-        ...projectSeatEngine(options.seat),
-        ...projectSeatHost(options.seat),
+        ...(opened.model === undefined ? {} : { model: opened.model }),
+        ...(opened.engine === undefined ? {} : { engine: opened.engine }),
+        ...(opened.engineModel === undefined ? {} : { engineModel: opened.engineModel }),
+        host: opened.host,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
         ...(options.config?.autoResumeLimit === undefined
@@ -138,18 +136,31 @@ afterHost) {
         ...(env.signal === undefined ? {} : { signal: env.signal }),
     };
 }
+/** Shared preamble for a new public role command and an explicit resume. */
+async function loadPublicRoleDispatchParts(env, home) {
+    const agentDir = resolvePublicAgentDir(env.agentDir, home);
+    const cwd = env.cwd ?? process.cwd();
+    const config = await loadAndValidateConfig(home, env.packageRoot);
+    const credentials = env.credentials ?? (await loadCredentialProviders(agentDir));
+    return { agentDir, cwd, config, credentials };
+}
 /**
  * #178 single spine: resolve seat → host select → argv parse once → missing-model → run.
  * Keeps host-unregistered ahead of bad argv and missing-model.
  */
 async function dispatchPublicRoleCommand(env, home, io, parsed, role, parse, run) {
-    const agentDir = resolveAgentDir(env, home);
-    const cwd = env.cwd ?? process.cwd();
-    const config = await loadAndValidateConfig(home, env.packageRoot);
-    const credentials = env.credentials ?? (await loadCredentialProviders(agentDir));
-    const seat = resolveEffectiveSeat(config, role, credentials, invocationFromParsed(parsed));
+    const parts = await loadPublicRoleDispatchParts(env, home);
+    const seat = resolveEffectiveSeat(parts.config, role, parts.credentials, invocationFromParsed(parsed));
     let parsedRoleArgv;
-    const result = await run(parsed.args, createRoleEnvironment(env, { role, home, agentDir, cwd, credentials, seat, config }, () => {
+    const result = await run(parsed.args, createRoleEnvironment(env, {
+        role,
+        home,
+        agentDir: parts.agentDir,
+        cwd: parts.cwd,
+        credentials: parts.credentials,
+        seat,
+        config: parts.config,
+    }, () => {
         parsedRoleArgv = parse(parsed.args);
     }), () => parsedRoleArgv);
     return {
@@ -176,11 +187,6 @@ function defaultIo() {
 function resolveHome(env) {
     return env.home ?? packageMachineHome();
 }
-function resolveAgentDir(env, home) {
-    return (env.agentDir ??
-        process.env.PI_CODING_AGENT_DIR ??
-        join(home, ".pi", "agent"));
-}
 function parseThinking(value) {
     // #683: opaque pass-through — no local whitelist.
     return value;
@@ -316,14 +322,6 @@ function requireCallableSeat(seat, axis, verb) {
         throw new CliUsageError(`unknown ${axis}-axis seat: ${seat}`);
     }
 }
-/** Single seat engine axis → run-options projection (#391 E2 / #883). */
-function projectSeatEngine(seat) {
-    return pickEngineAxis(seat);
-}
-/** Single seat.host → run-options projection (#595 / #617). */
-function projectSeatHost(seat) {
-    return { host: seat.host };
-}
 function loadAndValidateConfig(home, packageRoot) {
     return loadPublicCliConfig(home).then((config) => {
         try {
@@ -787,7 +785,7 @@ export async function runAkRole(argv, env) {
             }
             const config = await loadAndValidateConfig(home, env.packageRoot);
             const credentials = env.credentials ??
-                (await loadCredentialProviders(resolveAgentDir(env, home)));
+                (await loadCredentialProviders(resolvePublicAgentDir(env.agentDir, home)));
             const seats = effectiveSeatConfigurations(config, credentials, invocationFromParsed(parsed));
             io.stdout(renderRoles(seats));
             return { exitCode: 0 };
@@ -829,23 +827,20 @@ export async function runAkRole(argv, env) {
                 runId: resumeRequest.runId,
                 authority: env.principalAuthority ?? piDurablePrincipalAuthority,
             };
-            const agentDir = resolveAgentDir(env, home);
-            const cwd = env.cwd ?? process.cwd();
-            const config = await loadAndValidateConfig(home, env.packageRoot);
-            const credentials = env.credentials ?? (await loadCredentialProviders(agentDir));
+            const parts = await loadPublicRoleDispatchParts(env, home);
             const resumeRole = await peekRoleRunRole(home, resumeRequest.runId);
             // Missing durable role keeps the judge seat table. The resume entry
             // itself is one function; it reads the stored run.
             const seatRole = resumeRole ?? "judge";
-            const seat = resolveEffectiveSeat(config, seatRole, credentials, invocationFromParsed(parsed));
+            const seat = resolveEffectiveSeat(parts.config, seatRole, parts.credentials, invocationFromParsed(parsed));
             const result = await runPublicInstructionSeatResume(resumeRequest, createRoleEnvironment(env, {
                 role: seatRole,
                 home,
-                agentDir,
-                cwd,
-                credentials,
+                agentDir: parts.agentDir,
+                cwd: parts.cwd,
+                credentials: parts.credentials,
                 seat,
-                config,
+                config: parts.config,
             }), io);
             let current = result;
             while (current.exitCode === 0 && current.admitted?.correlationId !== undefined
@@ -860,9 +855,15 @@ export async function runAkRole(argv, env) {
                 const parentRole = await peekRoleRunRole(home, parentRunId);
                 if (parentRole === undefined)
                     break;
-                const parentSeat = resolveEffectiveSeat(config, parentRole, credentials, invocationFromParsed(parsed));
+                const parentSeat = resolveEffectiveSeat(parts.config, parentRole, parts.credentials, invocationFromParsed(parsed));
                 const parentEnv = createRoleEnvironment(env, {
-                    role: parentRole, home, agentDir, cwd, credentials, seat: parentSeat, config,
+                    role: parentRole,
+                    home,
+                    agentDir: parts.agentDir,
+                    cwd: parts.cwd,
+                    credentials: parts.credentials,
+                    seat: parentSeat,
+                    config: parts.config,
                 });
                 current = await continueParentAfterChild(parentRunId, current.admitted, parentEnv, io);
             }

package/dist/public-cli/config.js

@@ -490,6 +490,9 @@ function credentialProvidersFromAuthData(data) {
     xai: Object.prototype.hasOwnProperty.call(record, "xai")
   };
 }
+function resolvePublicAgentDir(explicit, home) {
+  return explicit ?? process.env.PI_CODING_AGENT_DIR ?? join(home, ".pi", "agent");
+}
 async function loadCredentialProviders(agentDir) {
   try {
     const raw = await readFile(join(agentDir, "auth.json"), "utf8");
@@ -519,6 +522,7 @@ export {
   providerConfigured,
   publicCliConfigPath,
   resolveEffectiveSeat,
+  resolvePublicAgentDir,
   resolvedSeatWithModel,
   savePublicCliConfig,
   setAutoResumeLimit,

package/dist/public-cli/instruction-seat-run.js

@@ -3,7 +3,8 @@
  * Seat differences are composition-root fields. An omitted reviewer lens
  * starts two ordinary single-axis runs here.
  */
-import { dirname, resolve, sep } from "node:path";
+import { dirname, resolve } from "node:path";
+import { isUnboundRunDirectory } from "../role-run-placement.js";
 import { AUDITOR_DOSSIER_PROMPT } from "../compliance-transport.js";
 import { bookDirectOfficerRunPointer } from "../archivist-record-pointer.js";
 import { createPiDoctorAuditor } from "../doctor-auditor.js";
@@ -22,7 +23,7 @@ import { isSafePositiveTicketNumber, readBoardTicketNumber } from "../run-ticket
 import { NotarySourceRunError, resolveNotarySourceRunLocator } from "../notary-source-run.js";
 import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
 import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSourceOnResume, packagedRoleMetadata, } from "../packaged-role-registry.js";
-import { isAuditorSoulRole, readAuditorResumeBinding } from "../auditor-soul.js";
+import { readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, bindAdmittedTicketNumber, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
 import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
@@ -31,7 +32,7 @@ import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, readBoundSessionEntries, seatKnownFailureResolver, attachPostAuditProjection, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
 import { formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
-import { admittedSeatTurnDetails, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
+import { admittedSeatTurnDetails, projectPublicTurnAxes, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
 import { invokeCourtDiarist, latestPayloadEscalated, } from "./countersign-run.js";
 const AUDITED_ROLES = new Set(["judge", "fixer", "coder", "secretariat", "countersign", "doctor"]);
 const SECRETARIAT_STATUS_REASK = "secretariatStatus 不是 converged、escalate 之一。请重新交卷，secretariatStatus 写明其一。";
@@ -309,6 +310,29 @@ async function runOmittedLensBatch(argv, parsed, env, io) {
     io.stdout(formatTerminalResult(terminal));
     return { exitCode: failed ? 1 : 0, terminal };
 }
+/**
+ * One same-parent lookup. Seat branches still build their own summons.
+ * A found child resumes that child; no prior run returns undefined so the caller mints.
+ */
+function resumeSameParentInstructionSeat(input) {
+    return tryResumeSameTicketSeatRun({
+        home: input.env.home,
+        projectRoot: input.projectRoot,
+        role: input.role,
+        parentRunPath: input.parentRunPath,
+        ...(input.ticketNumber === undefined ? {} : { ticketNumber: input.ticketNumber }),
+        freshSummons: input.env.freshSummons,
+        summons: input.summons,
+        resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, input.env, input.io),
+    });
+}
+/** Re-ask words when the parent supplied them; otherwise the caller's own instruction. */
+function sameParentInstruction(env, fallback) {
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
+    if (resumeInstruction === undefined)
+        return fallback;
+    return { instruction: resumeInstruction, instructionEmpty: false };
+}
 /**
  * Countersign on the shared entry: gate parent resume, deferred materialization,
  * then the same one-shot settlement as every other seat.
@@ -319,19 +343,20 @@ async function runCountersignBody(parsed, env, io) {
         : undefined;
     if (gateParentRunPath !== undefined) {
         const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction ?? parsed.instruction ?? "";
-        const resumed = await tryResumeSameTicketSeatRun({
-            home: env.home,
+        const resumed = await resumeSameParentInstructionSeat({
+            env,
+            io,
             projectRoot: resolve(parsed.project ?? env.cwd),
             role: "countersign",
             parentRunPath: gateParentRunPath,
-            ...(isSafePositiveTicketNumber(env.boundTicketNumber) ? { ticketNumber: env.boundTicketNumber } : {}),
-            freshSummons: env.freshSummons,
+            ...(isSafePositiveTicketNumber(env.boundTicketNumber)
+                ? { ticketNumber: env.boundTicketNumber }
+                : {}),
             summons: {
                 sourceRunPath: gateParentRunPath,
                 instruction: resumeInstruction,
                 instructionEmpty: resumeInstruction.trim() === "",
             },
-            resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
         });
         if (resumed != null)
             return resumed;
@@ -364,12 +389,7 @@ async function runCountersignBody(parsed, env, io) {
                 admitted = { ...admitted, sourceRunPath: gateParentRunPath };
             }
             const turnProjection = {
-                packageRoot: env.packageRoot,
-                home: env.home,
-                agentDir: env.agentDir,
-                ...(env.model === undefined ? {} : { model: env.model }),
-                ...pickEngineAxis(env),
-                ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+                ...projectPublicTurnAxes(env),
                 ...(env.correlationId === undefined || env.correlationId.trim() === ""
                     ? {}
                     : { correlationId: env.correlationId }),
@@ -446,17 +466,18 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     let auditorSubject;
     let auditorSource;
     let auditorTicket;
+    let resolvedNotarySource;
     if (record.sameParent === "subject-source") {
-        if (!isAuditorSoulRole(parsed.subject)) {
+        if (parsed.subject === undefined) {
             presentStructuralRejection(new CliUsageError("auditor --subject requires judge|doctor"), io);
             return { exitCode: 2 };
         }
         auditorSubject = parsed.subject;
-        const source = typeof parsed.sourceRun === "string" ? parsed.sourceRun.trim() : "";
-        if (source === "") {
+        if (parsed.sourceRun === undefined) {
             presentStructuralRejection(new CliUsageError("auditor --source-run requires a run locator"), io);
             return { exitCode: 2 };
         }
+        const source = parsed.sourceRun;
         try {
             const resolved = await resolveNotarySourceRunLocator({ projectRoot, sourceRun: source, home: env.home });
             auditorSource = resolved.runDirectory;
@@ -469,24 +490,23 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         if (auditorSource === undefined)
             return { exitCode: 2 };
         const sourceDirectory = auditorSource;
-        const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
         const summons = {
-            ...(resumeInstruction === undefined
-                ? { instruction: parsed.instruction ?? "", instructionEmpty: (parsed.instruction ?? "").trim() === "" }
-                : { instruction: resumeInstruction, instructionEmpty: false }),
+            ...sameParentInstruction(env, {
+                instruction: parsed.instruction ?? "",
+                instructionEmpty: (parsed.instruction ?? "").trim() === "",
+            }),
             attachmentPaths: parsed.attachmentPaths ?? [],
         };
         const resumed = await withAuditorSoulEnv({
             subject: auditorSubject,
             sourceRunDirectory: auditorSource,
-            run: () => tryResumeSameTicketSeatRun({
-                home: env.home,
+            run: () => resumeSameParentInstructionSeat({
+                env,
+                io,
                 projectRoot,
                 role,
                 parentRunPath: sourceDirectory,
-                freshSummons: env.freshSummons,
                 summons,
-                resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
             }),
         });
         if (resumed != null)
@@ -495,22 +515,21 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     if (record.sameParent === "gate-pointer") {
         const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction ?? "");
         if (parentRunPath !== undefined) {
-            const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
             const summons = {
                 sourceRunPath: parentRunPath,
-                ...(resumeInstruction === undefined
-                    ? { instruction: parsed.instruction ?? "", instructionEmpty: (parsed.instruction ?? "").trim() === "" }
-                    : { instruction: resumeInstruction, instructionEmpty: false }),
+                ...sameParentInstruction(env, {
+                    instruction: parsed.instruction ?? "",
+                    instructionEmpty: (parsed.instruction ?? "").trim() === "",
+                }),
                 attachmentPaths: parsed.attachmentPaths ?? [],
             };
-            const resumed = await tryResumeSameTicketSeatRun({
-                home: env.home,
+            const resumed = await resumeSameParentInstructionSeat({
+                env,
+                io,
                 projectRoot,
                 role,
                 parentRunPath,
-                freshSummons: env.freshSummons,
                 summons,
-                resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
             });
             if (resumed != null)
                 return resumed;
@@ -536,23 +555,29 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         const summons = {
             sourceRunPath: source.runDirectory,
             sourceRun: source,
-            ...(resumeInstruction === undefined ? {} : { instruction: resumeInstruction, instructionEmpty: false }),
+            ...(resumeInstruction === undefined
+                ? {}
+                : { instruction: resumeInstruction, instructionEmpty: false }),
         };
-        const resumed = await tryResumeSameTicketSeatRun({
-            home: env.home,
+        resolvedNotarySource = source;
+        const resumed = await resumeSameParentInstructionSeat({
+            env,
+            io,
             projectRoot,
             role,
             parentRunPath: source.runDirectory,
-            freshSummons: env.freshSummons,
             summons,
-            resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
         });
         if (resumed != null)
             return resumed;
     }
     let admitted;
     try {
-        admitted = await admitPublicRole(role, parsed, env, auditorTicket === undefined ? undefined : { assertedTicketNumber: auditorTicket });
+        const admissionOverride = {
+            ...(auditorTicket === undefined ? {} : { assertedTicketNumber: auditorTicket }),
+            ...(resolvedNotarySource === undefined ? {} : { resolvedSourceRun: resolvedNotarySource }),
+        };
+        admitted = await admitPublicRole(role, parsed, env, auditorTicket === undefined && resolvedNotarySource === undefined ? undefined : admissionOverride);
     }
     catch (error) {
         const rejected = usageExit(error, io);
@@ -589,7 +614,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
                     timedOut: false, code: null, stderr: "", thrown: error,
                 }, seatAdapters(admitted, env), env.principalAuthority, io);
             }
-            if (outcome.admitted?.runDirectory.includes(`${sep}unbound${sep}runs${sep}`)) {
+            if (outcome.admitted !== undefined && isUnboundRunDirectory(outcome.admitted.runDirectory)) {
                 await recordChildDiaristRun(admitted, outcome.admitted.runId);
             }
             if (outcome.failedWithoutEscalate !== undefined) {