@akagilnc/pi-workflow-roles 0.1.5357 → 0.1.5368

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) {

package/dist/public-cli/invocation.js

@@ -9,7 +9,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { activationBookDirectory, ensureRealDirectoryTree, homeFromRunDirectory, pathContainedIn, resolveActivationLedgerHome, } from "../activation-ledger-topology.js";
 import { resolveBookKeyFromGit } from "../activation-ledger-git.js";
-import { ensureRoleRunDirectory, ensureRoleRunPlacement, listBookRunDirectories, roleRunArtifactsDirectory, roleRunPlacement, } from "../role-run-placement.js";
+import { ensureRoleRunDirectory, ensureRoleRunPlacement, isUnboundRunDirectory, listBookRunDirectories, roleRunArtifactsDirectory, roleRunPlacement, } from "../role-run-placement.js";
 import { packagedAdmittedSubject, packagedArgvResult, packagedBareToken, packagedBaseIsRevision, packagedEmitsAuthorityRefs, packagedPublicInstructionSubject, packagedRoleMetadata, packagedStoresSourceRunRaw, packagedSubjectChoices, } from "../packaged-role-registry.js";
 import { isSafePositiveTicketNumber, readBoardTicketNumber, requireSafePositiveTicketNumber, } from "../run-ticket-number.js";
 import { rewriteRunDirectoryPathFields, rewriteRunDirectoryPathValue, } from "../role-run-relocation.js";
@@ -103,44 +103,53 @@ async function writeRoleInvocationLedger(source, role, effectiveModel) {
  * Host stays write-if-present (`string` only).
  */
 export async function recordEffectiveInvocationModel(runDirectory, model, engine, host, engineModel) {
-    const ledgerPath = join(runDirectory, "invocation.json");
-    const current = JSON.parse(await readFile(ledgerPath, "utf8"));
-    const next = { ...current };
-    if (model !== undefined) {
-        next.provider = model.provider;
-        next.model = model.model;
-        if (model.thinking === undefined) {
-            delete next.thinking;
+    await updateDurableJsonPage(join(runDirectory, "invocation.json"), (current) => {
+        const next = { ...current };
+        if (model !== undefined) {
+            next.provider = model.provider;
+            next.model = model.model;
+            if (model.thinking === undefined) {
+                delete next.thinking;
+            }
+            else {
+                next.thinking = model.thinking;
+            }
         }
-        else {
-            next.thinking = model.thinking;
+        if (engine === null) {
+            delete next.engine;
         }
-    }
-    if (engine === null) {
-        delete next.engine;
-    }
-    else if (engine !== undefined) {
-        next.engine = engine;
-    }
-    if (engineModel === null) {
-        delete next.engineModel;
-    }
-    else if (engineModel !== undefined) {
-        next.engineModel = engineModel;
-    }
-    if (host !== undefined) {
-        next.host = host;
-    }
-    await writeFile(ledgerPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+        else if (engine !== undefined) {
+            next.engine = engine;
+        }
+        if (engineModel === null) {
+            delete next.engineModel;
+        }
+        else if (engineModel !== undefined) {
+            next.engineModel = engineModel;
+        }
+        if (host !== undefined) {
+            next.host = host;
+        }
+        return next;
+    });
+}
+/**
+ * Read one durable JSON object, let the caller keep its field rules, and write
+ * the page back. `undefined` means the caller decided not to change the page.
+ */
+async function updateDurableJsonPage(path, update) {
+    const current = JSON.parse(await readFile(path, "utf8"));
+    const next = update(current);
+    if (next === undefined)
+        return;
+    await writeFile(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 /** Merge observed launch-time fields into the single existing invocation.json identity page. */
 async function mergeInvocationIdentityPage(runDirectory, fields) {
-    const ledgerPath = join(runDirectory, "invocation.json");
-    const current = JSON.parse(await readFile(ledgerPath, "utf8"));
-    await writeFile(ledgerPath, `${JSON.stringify({
+    await updateDurableJsonPage(join(runDirectory, "invocation.json"), (current) => ({
         ...current,
         ...fields,
-    }, null, 2)}\n`, "utf8");
+    }));
 }
 /**
  * Persist parent --source-run path onto admitted-request for officer resume lookup (#747).
@@ -150,19 +159,19 @@ export async function persistAdmittedSourceRunPath(admitted, sourceRunPath, audi
     if (sourceRunPath.trim() === "") {
         throw new Error("persistAdmittedSourceRunPath requires a non-empty sourceRunPath");
     }
-    const admittedPath = admitted.admittedRequestPath;
-    const current = JSON.parse(await readFile(admittedPath, "utf8"));
-    if (typeof current.sourceRunPath === "string" && current.sourceRunPath !== sourceRunPath) {
-        throw new Error(`persistAdmittedSourceRunPath refuses to replace ${current.sourceRunPath} with ${sourceRunPath}`);
-    }
-    const sameSubject = auditorSubject === undefined || current.auditorSubject === auditorSubject;
-    if (current.sourceRunPath === sourceRunPath && sameSubject)
-        return;
-    await writeFile(admittedPath, `${JSON.stringify({
-        ...current,
-        sourceRunPath,
-        ...(auditorSubject === undefined ? {} : { auditorSubject }),
-    }, null, 2)}\n`, "utf8");
+    await updateDurableJsonPage(admitted.admittedRequestPath, (current) => {
+        if (typeof current.sourceRunPath === "string" && current.sourceRunPath !== sourceRunPath) {
+            throw new Error(`persistAdmittedSourceRunPath refuses to replace ${current.sourceRunPath} with ${sourceRunPath}`);
+        }
+        const sameSubject = auditorSubject === undefined || current.auditorSubject === auditorSubject;
+        if (current.sourceRunPath === sourceRunPath && sameSubject)
+            return undefined;
+        return {
+            ...current,
+            sourceRunPath,
+            ...(auditorSubject === undefined ? {} : { auditorSubject }),
+        };
+    });
 }
 /**
  * Bind a post-admission resolved ticketNumber onto the in-memory admitted
@@ -177,17 +186,19 @@ export async function bindAdmittedTicketNumber(admitted, ticketNumber) {
 }
 /** Persist each direct caller observed while a retained run is resumed. */
 export async function recordAdmittedCorrelation(admitted, correlationId) {
-    const current = JSON.parse(await readFile(admitted.admittedRequestPath, "utf8"));
-    const prior = [
-        ...(Array.isArray(current.correlationIds)
-            ? current.correlationIds.filter((value) => typeof value === "string" && value.trim() !== "")
-            : []),
-        ...(typeof current.correlationId === "string" && current.correlationId.trim() !== ""
-            ? [current.correlationId]
-            : []),
-    ];
-    const correlationIds = [...new Set([...prior, correlationId])];
-    await writeFile(admitted.admittedRequestPath, `${JSON.stringify({ ...current, correlationId, correlationIds }, null, 2)}\n`, "utf8");
+    let correlationIds = [];
+    await updateDurableJsonPage(admitted.admittedRequestPath, (current) => {
+        const prior = [
+            ...(Array.isArray(current.correlationIds)
+                ? current.correlationIds.filter((value) => typeof value === "string" && value.trim() !== "")
+                : []),
+            ...(typeof current.correlationId === "string" && current.correlationId.trim() !== ""
+                ? [current.correlationId]
+                : []),
+        ];
+        correlationIds = [...new Set([...prior, correlationId])];
+        return { ...current, correlationId, correlationIds };
+    });
     await mergeInvocationIdentityPage(admitted.runDirectory, {
         correlationId,
         correlationIds,
@@ -198,7 +209,7 @@ export async function recordAdmittedCorrelation(admitted, correlationId) {
 }
 /** File a role run under its latest typed ticket identity. */
 export async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
-    if (admitted.ticketNumber === undefined || !admitted.runDirectory.includes(`${sep}unbound${sep}runs${sep}`))
+    if (admitted.ticketNumber === undefined || !isUnboundRunDirectory(admitted.runDirectory))
         return undefined;
     const oldRunDirectory = admitted.runDirectory;
     const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(oldRunDirectory));
@@ -264,12 +275,13 @@ export async function relocateAdmittedRunToTicket(admitted, authority, heldLease
 }
 /** Persist the exact child identity; later parent binding never inspects siblings. */
 export async function recordChildDiaristRun(parent, childRunId) {
-    const page = JSON.parse(await readFile(parent.admittedRequestPath, "utf8"));
-    const existing = Array.isArray(page.childDiaristRunIds)
-        ? page.childDiaristRunIds.filter((runId) => typeof runId === "string")
-        : [];
-    const childDiaristRunIds = existing.includes(childRunId) ? existing : [...existing, childRunId];
-    await writeFile(parent.admittedRequestPath, `${JSON.stringify({ ...page, childDiaristRunIds }, null, 2)}\n`, "utf8");
+    await updateDurableJsonPage(parent.admittedRequestPath, (page) => {
+        const existing = Array.isArray(page.childDiaristRunIds)
+            ? page.childDiaristRunIds.filter((runId) => typeof runId === "string")
+            : [];
+        const childDiaristRunIds = existing.includes(childRunId) ? existing : [...existing, childRunId];
+        return { ...page, childDiaristRunIds };
+    });
 }
 /**
  * Bind ticket identity onto a run directory's durable pages when the admitted
@@ -279,10 +291,16 @@ export async function recordChildDiaristRun(parent, childRunId) {
 export async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
     requireSafePositiveTicketNumber(ticketNumber, "bindTicketNumberOnRunDirectory");
     const admittedPath = join(runDirectory, "admitted-request.json");
-    const admitted = JSON.parse(await readFile(admittedPath, "utf8"));
-    if (admitted.ticketNumber === ticketNumber)
+    let unchanged = false;
+    await updateDurableJsonPage(admittedPath, (admitted) => {
+        if (admitted.ticketNumber === ticketNumber) {
+            unchanged = true;
+            return undefined;
+        }
+        return { ...admitted, ticketNumber };
+    });
+    if (unchanged)
         return;
-    await writeFile(admittedPath, `${JSON.stringify({ ...admitted, ticketNumber }, null, 2)}\n`, "utf8");
     await mergeInvocationIdentityPage(runDirectory, { ticketNumber });
 }
 /** Add the identity returned by the production Pi launch seam to its existing ledger page. */
@@ -528,18 +546,31 @@ function requireOptionPath(flag, value) {
  * next option), and a leading `-` (read as the next Skill option). Not a
  * general free-text gate — only the projection admission seam.
  */
+function skillArgTokenFault(value) {
+    if (value === undefined || value.trim() === "")
+        return "empty";
+    if (/\s/.test(value))
+        return "whitespace";
+    if (value.startsWith("-"))
+        return "optionLike";
+    return undefined;
+}
 function requireSkillArgToken(value, messages) {
-    if (value === undefined || value.trim() === "") {
-        throw new CliUsageError(messages.empty);
-    }
-    if (/\s/.test(value)) {
-        throw new CliUsageError(messages.whitespace);
-    }
-    if (value.startsWith("-")) {
-        throw new CliUsageError(messages.optionLike);
-    }
+    const fault = skillArgTokenFault(value);
+    if (fault !== undefined)
+        throw new CliUsageError(messages[fault]);
     return value;
 }
+/**
+ * Durable reviewer base on resume. Same token rule as fresh `--base`,
+ * with the resume-owned missing/damaged split.
+ */
+export function admittedReviewerBaseFault(value) {
+    const fault = skillArgTokenFault(value);
+    if (fault === undefined)
+        return undefined;
+    return fault === "empty" ? "missing" : "damaged";
+}
 /**
  * Reviewer --base admission: nonempty single Skill-arg token (shared rule with
  * requireAuthorityRef). Multi-token / option-like values smuggle extra flags
@@ -789,9 +820,6 @@ export async function admitPublicRole(role, parsed, env, override) {
             });
         }
         case "worker-packet": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
             if (instruction.trim() === "") {
                 throw new CliUsageError("fixer requires a nonblank repair instruction");
             }
@@ -844,19 +872,7 @@ export async function admitPublicRole(role, parsed, env, override) {
             });
         }
         case "collect-target": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
-            let explicitPrNumber;
-            if (parsed.prNumber !== undefined) {
-                try {
-                    explicitPrNumber = parseCollectorPrNumber(parsed.prNumber);
-                }
-                catch (error) {
-                    const detail = error instanceof Error ? error.message : String(error);
-                    throw new CliUsageError(detail, { cause: error });
-                }
-            }
+            const explicitPrNumber = parsed.prNumber;
             const projectRoot = resolve(parsed.project ?? shared.cwd);
             let repository;
             if (parsed.repo !== undefined) {
@@ -907,15 +923,10 @@ export async function admitPublicRole(role, parsed, env, override) {
             return { ...admittedCollector, repository };
         }
         case "case-identity": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
-            const issueNumber = parsed.issueNumber ?? Number.NaN;
-            if (!Number.isInteger(issueNumber) ||
-                issueNumber < 1 ||
-                !DOCTOR_ISSUE_NUMBER_PATTERN.test(String(issueNumber))) {
-                throw new CliUsageError(`doctor --issue must be a positive integer, got ${issueNumber}`);
+            if (parsed.issueNumber === undefined) {
+                throw new CliUsageError(`doctor --issue must be a positive integer, got ${Number.NaN}`);
             }
+            const issueNumber = parsed.issueNumber;
             let frozenAttachments = [];
             const admittedDoctor = await admitStandardMaterialInvocation("doctor", {
                 ...shared,
@@ -970,23 +981,22 @@ export async function admitPublicRole(role, parsed, env, override) {
             return { ...admittedDoctor, attachments: frozenAttachments };
         }
         case "source-locator": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
             const projectRoot = resolve(parsed.project ?? shared.cwd);
-            let sourceRun;
-            try {
-                sourceRun = await resolveNotarySourceRunLocator({
-                    projectRoot,
-                    sourceRun: parsed.sourceRun ?? "",
-                    home: shared.home,
-                });
-            }
-            catch (error) {
-                if (error instanceof NotarySourceRunError) {
-                    throw new CliUsageError(error.message, { cause: error });
+            let sourceRun = override?.resolvedSourceRun;
+            if (sourceRun === undefined) {
+                try {
+                    sourceRun = await resolveNotarySourceRunLocator({
+                        projectRoot,
+                        sourceRun: parsed.sourceRun ?? "",
+                        home: shared.home,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof NotarySourceRunError) {
+                        throw new CliUsageError(error.message, { cause: error });
+                    }
+                    throw error;
                 }
-                throw error;
             }
             // Board ticket on the source run wins; otherwise the summons ticket. Code does not infer one.
             const inheritedTicketNumber = await readBoardTicketNumber(sourceRun.runDirectory);
@@ -1007,9 +1017,6 @@ export async function admitPublicRole(role, parsed, env, override) {
             });
         }
         case "gleaner": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
             const baseRevision = parsed.baseRevision ?? "";
             if (baseRevision.trim() === "") {
                 throw new CliUsageError("--base requires a nonempty revision");
@@ -1024,16 +1031,19 @@ export async function admitPublicRole(role, parsed, env, override) {
             });
         }
         case "review-basis": {
-            const lens = requireReviewerLens(parsed.lens);
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
+            if (parsed.lens === undefined) {
+                throw new CliUsageError("--lens requires completeness or correctness");
+            }
+            if (parsed.baseRevision === undefined) {
+                throw new CliUsageError("--base requires a nonempty revision");
             }
-            const baseRevision = requireReviewerBaseRevision(parsed.baseRevision);
             const rawRefs = parsed.authorityRefs ?? [];
             if (rawRefs.length === 0) {
                 throw new CliUsageError("reviewer requires --authority-ref <ref>");
             }
-            const authorityRefs = Object.freeze(rawRefs.map((ref) => requireAuthorityRef(ref)));
+            const lens = parsed.lens;
+            const baseRevision = parsed.baseRevision;
+            const authorityRefs = Object.freeze([...rawRefs]);
             const admittedReviewer = await admitStandardMaterialInvocation("reviewer", {
                 ...shared,
                 instruction,
@@ -1048,9 +1058,6 @@ export async function admitPublicRole(role, parsed, env, override) {
             return { ...admittedReviewer, authorityRefs };
         }
         case "merge-envelope": {
-            if (parsed.project !== undefined) {
-                requireOptionPath("--project", parsed.project);
-            }
             if (instruction.trim() === "") {
                 throw new CliUsageError("merger requires a nonblank task instruction");
             }
@@ -1106,9 +1113,6 @@ function admissionSubject(ticketNumber) {
  * Every public seat persists through this function. Seat-only fields are supplied by the caller.
  */
 async function placeRoleAdmission(options) {
-    if (options.project !== undefined) {
-        requireOptionPath("--project", options.project);
-    }
     const projectRoot = resolve(options.project ?? options.cwd);
     const runId = options.runId ?? (options.createRunId ?? uuidv7)();
     const ticketFields = ticketAdmissionFields(options.assertedTicketNumber);