@akagilnc/pi-workflow-roles 0.1.3452 → 0.1.3471

package/package.json

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

package/scripts/build-package.mjs

@@ -23,9 +23,7 @@ const entries = [
   "archivist-record-entry",
   // Pure subject nest topology — cold discovery without SessionManager (#636).
   "archivist-record-topology",
-  // Officer ticket-seat pure read + deferred open (#636 public-bin cold graph).
-  "ticket-seat-memory",
-  // ticket-seat-memory → session-opening-materials (#636 non-bundle graph closure).
+  // Session material loaders used by published non-bundle roots.
   "session-opening-materials",
   // Value-import closure of published non-bundle roots (build-package-only loadable).
   "auditor-dossier-tool",

package/src/analyst-gate-cycles-read.ts

@@ -34,11 +34,10 @@ import {
 import {
   extractSessionTimestampSpan,
   intervalRowsAroundAnchor,
-  LedgerSessionJsonlError,
   readLedgerSessionJsonl,
   type LedgerSessionRow,
 } from "./ledger-session-read.ts";
-import { isTicketSeatRunBindingRow } from "./ticket-seat-memory.ts";
+
 
 /** One completed gate round: direct officer receipt or historical province/officer pair. */
 /** Honest origin discriminant: direct summons vs historical province dispatch. */
@@ -349,22 +348,7 @@ async function classifyAuditorVolume(
   filePath: string,
 ): Promise<readonly ClassifiedVolume[]> {
   // Canonical JSONL errors propagate — failure honesty (never wash to fewer rounds).
-  // Shared ticket-seat main volumes are the exception: later-run damage after a
-  // closed binding must not erase earlier gate rounds (same ownership rule as
-  // timeline attribution). Pure nested gate volumes without run bindings stay loud.
-  let rows: readonly LedgerSessionRow[];
-  try {
-    rows = await readLedgerSessionJsonl(filePath);
-  } catch (error) {
-    if (
-      error instanceof LedgerSessionJsonlError
-      && error.prefixRows.some((row) => isTicketSeatRunBindingRow(row))
-    ) {
-      rows = error.prefixRows;
-    } else {
-      throw error;
-    }
-  }
+  const rows = await readLedgerSessionJsonl(filePath);
   const accepted = extractAllAcceptedGateToolCalls(rows);
   // Rejected-only / non-gate volumes omit (empty accepted set).
   if (accepted.length === 0) return [];
@@ -455,9 +439,7 @@ function pairGateRounds(
  * ENOENT (directory truly absent) → []. ENOTDIR and other errors propagate
  * (failure honesty — damaged topology must not wash to zero rounds).
  *
- * #636 ticket-seat memory may place officer volumes under book-level subject
- * digests shared across parent runs; pass `parentSessionFile` to keep only
- * rounds whose attempt binding names that parent.
+ * Pass `parentSessionFile` to keep only rounds whose attempt binding names that parent.
  */
 export async function readAnalystGateCyclesFromAuditorRoles(
   auditorRolesDirectory: string | readonly string[],

package/src/analyst-ledger.ts

@@ -25,7 +25,6 @@ import {
   extractSessionModelSequence,
   extractSessionTimestampSpan,
   extractSessionToolIntervals,
-  intervalRowsForMatchingBinding,
   LedgerSessionJsonlError,
   readLedgerSessionJsonl,
   type LedgerSessionRow,
@@ -46,11 +45,6 @@ import {
   readAnalystGateCyclesFromAuditorRoles,
   type AnalystGateCycleRound,
 } from "./analyst-gate-cycles-read.ts";
-import {
-  isTicketSeatRunBindingRow,
-  resolveTicketSeatMemoryNestDirectories,
-  ticketSeatRunBindingRunId,
-} from "./ticket-seat-memory.ts";
 
 export type { AnalystGateCycleRound } from "./analyst-gate-cycles-read.ts";
 
@@ -210,16 +204,9 @@ async function resolveSessionFile(
 }
 
 /**
- * Attribute session rows to one run (#636 D).
+ * Attribute session rows to one run.
  * Private run volumes (session under runDirectory) keep the whole file.
- * Shared ticket-seat main volumes must carry this run's binding interval;
- * whole-volume stats would let later continuations pollute earlier runs.
- * Unbounded external volumes stay honest missing — never silent full ownership.
- *
- * `closed` on shared intervals: a later binding ended ownership before EOF of
- * the provided rows. On damaged-prefix recovery, only closed intervals keep
- * full frame/model/tool facts — open intervals may have lost rows to the bad line.
- * Private volumes are never closed against a prefix (the whole file is this run).
+ * External volumes stay honest missing — never silent full ownership.
  */
 function attributeSessionRowsForRun(input: {
   readonly rows: readonly LedgerSessionRow[];
@@ -236,19 +223,10 @@ function attributeSessionRowsForRun(input: {
   if (pathContainedIn(input.runDirectory, input.sessionFile)) {
     return { kind: "attributed", rows: input.rows, closed: false };
   }
-  const interval = intervalRowsForMatchingBinding(
-    input.rows,
-    isTicketSeatRunBindingRow,
-    (row) => ticketSeatRunBindingRunId(row) === input.runId,
-  );
-  if (interval === undefined) {
-    return {
-      kind: "missing-boundary",
-      reason:
-        "shared session volume has no ticket-seat run binding for this run",
-    };
-  }
-  return { kind: "attributed", rows: interval.rows, closed: interval.closed };
+  return {
+    kind: "missing-boundary",
+    reason: "session volume is outside the run directory",
+  };
 }
 
 /**
@@ -382,8 +360,7 @@ async function classifyScopedRun(input: {
   let partialFirstFrameAt: AnalystFirstFrameAt = { status: "absent" };
   let partialLastFrameAt: AnalystOptionalTimestamp = { status: "absent" };
 
-  // 1) session timeline — shared ticket-seat volumes slice to this run's binding.
-  // Damage after a closed binding interval must not erase that run's full facts.
+  // 1) session timeline from the run-private volume.
   const sessionFile = await resolveSessionFile(input.runDirectory);
   let rows: readonly LedgerSessionRow[] | undefined;
   const admitAttributed = (
@@ -516,21 +493,13 @@ async function classifyScopedRun(input: {
   // Nested auditor-roles gate pairs stay inside the sole scan (families must
   // not readdir this tree again). Missing directory → []. Damaged discovered
   // nested JSONL is page-local unreadable — never silently under-count rounds.
-  // #636: ticket-seat memory nests via sole discovery helper.
   let gateCycles: readonly AnalystGateCycleRound[];
   try {
-    const memoryNests = await resolveTicketSeatMemoryNestDirectories({
-      runDirectory: input.runDirectory,
-      seats: ["inspector", "notary"],
-    });
-    const directories = [
-      join(input.runDirectory, "session", "auditor-roles"),
-      ...memoryNests,
-    ];
     const parentSessionFile = join(input.runDirectory, "session", "session.jsonl");
-    gateCycles = await readAnalystGateCyclesFromAuditorRoles(directories, {
-      parentSessionFile,
-    });
+    gateCycles = await readAnalystGateCyclesFromAuditorRoles(
+      join(input.runDirectory, "session", "auditor-roles"),
+      { parentSessionFile },
+    );
   } catch (error) {
     return {
       kind: "unreadable",

package/src/archivist-record-entry.ts

@@ -136,10 +136,9 @@ export type RecordSessionOpen = {
  * identity is checked once before SessionManager.open (directory walk cannot see a
  * trailing .jsonl symlink). New principals mint under the already-validated sessionDir
  * via destination-free SessionManager.create — no derived postcondition.
- * Resume via the AK-owned current-session ledger is limited to subject-keyed identity and the
- * authorized worker-submission-gate durable path. Ordinary no-subject children
- * (evidence-children, auditor-roles, …) always mint a fresh session — never reopen
- * a sibling volume selected only by kind/cwd/mtime.
+ * Resume via the AK-owned current-session ledger is limited to subject-keyed identity
+ * and the authorized worker-submission-gate durable path (ADR 0066).
+ * Other ordinary no-subject children (auditor-roles, evidence-children, …) always mint fresh.
  * New persisted principals materialize their deferred session header before return so
  * custom-entry-only writers do not need a parallel delayed-header helper.
  *
@@ -183,8 +182,8 @@ export function createRecordSessionOpen(options: CreateRecordSessionOptions): Re
   const nestAlreadyExists = existsSync(sessionDir);
   // Directory-chain ownership: containment + physical components (no parallel assert).
   ensureRealDirectoryTree(ledgerHome, sessionDir);
-  // Subject-keyed nests continue by subject digest; gate durable resume is the only
-  // authorized no-subject same-nest continuation. All other kinds mint fresh.
+  // Subject-keyed nests continue by subject digest; worker-submission-gate is the
+  // sole authorized no-subject same-nest continuation. All other kinds mint fresh.
   const mayResumeSameNest =
     options.subject !== undefined || options.kind === WORKER_SUBMISSION_GATE_KIND;
   if (mayResumeSameNest && nestAlreadyExists) {

package/src/evidence-child-executor.ts

@@ -26,12 +26,6 @@ import {
 } from "./compliance-transport.ts";
 import { auditorRunDirectory } from "./auditor-dossier-tool.ts";
 import { sitianReport } from "./sitian-facade.ts";
-import {
-  isTicketSeatMemorySeat,
-  readRunTicketNumber,
-  ticketSeatMemorySubject,
-  TICKET_SEAT_MEMORY_KIND,
-} from "./ticket-seat-memory.ts";
 import { createEngineDetourToolDefinition } from "./engine-detour-tool.ts";
 import { engineNameFromEnv } from "./engine-detour.ts";
 import {
@@ -518,7 +512,6 @@ function auditorSeatKey(gateSeat: GateOfficerSeat | undefined): string {
 export async function executeAuditorChild(
   options: AuditorRoleOptions,
 ): Promise<{ decision: unknown; response: AssistantMessage; noReceiptLifecycle?: NoReceiptLifecycleFacts }> {
-  const { createRecordSession } = await import("./archivist-record-entry.ts");
   const runDirectory = options.runDirectory ?? auditorRunDirectory(options.context);
   if (runDirectory === undefined) {
     throw new Error(`${options.roleLabel} requires a run directory carrying the institutional resolution page`);
@@ -570,16 +563,13 @@ export async function executeAuditorChild(
     const parentHeader = parentSessionManager?.getHeader?.();
     const parentSessionFile = parentSessionManager?.getSessionFile?.();
     const parentAttemptEntryId = parentSessionManager?.getLeafId?.();
-    // #636: ticket+seat subject resumes the same nest (navigator subject path); no ticket → fresh nest.
-    const ticketNumber = await readRunTicketNumber(runDirectory);
-    const memorySubject =
-      ticketNumber !== undefined && isTicketSeatMemorySeat(seat)
-        ? ticketSeatMemorySubject(ticketNumber, seat)
-        : undefined;
+    // Institutional child under parent placement for gate/settlement discovery.
+    // No ticket:seat subject nest (#636 deleted / ADR 0079). Public officer seats
+    // resume via tryResumeSameTicketSeatRun on the seat's own run — not this nest.
+    const { createRecordSession } = await import("./archivist-record-entry.ts");
     const auditorSessionManager: SessionManager = createRecordSession({
       cwd,
-      kind: TICKET_SEAT_MEMORY_KIND,
-      ...(memorySubject === undefined ? {} : { subject: memorySubject }),
+      kind: "auditor-roles",
       ...(parentSessionManager === undefined ? {} : { parent: parentSessionManager }),
     });
 

package/src/grok/production-host.ts

@@ -166,26 +166,19 @@ export async function bindProductionGrokIsolation(
  * and AK seatbelt hooks via settleProductionGrokHomeCleanup (no silent catch)
  * while preserving the session dossier under runDirectory/grok-home. Success,
  * typed-result, and throw paths all clean up; cleanup failure and primary+cleanup
- * both surface.
- *
- * `noteOpened` fires only after bind succeeds — the actual open event, distinct
- * from turn return/throw — so last-host ownership can retain the opened run
- * even when the body or cleanup later throws (#636).
+ * both surface. Same-run Grok isolation only — no cross-run home override (#637).
  */
 export async function withProductionGrokIsolation<T>(
   runDirectory: string,
   operatorHome: string,
   packageRoot: string,
   run: (binding: ProductionGrokIsolationBinding) => Promise<T>,
-  noteOpened?: (runDirectory: string) => void,
 ): Promise<T> {
   let binding: ProductionGrokIsolationBinding | undefined;
   let primaryFailure: ProductionGrokPrimaryFailure = NO_PRODUCTION_GROK_PRIMARY_FAILURE;
   let value!: T;
   try {
     binding = await bindProductionGrokIsolation(runDirectory, operatorHome, packageRoot);
-    // Open fact: bind succeeded under runDirectory. Not deferred to turn outcome.
-    noteOpened?.(runDirectory);
     value = await run(binding);
   } catch (error) {
     primaryFailure = { present: true, value: error };
@@ -285,26 +278,9 @@ async function recordGrokCapabilities(
   );
 }
 
-/**
- * Which run directory owns GROK_HOME for this turn (#636 / ADR 0077).
- * Same-host ticket-seat resume reopens the prior native home; otherwise the live run.
- * Private to the production host — not a test seam.
- */
-function resolveProductionGrokIsolationRunDirectory(
-  request: Pick<RoleTurnRequest, "runDirectory" | "continuation" | "nativeHomeRunDirectory">,
-): string {
-  if (
-    request.continuation.kind === "resume" &&
-    typeof request.nativeHomeRunDirectory === "string" &&
-    request.nativeHomeRunDirectory.length > 0
-  ) {
-    return request.nativeHomeRunDirectory;
-  }
-  return request.runDirectory;
-}
-
 /**
  * Assemble the production grok-build RoleTurnHost from the S6 true adapter.
+ * Isolation always under the live request.runDirectory (same-run resume keeps it).
  */
 export function createProductionGrokRoleTurnHost(options: ProductionGrokHostOptions): RoleTurnHost {
   const { packageRoot, principalAuthority } = options;
@@ -342,13 +318,9 @@ export function createProductionGrokRoleTurnHost(options: ProductionGrokHostOpti
 
   return {
     executeTurn(request) {
-      // #636 same-host ticket-seat resume: reopen the prior run's grok-home so
-      // session/load hits the ACP storage that bound the shared principal.
-      // Fresh runs and cross-host arrivals keep isolating under request.runDirectory.
-      const isolationRunDirectory = resolveProductionGrokIsolationRunDirectory(request);
       const execution = serial.then(() =>
         withProductionGrokIsolation(
-          isolationRunDirectory,
+          request.runDirectory,
           request.home,
           packageRoot,
           async (binding) => {
@@ -360,7 +332,6 @@ export function createProductionGrokRoleTurnHost(options: ProductionGrokHostOpti
               turn = undefined;
             }
           },
-          request.noteNativeHomeOpened,
         ),
       );
       serial = execution.then(

package/src/grok/role-envelope.ts

@@ -539,16 +539,19 @@ export async function prepareGrokRoleEnvelope(options: {
   const relay = fileURLToPath(new URL("./mcp-relay.mjs", import.meta.url));
   let disposed = false;
   // Tools execute in this process (relay is protocol-only). Mirror Pi's child-env
-  // AK_ROLE_RUN_DIR injection onto the parent so ledger runIdentity correlates
-  // with settlement's bare admitted.runId via runIdFromRunDirectory. Inject only
+  // AK_ROLE_RUN_DIR / AK_ROLE_COURT_ATTEMPT injection onto the parent so ledger
+  // runIdentity and court-attempt identity correlate with settlement. Inject only
   // after prepare succeeds (below); dispose must restore including unset.
   let priorAkRoleRunDir: string | undefined;
+  let priorAkRoleCourtAttempt: string | undefined;
   let runDirInjected = false;
-  const restoreAkRoleRunDir = (): void => {
+  const restoreAkRoleRunEnv = (): void => {
     if (!runDirInjected) return;
     runDirInjected = false;
     if (priorAkRoleRunDir === undefined) delete process.env.AK_ROLE_RUN_DIR;
     else process.env.AK_ROLE_RUN_DIR = priorAkRoleRunDir;
+    if (priorAkRoleCourtAttempt === undefined) delete process.env.AK_ROLE_COURT_ATTEMPT;
+    else process.env.AK_ROLE_COURT_ATTEMPT = priorAkRoleCourtAttempt;
   };
   const dispose = async (): Promise<void> => {
     if (disposed) return;
@@ -560,7 +563,7 @@ export async function prepareGrokRoleEnvelope(options: {
       cleanupFailures.push(error);
     }
     try {
-      restoreAkRoleRunDir();
+      restoreAkRoleRunEnv();
     } catch (error) {
       cleanupFailures.push(error);
     }
@@ -659,7 +662,10 @@ export async function prepareGrokRoleEnvelope(options: {
     }
 
     priorAkRoleRunDir = process.env.AK_ROLE_RUN_DIR;
+    priorAkRoleCourtAttempt = process.env.AK_ROLE_COURT_ATTEMPT;
     process.env.AK_ROLE_RUN_DIR = request.runDirectory;
+    if (request.courtAttemptId === undefined) delete process.env.AK_ROLE_COURT_ATTEMPT;
+    else process.env.AK_ROLE_COURT_ATTEMPT = request.courtAttemptId;
     runDirInjected = true;
 
     return {

package/src/host-contracts.ts

@@ -166,18 +166,11 @@ export type RoleTurnRequest = {
   /** Set by post-admission only on a real host switch; never on same-host resume. */
   readonly hostTransition?: RoleTurnHostTransition;
   /**
-   * Grok native isolation run for ticket-seat resume (#636 / ADR 0079):
-   * reopen grok-home under this prior run (ACP storage). Covers same-host,
-   * same-run retry after a new run, and return-to-Grok after another host.
-   * Absent → isolate under runDirectory. Never a cross-host byte handoff.
+   * Same-ticket re-summons only (#637): opens a new court-turn attempt on the
+   * retained run so submission-ledger sole-final is per attempt, not forever.
+   * Manual resume never sets this — sealed idempotent short-circuit stays intact.
    */
-  readonly nativeHomeRunDirectory?: string;
-  /**
-   * Production Grok isolation notes the actual open event here after bind succeeds
-   * (#636). Open is not the same event as turn return/throw — post-admission uses
-   * this fact for last-host ownership instead of inferring open from the turn outcome.
-   */
-  readonly noteNativeHomeOpened?: (runDirectory: string) => void;
+  readonly courtAttemptId?: string;
 };
 
 /** Turn result — only fields upper layers currently consume. */

package/src/host-transition-prior-native.ts

@@ -72,17 +72,14 @@ export async function listGrokNativeRecordPaths(runDirectory: string): Promise<s
  * Unknown host names → undefined (no inject). Empty native volume still
  * yields a typed switch (empty path list).
  *
- * Grok native home lives under the run that wrote it. Ticket-seat memory
- * cross-run switches pass `previousRunDirectory` from last-host metadata so
- * the scan does not look at an empty fresh run (#636 / #617 DK-4).
+ * Grok native home lives under the live run that wrote it (#617 DK-4 / #637
+ * same-run resume). No cross-run previousRunDirectory override.
  */
 export async function projectHostTransitionPriorNative(input: {
   readonly previousHost: string;
   readonly liveHost: string;
   readonly runDirectory: string;
   readonly piSessionFile: string;
-  /** Prior run that held Grok native records when principal continued across runs. */
-  readonly previousRunDirectory?: string;
 }): Promise<RoleTurnHostTransition | undefined> {
   if (input.previousHost === input.liveHost) return undefined;
   if (!isKnownRoleTurnHost(input.previousHost) || !isKnownRoleTurnHost(input.liveHost)) {
@@ -96,8 +93,7 @@ export async function projectHostTransitionPriorNative(input: {
     };
   }
   // previousHost === "grok-build": DK-7 path handoff only — do not read bytes.
-  const grokRoot = input.previousRunDirectory ?? input.runDirectory;
-  const paths = await listGrokNativeRecordPaths(grokRoot);
+  const paths = await listGrokNativeRecordPaths(input.runDirectory);
   return {
     previousHost: "grok-build",
     priorNativePaths: paths,

package/src/ledger-session-read.ts

@@ -297,20 +297,4 @@ export function intervalRowsAroundAnchor(
   return { rows: rows.slice(start, end), closed: end < rows.length };
 }
 
-/**
- * Interval owned by the first binding row that satisfies `matches`.
- * `undefined` when the volume carries no matching binding — callers must not
- * silently treat the whole continuous volume as that owner.
- */
-export function intervalRowsForMatchingBinding(
-  rows: readonly LedgerSessionRow[],
-  isBindingRow: (row: LedgerSessionRow) => boolean,
-  matches: (row: LedgerSessionRow) => boolean,
-): BindingInterval | undefined {
-  for (let i = 0; i < rows.length; i += 1) {
-    const row = rows[i]!;
-    if (!isBindingRow(row) || !matches(row)) continue;
-    return intervalRowsAroundAnchor(rows, i, isBindingRow);
-  }
-  return undefined;
-}
+

package/src/pi/in-process-session.ts

@@ -634,8 +634,8 @@ export async function openPiInstitutionalSession(
     }
 
     // 7. Create AgentSession — thinking is opaque pass-through. Absent selection
-    // omits thinkingLevel (Pi default). Pi clamps unsupported levels itself;
-    // we do not re-check or invent defaults.
+    // omits thinkingLevel (Pi owns default). Pi clamps unsupported levels itself;
+    // we do not re-check or invent package defaults.
     const { session } = await createAgentSession({
       cwd: options.cwd,
       model: effectiveModel,
@@ -651,6 +651,10 @@ export async function openPiInstitutionalSession(
       ...(options.toolsAllowlist === undefined ? {} : { tools: options.toolsAllowlist as string[] }),
       ...(customTools.length === 0 ? {} : { customTools }),
     });
+    await session.setModel(effectiveModel);
+    if (options.selection.thinking !== undefined) {
+      session.setThinkingLevel(options.selection.thinking as any);
+    }
 
     // 8. Event subscriptions
     const listeners = new Set<(event: HostInstitutionalSessionEvent) => void>();

package/src/pi/role-turn-host.ts

@@ -50,6 +50,11 @@ export function buildExplicitInternalActivationArgs(
   return ["--no-extensions", "-e", selectedRoleEntry, ...extraArgs];
 }
 
+/**
+ * Pi argv for seat model. Host only passes through resolved values — no local
+ * thinking whitelist and no package default fill. Bare provider/model omits
+ * --thinking so Pi owns its own default (#346/#384). Explicit thinking only.
+ */
 function buildSeatModelCliArgs(model: RoleTurnModelConfig | undefined): string[] {
   if (model === undefined) return [];
   return [
@@ -426,12 +431,16 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
         config.extraPiArgs ?? [],
       );
       const args = buildExplicitInternalActivationArgs(roleEntry, extraArgs);
+      // Shared envelope isolates this call's court identity: omitting courtAttemptId
+      // must not inherit a parent process.env.AK_ROLE_COURT_ATTEMPT (#637).
       const env: NodeJS.ProcessEnv = {
         ...process.env,
         HOME: request.home,
         PI_CODING_AGENT_DIR: request.agentDir,
         AK_ROLE_RUN_DIR: request.runDirectory,
       };
+      if (request.courtAttemptId === undefined) delete env.AK_ROLE_COURT_ATTEMPT;
+      else env.AK_ROLE_COURT_ATTEMPT = request.courtAttemptId;
       applyEngineChildEnv(env, request.engine);
       if (request.correlationId !== undefined && request.correlationId.trim() !== "") {
         env.AK_CORRELATION_ID = request.correlationId;

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

@@ -160,16 +160,16 @@ export async function runPublicCollectorResume(
     request,
     env,
     io,
-    load: () =>
+    load: (effective) =>
       loadResumableCollectorRun(
       env.home,
-      request.runId,
+      effective.runId,
       env.principalAuthority,
     ),
-    buildTurnRequest: (admitted) =>
+    buildTurnRequest: (admitted, effective) =>
       buildCollectorTurnRequest(
       admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
+      resumeTurnRequestProjectionOptions(admitted, effective, env),
     ),
     adapters: collectorAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),