@akagilnc/pi-workflow-roles 0.1.4528 → 0.1.4620

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

@@ -4,6 +4,8 @@
  * extra packets. Controlled-failure settlement reuses #107.
  * #526: execution via RoleTurnHost; argv is Pi adapter internal.
  */
+import { resolve } from "node:path";
+
 import type {
   DurablePrincipalAuthority,
   MethodBinding,
@@ -40,7 +42,11 @@ import {
   trySettleReviewerTerminalResult,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
-import type { TerminalResult } from "./terminal.ts";
+import {
+  formatTerminalResult,
+  isLawfulTypedTerminalOutcome,
+  type TerminalResult,
+} from "./terminal.ts";
 import {
   projectRoleTurnRequest,
   type RoleTurnRequestProjectionOptions,
@@ -59,10 +65,42 @@ export type ReviewerRunEnv = PostAdmissionEnv & {
   createRunId?: () => string;
 };
 
+type ReviewerRunResult = {
+  exitCode: number;
+  admitted?: AdmittedReviewerInvocation;
+  terminal?: TerminalResult;
+};
+
 function reviewerMethods(packageRoot: string): readonly MethodBinding[] {
   return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "ak-cross-m-review") }];
 }
 
+/**
+ * All Reviewer turns (explicit --lens, dual-lens child, resume) execute in a
+ * fresh worktree of the source tree's current HEAD (#946 统一新副本). Dual-lens
+ * summon already injects executionCwd; only mint when absent. Cleanup failure
+ * is diagnostic only and does not flip the exit code. Mint failure propagates
+ * so the caller can settle a controlled failure against the admitted run.
+ */
+async function runReviewerTurnInFreshCopy(
+  env: ReviewerRunEnv,
+  projectRoot: string,
+  io: CliIo,
+  body: (sandboxedEnv: ReviewerRunEnv) => Promise<ReviewerRunResult>,
+): Promise<ReviewerRunResult> {
+  if (env.executionCwd !== undefined) {
+    return body(env);
+  }
+  const { withEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+  return await withEphemeralReviewerWorktree({
+    projectRoot,
+    onCleanupDiagnostic: (diagnostic) => {
+      io.stderr(`${diagnostic}\n`);
+    },
+    run: (executionCwd) => body({ ...env, executionCwd }),
+  });
+}
+
 /** Project admitted Reviewer invocation onto the host-neutral turn request. */
 export function buildReviewerTurnRequest(
   admitted: AdmittedReviewerInvocation,
@@ -149,7 +187,7 @@ export async function runPublicReviewer(
     instruction: string;
     attachmentPaths: string[];
     baseRevision: string;
-    lens: ReviewerLens;
+    lens?: ReviewerLens;
     authorityRefs: string[];
     project?: string;
   },
@@ -158,9 +196,100 @@ export async function runPublicReviewer(
   admitted?: AdmittedReviewerInvocation;
   terminal?: TerminalResult;
 }> {
+  let parsed: ReturnType<typeof parseReviewerArgv>;
+  try {
+    parsed = parseReviewerArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // Omitted public lens is the parallel two-axis branch mark; never admitted as a parent run.
+  // Each leg reuses this call's public argv and only adds --lens (#946 / 10a).
+  if (parsed.lens === undefined) {
+    const { summonParallelReviewerLenses } = await import("../public-role-summons.ts");
+    const children = await summonParallelReviewerLenses({
+      argv,
+      // Replay argv under the same cwd the single-axis entry would see (10a).
+      // Do not substitute the resolved project path — relative --project must
+      // not be re-resolved against a shifted cwd.
+      cwd: env.cwd,
+      projectRoot: resolve(parsed.project ?? env.cwd),
+      // Typed base from the public parse — precheck only; child argv stays verbatim.
+      baseRevision: parsed.baseRevision,
+      home: env.home,
+      agentDir: env.agentDir,
+      ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
+      ...(env.model === undefined ? {} : { model: env.model }),
+      ...(env.host === undefined ? {} : { host: env.host }),
+      ...(env.engine === undefined ? {} : { engine: env.engine }),
+      ...(env.engineModel === undefined ? {} : { engineModel: env.engineModel }),
+      packageRoot: env.packageRoot,
+      ...(env.signal === undefined ? {} : { signal: env.signal }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
+      roleTurnHost: env.roleTurnHost,
+      ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+      principalAuthority: env.principalAuthority,
+      ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+    });
+    const childResults = [children.completeness, children.correctness] as const;
+    const terminals = childResults
+      .map((child) => child.terminal)
+      .filter((terminal): terminal is TerminalResult => terminal !== undefined);
+    // ADR 0052 / terminal.ts: lawful typed child terminals (accepted / no_receipt /
+    // audit_escalation) are not batch failures. Child exitCode remains the live
+    // surface for seal/infrastructure overlays that keep the original Terminal.
+    // failedChildren counts only non-lawful/missing child Terminals; seal overlays
+    // that flip exitCode while keeping lawful Terminals are a separate identity.
+    const failedChildren = childResults.filter((child) =>
+      child.terminal === undefined
+      || !isLawfulTypedTerminalOutcome(child.terminal.roleOutcome)).length;
+    const overlayExit = childResults.some((child) => child.exitCode !== 0);
+    const failed = failedChildren > 0 || overlayExit;
+    const overlayDiagnostics = [...new Set(
+      childResults
+        .map((child) => child.stderr)
+        .filter((text): text is string => typeof text === "string" && text !== ""),
+    )];
+    const terminal: TerminalResult = {
+      batch: "reviewer",
+      roleOutcome: failed
+        ? {
+            kind: "failure",
+            role: "reviewer",
+            diagnostic: failedChildren > 0
+              ? "Reviewer batch child failure"
+              : (overlayDiagnostics[0] ?? "Reviewer batch infrastructure failure"),
+            decisiveFacts: { failedChildren },
+            payloads: terminals,
+          }
+        : { kind: "accepted", role: "reviewer", payloads: terminals },
+      reviewerChildren: {
+        ...(children.completeness.terminal === undefined ? {} : { completeness: children.completeness.terminal }),
+        ...(children.correctness.terminal === undefined ? {} : { correctness: children.correctness.terminal }),
+      },
+      reviewerChildOutcomes: {
+        completeness: { exitCode: children.completeness.exitCode, ...(children.completeness.stderr === undefined ? {} : { stderr: children.completeness.stderr }) },
+        correctness: { exitCode: children.correctness.exitCode, ...(children.correctness.stderr === undefined ? {} : { stderr: children.correctness.stderr }) },
+      },
+      // Batch has no parent run and no own attendance; no-advice is affirmative
+      // only (navigator-attendance.ts). Children carry their own navigator facts.
+      navigator: {
+        disposition: "unavailable",
+        source: "unknown",
+        reason: "Reviewer batch has no parent-run Navigator attendance",
+      },
+      artifacts: terminals.flatMap((item) => item.artifacts),
+    };
+    io.stdout(formatTerminalResult(terminal));
+    return { exitCode: failed ? 1 : 0, terminal };
+  }
+
   let admitted: AdmittedReviewerInvocation;
   try {
-    const parsed = parseReviewerArgv(argv);
     admitted = await admitReviewerInvocation({
       home: env.home,
       principalAuthority: env.principalAuthority,
@@ -172,6 +301,7 @@ export async function runPublicReviewer(
       authorityRefs: parsed.authorityRefs,
       ...(parsed.project === undefined ? {} : { project: parsed.project }),
       ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
       ...(env.model === undefined ? {} : { model: env.model }),
     });
   } catch (error) {
@@ -202,56 +332,82 @@ export async function runPublicReviewer(
     )) as { exitCode: number; admitted: AdmittedReviewerInvocation; terminal: TerminalResult };
   }
 
-  return await runPostAdmissionResumable({
-    admitted,
-    env,
-    io,
-    buildInitialRequest: () =>
-      buildReviewerTurnRequest(admitted, {
-        packageRoot: env.packageRoot,
-        home: env.home,
-        agentDir: env.agentDir,
-        ...(env.model === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { correlationId: admitted.correlationId ?? env.correlationId }),
-        continuation: {
-          kind: "initial",
-          prompt: buildReviewerTransportPrompt(
-            admitted,
-            engineSessionMaterialFromOptions({
-              ...pickEngineAxis(env),
-              packageRoot: env.packageRoot,
-            }),
-          ),
-        },
-      }),
-    buildResumeRequest: () =>
-      buildReviewerTurnRequest(admitted, {
-        packageRoot: env.packageRoot,
-        home: env.home,
-        agentDir: env.agentDir,
-        ...(env.model === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { correlationId: admitted.correlationId ?? env.correlationId }),
-        continuation: {
-          kind: "resume",
-          prompt: reviewerResumePrompt(env),
-        },
-      }),
-    adapters: reviewerAdapters(env.packageRoot, methodMaterial),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
+  // Fresh copy for this call (explicit --lens or dual-lens child with pre-set cwd).
+  // Durable projectRoot stays the caller project; only the host turn uses the sandbox.
+  try {
+    return await runReviewerTurnInFreshCopy(env, admitted.projectRoot, io, async (sandboxedEnv) =>
+      await runPostAdmissionResumable({
+        admitted,
+        env: sandboxedEnv,
+        io,
+        buildInitialRequest: () =>
+          buildReviewerTurnRequest(admitted, {
+            packageRoot: sandboxedEnv.packageRoot,
+            home: sandboxedEnv.home,
+            agentDir: sandboxedEnv.agentDir,
+            ...(sandboxedEnv.model === undefined ? {} : { model: sandboxedEnv.model }),
+            ...pickEngineAxis(sandboxedEnv),
+            ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
+            ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
+              ? {}
+              : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
+            // Ephemeral worktree cwd; durable projectRoot stays on admitted caller project.
+            ...(sandboxedEnv.executionCwd === undefined ? {} : { cwd: sandboxedEnv.executionCwd }),
+            continuation: {
+              kind: "initial",
+              prompt: buildReviewerTransportPrompt(
+                admitted,
+                engineSessionMaterialFromOptions({
+                  ...pickEngineAxis(sandboxedEnv),
+                  packageRoot: sandboxedEnv.packageRoot,
+                }),
+              ),
+            },
+          }),
+        buildResumeRequest: () =>
+          buildReviewerTurnRequest(admitted, {
+            packageRoot: sandboxedEnv.packageRoot,
+            home: sandboxedEnv.home,
+            agentDir: sandboxedEnv.agentDir,
+            ...(sandboxedEnv.model === undefined ? {} : { model: sandboxedEnv.model }),
+            ...pickEngineAxis(sandboxedEnv),
+            ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
+            ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
+              ? {}
+              : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
+            // In-batch auto-resume keeps the same call's sandbox (dual-lens or single).
+            ...(sandboxedEnv.executionCwd === undefined ? {} : { cwd: sandboxedEnv.executionCwd }),
+            continuation: {
+              kind: "resume",
+              prompt: reviewerResumePrompt(sandboxedEnv),
+            },
+          }),
+        adapters: reviewerAdapters(sandboxedEnv.packageRoot, methodMaterial),
+        ...(sandboxedEnv.engine === undefined ? {} : { effectiveEngine: sandboxedEnv.engine }),
+      }));
+  } catch (error) {
+    return (await presentControlledFailure(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error,
+      },
+      reviewerAdapters(env.packageRoot, methodMaterial),
+      env.principalAuthority,
+      io,
+    )) as ReviewerRunResult;
+  }
 }
 
 /**
  * Resume a previously admitted Reviewer Role run after a typed HTTP 429.
  * Restores task/base/session identity; model override is temporary.
+ * Execution always uses a fresh worktree of the source tree at resume time
+ * (#946 统一新副本 / 10a) — no old worktree, no ownership record.
+ * Fresh-copy mint reuses the coordinator's single pre-lease load via
+ * afterAdmittedPrepare; does not pre-load outside the coordinator.
  */
 export async function runPublicReviewerResume(
   request: PublicResumeRequest,
@@ -262,6 +418,11 @@ export async function runPublicReviewerResume(
   admitted?: AdmittedReviewerInvocation;
   terminal?: TerminalResult;
 }> {
+  // Call-local cell: afterAdmittedPrepare writes executionCwd; buildTurnRequest reads it.
+  // Keeps the single-load coordinator contract — no preliminary load outside.
+  const sandbox: { executionCwd?: string } = {
+    ...(env.executionCwd === undefined ? {} : { executionCwd: env.executionCwd }),
+  };
   return await runPostAdmissionSeatResume({
     request,
     env,
@@ -269,25 +430,49 @@ export async function runPublicReviewerResume(
     load: (effective) =>
       loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
     buildTurnRequest: (admitted, effective) => {
-      const base = resumeTurnRequestProjectionOptions(admitted, effective, env);
+      const activeEnv: ReviewerRunEnv = sandbox.executionCwd === undefined
+        ? env
+        : { ...env, executionCwd: sandbox.executionCwd };
+      const base = resumeTurnRequestProjectionOptions(admitted, effective, activeEnv);
       return buildReviewerTurnRequest(admitted, {
         ...base,
+        // Fresh copy at resume time; durable projectRoot unchanged.
+        ...(sandbox.executionCwd === undefined ? {} : { cwd: sandbox.executionCwd }),
         continuation: {
           kind: "resume",
-          prompt: reviewerResumePrompt(env, effective.message),
+          prompt: reviewerResumePrompt(activeEnv, effective.message),
         },
       });
     },
     adapters: reviewerAdapters(env.packageRoot),
-    afterAdmittedLoad: (admitted) =>
-      resolveResumeMethodMaterialAdapters({
+    afterAdmittedLoad: async (admitted) => {
+      return resolveResumeMethodMaterialAdapters({
         admitted,
         authority: env.principalAuthority,
         io,
         loadMaterial: () => loadReviewerMethodMaterial(env.packageRoot),
         adaptersWith: (material) => reviewerAdapters(env.packageRoot, material),
         emptyAdapters: reviewerAdapters(env.packageRoot),
-      }),
+      });
+    },
+    afterAdmittedPrepare: async (admitted) => {
+      // Already sandboxed (in-batch auto-resume path) — nothing to mint.
+      if (sandbox.executionCwd !== undefined) {
+        return { env: { ...env, executionCwd: sandbox.executionCwd } };
+      }
+      const { openEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+      const opened = await openEphemeralReviewerWorktree({
+        projectRoot: admitted.projectRoot,
+        onCleanupDiagnostic: (diagnostic) => {
+          io.stderr(`${diagnostic}\n`);
+        },
+      });
+      sandbox.executionCwd = opened.executionCwd;
+      return {
+        env: { ...env, executionCwd: opened.executionCwd },
+        cleanup: opened.close,
+      };
+    },
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

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

@@ -127,8 +127,17 @@ export type RoleRunRecord = {
   readonly resumable?: TypedHttp429Observation;
 };
 
-/** Package-owned turn trigger for resume. Not caller instruction and not semantic task content. */
-export const RESUME_TRANSPORT_ENVELOPE = "[ak-role:resume-continue]" as const;
+/**
+ * Package-owned non-empty Chinese neutral resume transport (#959 / ADR 0073).
+ * Used by:
+ *   - auto-resume (all seats via buildAutoResumeContinuationPrompt) — required so
+ *     hosts that reject empty stdin (codex) still receive a prompt;
+ *   - reviewer seat manual resume (reviewerResumePrompt) — same non-empty need on
+ *     that seat's own manual entry.
+ * Generic bare `ak-role resume` stays empty-capable via selectResumeContinuationPrompt
+ * / buildResumeContinuationPrompt — ADR 0080 keeps auto and generic-manual entries separate.
+ */
+export const RESUME_TRANSPORT_ENVELOPE = "继续。" as const;
 
 /** Public manual resume request after the unique CLI parser owns runId + optional message. */
 export type PublicResumeRequest = {
@@ -169,9 +178,11 @@ export type SameTicketSummonsMaterials = {
 };
 
 /**
- * Unique continuation-prompt selector for manual/auto engine-axis resume
- * (#471 / #600 / #736). Message present → those bytes; absent → engine pointers only.
- * #836: no transport-token prompt, no line-by-line 重新读 rewrite.
+ * Manual resume continuation selector (#471 / #600 / #736 / ADR 0080).
+ * Message present → those bytes; absent → engine pointers only (may be empty).
+ * Caller message (including blank) still wins verbatim when supplied.
+ * Auto-resume must use buildAutoResumeContinuationPrompt — do not fold the
+ * non-empty Chinese envelope into this shared manual selector (#959).
  */
 export function selectResumeContinuationPrompt(
   message?: string,
@@ -182,8 +193,8 @@ export function selectResumeContinuationPrompt(
 }
 
 /**
- * Resume continuation with engine material resolved from the seat env (#600).
- * Seat table / invocation engine axis rides the same prompt seam as initial runs.
+ * Manual resume continuation with engine material from the seat env (#600).
+ * Bare manual resume stays empty-prompt-capable; auto-resume is a separate entry.
  */
 export function buildResumeContinuationPrompt(options: {
   packageRoot: string;
@@ -200,6 +211,25 @@ export function buildResumeContinuationPrompt(options: {
   );
 }
 
+/**
+ * Auto-resume continuation only (#959 / ADR 0080).
+ * Always non-empty: Chinese neutral envelope plus optional engine pointers.
+ * Never call this from manual `ak-role resume`.
+ */
+export function buildAutoResumeContinuationPrompt(options: {
+  packageRoot: string;
+  engine?: string;
+  engineModel?: string;
+}): string {
+  return selectResumeContinuationPrompt(
+    RESUME_TRANSPORT_ENVELOPE,
+    engineSessionMaterialFromOptions({
+      packageRoot: options.packageRoot,
+      ...pickEngineAxis(options),
+    }),
+  );
+}
+
 const RUN_STATE_FILE = "run-state.json";
 const WRITER_LOCK_FILE = "writer.lock";
 

package/src/public-cli/settlement.ts

@@ -123,7 +123,6 @@ import {
   parseInvocationMarkerIdentity,
   type InvocationMarkerIdentity,
 } from "../navigator-invocation-identity.ts";
-import type { NavigatorPhase } from "../navigator-attendance.ts";
 import {
   NO_RECEIPT_LIFECYCLE_ENTRY_TYPE,
   RECEIPT_DELIVERY_TURN_LIMIT,
@@ -360,7 +359,7 @@ import {
   exitCodeForTerminalOutcome,
   formatTerminalResult,
   isLawfulTypedTerminalOutcome,
-  recommendationNavigatorFact,
+  adviceNavigatorFact,
   type ControlledFailureCause,
   type TerminalArtifactRef,
   type TerminalGateFact,
@@ -782,7 +781,13 @@ export function explicitInternalKnownFailureClassificationInput(
   };
 }
 
-/** Post-role Navigator delivery grace (Issue #11 / #101 / #106 / #159). */
+/**
+ * Post-role Navigator delivery grace (Issue #11 / #101 / #106 / #159).
+ * After the parent finishes: wait at most this long for navigator output, then
+ * stop waiting. Navigator must already be running from parent start (prepare
+ * host round in parallel); this window is only the tail after parent end — not
+ * the budget to start a cold full host turn (owner 2026-09-17 #959).
+ */
 export const NAVIGATOR_POST_ROLE_GRACE_MS = 10_000;
 
 type SessionMessage = {
@@ -1931,11 +1936,6 @@ export type LawfulJudgeRoleOutcome = Extract<
   TerminalRoleOutcome,
   { kind: "accepted" } | { kind: "audit_escalation" }
 >;
-function navigatorPhaseValue(value: unknown): NavigatorPhase {
-  if (value === "plan" || value === "apply") return value;
-  return null;
-}
-
 /**
  * Minimal attendance provenance against the bound marker (ADR 0043).
  * Keep only invocationId + post-terminal ordering. Runtime-self-produced
@@ -1960,35 +1960,44 @@ function parseNavigatorAttendanceDetails(
   const advisoryDiagnostic = typeof details.routePlaybookReadFailure === "string"
     ? { advisoryDiagnostic: details.routePlaybookReadFailure }
     : {};
-  if (disposition === "recommendation") {
-    const next = details.next;
-    if (!isRecord(next) || typeof next.role !== "string") {
+  // #959: advice prose is presented as-is. Legacy "recommendation" with next/reason/
+  // command is projected into prose so historical sessions still render — never wash
+  // a real recommendation into no-advice when any advice body is recoverable.
+  if (disposition === "advice" || disposition === "recommendation") {
+    let prose: string | undefined;
+    if (typeof details.prose === "string" && details.prose.trim() !== "") {
+      prose = details.prose;
+    } else {
+      const next = isRecord(details.next) && typeof details.next.role === "string"
+        ? details.next.role
+        : undefined;
+      const reason = typeof details.reason === "string" && details.reason.trim() !== ""
+        ? details.reason
+        : undefined;
+      const command = typeof details.command === "string" && details.command.trim() !== ""
+        ? details.command
+        : undefined;
+      if (reason !== undefined && next !== undefined) {
+        prose = `${reason}（下一步：${next}）`;
+      } else if (reason !== undefined) {
+        prose = reason;
+      } else if (next !== undefined) {
+        // Historical recommendation with only typed next — still real advice.
+        prose = `下一步：${next}`;
+      } else if (command !== undefined) {
+        prose = command;
+      }
+    }
+    if (prose === undefined || prose.trim() === "") {
+      // Attended but empty body is affirmative no-advice, not unavailable (#959).
       return {
-        disposition: "unavailable",
-        source: "unknown",
-        reason: "navigator recommendation missing typed next role",
+        disposition: "no-advice",
+        ...advisoryDiagnostic,
       };
     }
-    const reason = typeof details.reason === "string" ? details.reason : "";
-    const route = Array.isArray(details.route)
-      ? details.route
-          .filter(isRecord)
-          .map((target) => ({
-            role: String(target.role),
-            phase: navigatorPhaseValue(target.phase),
-          }))
-      : undefined;
-    return recommendationNavigatorFact({
+    return adviceNavigatorFact({
+      prose,
       ...advisoryDiagnostic,
-      next: {
-        role: next.role,
-        phase: navigatorPhaseValue(next.phase),
-      },
-      reason,
-      ...(route === undefined ? {} : { route }),
-      ...(typeof details.command === "string"
-        ? { modelCommand: details.command }
-        : {}),
     });
   }
   if (disposition === "unavailable") {
@@ -3634,7 +3643,6 @@ export async function trySettleReviewerTerminalResult(
   return settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
 }
 
-
 /**
  * Observe forced Merger resolving-merge-conflicts Skill expansions from the session.
  * Expansion evidence is package-path only; ambient home locations never count.