@akagilnc/pi-workflow-roles 0.1.5212 → 0.1.5235

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

@@ -1,3 +1,4 @@
+import { join } from "node:path";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 
@@ -8,7 +9,10 @@ import {
   raceAgainstHostAbort,
 } from "../external-host-turn-loop.ts";
 
-import { reportHostSessionEvent } from "../host-session-record.ts";
+import {
+  copyAndRecordHostDossier,
+  recordNativeSessionPointer,
+} from "../host-session-record.ts";
 import {
   NAVIGATOR_OUTPUT_TOOL_NAME,
   navigatorProseFromUnknown,
@@ -20,30 +24,6 @@ import {
 } from "../prepared-role-turn.ts";
 import { acpModelId, type AcpHostDescription } from "./description.ts";
 
-/** #971: authorized host for usage + auto_compact ledgering only. */
-const GROK_BUILD_HOST = "grok-build";
-
-/** #971: grok-build prompt result carries host usage under `_meta.usage`. */
-function acpPromptResultHasUsage(result: Readonly<Record<string, unknown>>): boolean {
-  const meta = result._meta;
-  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return false;
-  return Object.prototype.hasOwnProperty.call(meta, "usage");
-}
-
-/**
- * #971: ledger only the authorized vendor compaction notice on grok-build.
- * Other `_x.ai/*` notifications stay out of host-session records.
- */
-function isAcpAutoCompactCompletedNotification(
-  method: string,
-  params: Readonly<Record<string, unknown>>,
-): boolean {
-  if (method !== "_x.ai/session_notification") return false;
-  const update = params.update;
-  if (typeof update !== "object" || update === null || Array.isArray(update)) return false;
-  return (update as { sessionUpdate?: unknown }).sessionUpdate === "auto_compact_completed";
-}
-
 /**
  * #959: collect free-form agent text from ACP session/update stream.
  * Used only when the navigator seat spoke prose without calling the output tool.
@@ -278,7 +258,9 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
     const systemPromptOverride = renderSystemPromptOverride(prepared.systemPrompt);
     let connection: AcpConnection | undefined;
     let sessionId: string | undefined;
+    let sessionOpened = false;
     let accepted = false;
+    const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
     // Mutable so dispose failure can outrank a clean turn (headless withCleanupFailure face).
     let outcome: RoleTurnResult = failure("session", "AcpNoOutcome", "no-outcome");
     try {
@@ -286,66 +268,26 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
         outcome = failure("activation", "UncontrolledAcpSession", "ak-config-missing");
       } else {
       connection = await config.connect(request);
-      // Live host-session records: ACP session/update → sitian sole entry (#811).
-      // One abort + one race helper + one outer projection — write failure ends
-      // any in-flight RPC as typed session infrastructure failure.
-      const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
-      const recordAbort = new AbortController();
-      let hostSessionRecordFailure: RoleTurnKnownFailure | undefined;
-      const hostSessionRecordResult = (): RoleTurnResult => ({
-        code: null,
-        stderr: "",
-        timedOut: false,
-        knownFailure: hostSessionRecordFailure!,
-      });
-      const noteHostSessionRecordFailure = (error: unknown): void => {
-        if (hostSessionRecordFailure !== undefined) return;
-        hostSessionRecordFailure = {
-          cause: "session",
-          identity: { name: "HostSessionRecordFailure", code: "host-session-record-failed" },
-          diagnostic: error instanceof Error ? error.message : String(error),
-        };
-        try { recordAbort.abort(); } catch { /* already aborted */ }
-      };
       const rpc = (
         method: string,
         params: Readonly<Record<string, unknown>>,
-      ): Promise<Readonly<Record<string, unknown>>> =>
-        raceAgainstHostAbort(connection!.request(method, params), recordAbort.signal, "host-session-record-failed");
+      ): Promise<Readonly<Record<string, unknown>>> => connection!.request(method, params);
 
       // #959: navigator free-form agent text — only while session/prompt is in flight.
       // session/load replays history via session/update; those must not enter the bucket
       // (resume / set_model load would otherwise prepend prior turns as "this turn" prose).
       const agentProseChunks: string[] = [];
       let collectAgentProse = false;
-      // #971: usage + auto_compact are grok-build-only; same ACP adapter serves Hermes too.
-      const ledgerGrokBuildObservability = config.hostName === GROK_BUILD_HOST;
       connection.onNotification?.((method, params) => {
-        if (hostSessionRecordFailure !== undefined) return;
         const isSessionUpdate = method === "session/update";
-        const isAutoCompact = ledgerGrokBuildObservability
-          && isAcpAutoCompactCompletedNotification(method, params);
-        // #971: session/update stays; auto_compact_completed is the only vendor notice.
-        if (!isSessionUpdate && !isAutoCompact) return;
-        if (isSessionUpdate && collectAgentProse) {
+        if (!isSessionUpdate) return;
+        if (collectAgentProse) {
           const chunk = acpAgentTextChunk(params);
           if (chunk !== undefined) agentProseChunks.push(chunk);
         }
-        try {
-          reportHostSessionEvent({
-            host: config.hostName,
-            cwd: request.cwd,
-            sessionParent,
-            source: "acp-host",
-            event: { method, params },
-          });
-        } catch (error) {
-          noteHostSessionRecordFailure(error);
-        }
       });
 
-      try {
-        const initialized = await rpc("initialize", {
+      const initialized = await rpc("initialize", {
           protocolVersion: 1,
           clientCapabilities: {},
         });
@@ -374,9 +316,13 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             sessionId: bindSessionId,
             ...sessionBindParams,
           });
-          return typeof loaded.sessionId === "string" && loaded.sessionId !== ""
+          const loadedId = typeof loaded.sessionId === "string" && loaded.sessionId !== ""
             ? loaded.sessionId
             : bindSessionId;
+          if (config.hostName !== "hermes") recordNativeSessionPointer({
+            host: config.hostName, sessionId: loadedId, cwd: request.cwd, sessionParent, home: request.home,
+          });
+          return loadedId;
         };
         if (request.continuation.kind === "resume" && config.boundResume === "session/load") {
           const explicitHostSessionId = request.continuation.hostSessionId;
@@ -384,7 +330,9 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             ? explicitHostSessionId
             : await config.sessionIdentity.load(request.principal);
           if (boundSessionId !== undefined && boundSessionId !== "") {
+            sessionId = boundSessionId;
             sessionId = await loadSession(boundSessionId);
+            sessionOpened = true;
           }
         }
         let sessionReady = true;
@@ -395,6 +343,10 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             outcome = failure("session", "AcpSessionFailure", "session-id-missing");
             sessionReady = false;
           } else {
+            if (config.hostName !== "hermes") recordNativeSessionPointer({
+              host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home,
+            });
+            sessionOpened = true;
             await config.sessionIdentity.bind(request.principal, sessionId);
           }
         }
@@ -415,12 +367,6 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
           roundLimitName: "AcpRoundLimit",
           currentSessionId: () => sessionId,
           async runRound({ prompt, abortSignal }) {
-            if (hostSessionRecordFailure !== undefined) return { status: "terminal", result: hostSessionRecordResult() };
-            // Envelope infra abort, parent cancellation (#675), and host-session
-            // record abort (#811) share one race face for in-flight prompt.
-            const abortParts: AbortSignal[] = [recordAbort.signal];
-            if (abortSignal !== undefined) abortParts.push(abortSignal);
-            const combinedAbort = AbortSignal.any(abortParts);
             let result: Readonly<Record<string, unknown>>;
             // Open the prose gate only for this prompt round; clear any stale chunks first.
             agentProseChunks.length = 0;
@@ -431,36 +377,15 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
                   sessionId: activeSessionId,
                   prompt: [{ type: "text", text: prompt }],
                 }),
-                combinedAbort,
+                abortSignal,
                 "ACP host aborted",
               );
             } catch (error) {
               collectAgentProse = false;
               agentProseChunks.length = 0;
-              if (hostSessionRecordFailure !== undefined) {
-                return { status: "terminal", result: hostSessionRecordResult() };
-              }
               throw error;
             }
             collectAgentProse = false;
-            // #971: per-round grok-build usage is on the prompt JSON-RPC result, not a notice.
-            if (ledgerGrokBuildObservability && acpPromptResultHasUsage(result)) {
-              try {
-                reportHostSessionEvent({
-                  host: config.hostName,
-                  cwd: request.cwd,
-                  sessionParent,
-                  source: "acp-host",
-                  event: { method: "session/prompt", result },
-                });
-              } catch (error) {
-                noteHostSessionRecordFailure(error);
-                return { status: "terminal", result: hostSessionRecordResult() };
-              }
-            }
-            if (hostSessionRecordFailure !== undefined) {
-              return { status: "terminal", result: hostSessionRecordResult() };
-            }
             if (result.stopReason === "refusal") {
               agentProseChunks.length = 0;
               return {
@@ -487,18 +412,9 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             accepted = true;
           },
         });
-        outcome = hostSessionRecordFailure !== undefined ? hostSessionRecordResult() : turnResult;
+        outcome = turnResult;
         } // sessionReady
         } // model match else
-      } catch (error) {
-        // recordAbort races setup RPCs via raceAgainstHostAbort (host-aborted code);
-        // noteHostSessionRecordFailure always sets the typed failure before aborting.
-        if (hostSessionRecordFailure !== undefined) {
-          outcome = hostSessionRecordResult();
-        } else {
-          throw error;
-        }
-      }
       } // mcpServers else
     } finally {
       if (connection !== undefined) {
@@ -509,6 +425,18 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
         try { await connection.close(); }
         catch { /* keep turn result */ }
       }
+      if (config.hostName !== "hermes" && sessionOpened && sessionId !== undefined) {
+        copyAndRecordHostDossier({
+          host: config.hostName,
+          sessionId,
+          cwd: request.cwd,
+          sessionDirectory: join(request.runDirectory, "session"),
+          sessionParent,
+          continuation: request.continuation,
+          ...(request.model !== undefined ? { model: request.model } : {}),
+          ...(request.home !== undefined ? { home: request.home } : {}),
+        });
+      }
       try {
         await prepared.dispose?.();
       } catch (cleanupError) {

package/src/diarist.ts

@@ -1,8 +1,8 @@
 /**
- * 起居郎 volume commit — ADR 0075 `diarist-is-role` / #901.
- * LLM submits bounds; mechanical layer reprojects the
- * unique records.jsonl from session volumes. No human view. No lifecycle here
- * (ADR 0018): the seat prepares, the role envelope commits.
+ * 起居郎 volume commit — ADR 0075 `diarist-is-role` / #901 / #1090.
+ * LLM submits bounds; mechanical layer appends a projection commit from
+ * session volumes (pure append, no cross-submit dedupe). No human view.
+ * No lifecycle here (ADR 0018): the seat prepares, the role envelope commits.
  */
 import { reprojectTicketProvenance } from "./ticket-provenance.ts";
 import type { TicketProvenanceSession } from "./ticket-provenance-contracts.ts";
@@ -19,7 +19,7 @@ export type DiaristCommitFacts = {
 };
 
 /**
- * Reproject the unique diary from LLM-submitted bounds.
+ * Append a diary projection from LLM-submitted bounds (#1090).
  * Shape projection of sessions is the caller's job (accept hook);
  * this seam only copies source facts into the volume.
  */

package/src/engine-detour-usage.ts

@@ -222,7 +222,7 @@ export async function readEngineDetourToolUsage(input: {
   });
 
   const { records } = await readSitianRecords(recordFile);
-  const calls: EngineDetourCallFact[] = [];
+  const callsByToolCallId = new Map<string, EngineDetourCallFact>();
   for (const record of records) {
     if (record.kind !== ENGINE_DETOUR_CALL_KIND) continue;
     const boundScope = invocationScopeIdOfRecord(record);
@@ -240,9 +240,11 @@ export async function readEngineDetourToolUsage(input: {
     };
     const fact = callFactFromSitianPayload(record.payload, pointer);
     if (fact === undefined) continue;
-    calls.push(fact);
+    // ADR 0086: Reader deduplicates by toolCallId within the invocation scope
+    callsByToolCallId.set(fact.toolCallId, fact);
   }
 
+  const calls = Array.from(callsByToolCallId.values());
   return { callCount: calls.length, calls };
 }
 
@@ -300,20 +302,6 @@ export async function readInvocationEngineMounted(
   return typeof raw.engine === "string" && raw.engine.trim() !== "";
 }
 
-/**
- * Selected host from the admission invocation page — for post-admission
- * host-transition classification only. In-turn tools take host from the shared
- * Host envelope (RoleTurnRequest / HostContext), never this reader.
- * Undefined when absent — callers must not invent "pi".
- */
-export function readInvocationSelectedHost(runDirectory: string): string | undefined {
-  const raw = readInvocationRecord(runDirectory);
-  if (raw === undefined) return undefined;
-  return typeof raw.host === "string" && raw.host.trim() !== ""
-    ? raw.host.trim()
-    : undefined;
-}
-
 /** Merge usage into decisiveFacts without touching role payloads. */
 export function withEngineDetourToolUsageFact<
   T extends { readonly decisiveFacts?: Readonly<Record<string, unknown>> },

package/src/external-host-turn-loop.ts

@@ -1,6 +1,6 @@
 /**
  * Middle external-host role-turn loop (#820 / ADR 0082).
- * One copy: serial, prior-native, abort merge/race, 8-round closeRound retry,
+ * One copy: serial, abort merge/race, 8-round closeRound retry,
  * host-aborted, round-limit. Last hop = ExternalHostTurnDriver (four verbs).
  */
 import type {
@@ -9,7 +9,6 @@ import type {
   RoleTurnRequest,
   RoleTurnResult,
 } from "./host-contracts.ts";
-import { isOfficerReviewSeat } from "./packaged-role-registry.ts";
 
 export const EXTERNAL_ROLE_TURN_ROUND_LIMIT = 8 as const;
 
@@ -55,21 +54,6 @@ export function mergeRoleTurnAbortSignals(
   return AbortSignal.any([prepared, request]);
 }
 
-/**
- * Host-transition prior-native paths are machine handoff material (#617 DK-4).
- * #879: station-child officer dialogue must not receive those paths spliced into
- * the review prompt — officers already hold --source-run / binding pointers.
- */
-export function promptWithPriorNativePaths(basePrompt: string, request: RoleTurnRequest): string {
-  if (request.continuation.kind !== "resume") return basePrompt;
-  if (request.stationChild === true && isOfficerReviewSeat(request.activation.role)) {
-    return basePrompt;
-  }
-  const paths = request.hostTransition?.priorNativePaths;
-  if (paths === undefined || paths.length === 0) return basePrompt;
-  return `${basePrompt}\n${paths.join("\n")}`;
-}
-
 export function isHostAbortedError(error: unknown): boolean {
   return typeof error === "object" && error !== null && (error as { code?: unknown }).code === "host-aborted";
 }
@@ -135,7 +119,7 @@ export async function driveExternalRoleTurnRounds(
   request: RoleTurnRequest,
   driver: ExternalHostTurnDriver,
 ): Promise<RoleTurnResult> {
-  let prompt = promptWithPriorNativePaths(prepared.prompt, request);
+  let prompt = prepared.prompt;
   const abortSignal = mergeRoleTurnAbortSignals(prepared.abortSignal, request.signal);
   let stderr = "";
 

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

@@ -22,7 +22,10 @@ import {
   type SessionIdentityAuthority,
 } from "../prepared-role-turn.ts";
 
-import { reportHostSessionEvent } from "../host-session-record.ts";
+import {
+  copyAndRecordHostDossier,
+  recordNativeSessionPointer,
+} from "../host-session-record.ts";
 import {
   closeJsonSchemaForCodex,
   codexTurnArgs,
@@ -261,6 +264,7 @@ function spawnHeadlessTurn(options: {
   readonly stdin?: string;
   /** Called for each complete stdout line as it arrives (live stream-json). */
   readonly onStdoutLine?: (line: string) => void;
+  readonly onClose?: () => void;
 }): Promise<{ code: number | null; stdout: string; stderr: string; timedOut: boolean }> {
   return new Promise((resolve, reject) => {
     if (options.signal?.aborted) {
@@ -325,8 +329,15 @@ function spawnHeadlessTurn(options: {
         lineBuffer = "";
       }
     };
+    let aborted = false;
     const settle = (code: number | null): void => {
       if (settled) return;
+      if (aborted) {
+        settled = true;
+        if (timer !== undefined) clearTimeout(timer);
+        reject(hostAbortedError("headless host aborted"));
+        return;
+      }
       // Final flush first: onStdoutLine may failLine (reject + settled=true).
       flushStdoutLines("", true);
       if (settled) return;
@@ -340,11 +351,9 @@ function spawnHeadlessTurn(options: {
       resolve({ code, stdout: resultStdout, stderr, timedOut });
     };
     const onAbort = (): void => {
-      child.kill("SIGTERM");
       if (settled) return;
-      settled = true;
-      if (timer !== undefined) clearTimeout(timer);
-      reject(hostAbortedError("headless host aborted"));
+      aborted = true;
+      child.kill("SIGTERM");
     };
     child.stdout.setEncoding("utf8").on("data", (chunk: string) => { flushStdoutLines(chunk, false); });
     child.stderr.setEncoding("utf8").on("data", (chunk: string) => {
@@ -357,7 +366,10 @@ function spawnHeadlessTurn(options: {
       options.signal?.removeEventListener("abort", onAbort);
       reject(error);
     });
-    child.on("close", (code) => settle(code));
+    child.on("close", (code) => {
+      options.onClose?.();
+      settle(code);
+    });
     options.signal?.addEventListener("abort", onAbort, { once: true });
     if (options.timeoutMs !== undefined && options.timeoutMs > 0) {
       timer = setTimeout(() => {
@@ -498,6 +510,8 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
       }
 
       const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+      let exitedSessionId: string | undefined;
+      try {
       outcome = await driveExternalRoleTurnRounds(prepared, request, {
         roundLimitName: "HeadlessRoundLimit",
         currentSessionId: () => sessionId,
@@ -532,9 +546,23 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           }
 
           const codexObserver = codex ? createCodexExecTurnObserver() : undefined;
+          let pointerRecorded = false;
+          let codexIdObserved = false;
+          if (sessionId !== undefined && sessionId !== "") {
+            pointerRecorded = recordNativeSessionPointer({
+              host: config.hostName,
+              sessionId,
+              cwd: request.cwd,
+              sessionParent,
+              home: request.home,
+            }) !== undefined;
+          }
+
           let spawned: { code: number | null; stdout: string; stderr: string; timedOut: boolean };
+          let childExited = false;
           try {
             spawned = await spawnHeadlessTurn({
+              onClose() { childExited = true; },
               binary: config.binary,
               args,
               cwd: request.cwd,
@@ -554,16 +582,33 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                 }
                 // One bounded live seam owns both recording and host-specific reduction.
                 codexObserver?.observe(event);
-                reportHostSessionEvent({
-                  host: config.hostName,
-                  cwd: request.cwd,
-                  sessionParent,
-                  source: "headless-host",
-                  event,
-                });
+                if (!codex && typeof event === "object" && event !== null && "session_id" in event
+                  && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
+                  sessionId = event.session_id;
+                  recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
+                }
+                if (codex && !codexIdObserved) {
+                  const tid = codexObserver?.result().threadId;
+                  if (tid !== undefined && tid !== "") {
+                    codexIdObserved = true;
+                    pointerRecorded = recordNativeSessionPointer({
+                      host: config.hostName,
+                      sessionId: tid,
+                      cwd: request.cwd,
+                      sessionParent,
+                      home: request.home,
+                    }) !== undefined;
+                  }
+                }
               },
             });
+            const roundSessionId = (codex ? codexObserver?.result().threadId : undefined) ?? sessionId;
+            exitedSessionId = roundSessionId;
+            if (codex && roundSessionId !== undefined && roundSessionId !== "" && !pointerRecorded) {
+              recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
+            }
           } catch (error) {
+            if (childExited) exitedSessionId = (codex ? codexObserver?.result().threadId : undefined) ?? sessionId;
             if (isHostAbortedError(error)) throw error;
             const message = error instanceof Error ? error.message : String(error);
             const observedHostFailure = codexObserver?.result().failureDiagnostic;
@@ -577,24 +622,6 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                 }, observedHostFailure),
               };
             }
-            // SitianInfrastructureError.knownCause is session; spawn errno stays activation.
-            const isRecordFailure =
-              typeof error === "object"
-              && error !== null
-              && ((error as { knownCause?: unknown }).knownCause === "session"
-                || (error as { name?: unknown }).name === "SitianInfrastructureError");
-            if (isRecordFailure) {
-              return {
-                status: "terminal",
-                result: failure(
-                  "session",
-                  "HostSessionRecordFailure",
-                  "host-session-record-failed",
-                  { diagnostic: message, sessionId },
-                  message,
-                ),
-              };
-            }
             return {
               status: "terminal",
               result: failure("activation", "HeadlessSpawnFailure", "spawn-failed", {
@@ -773,6 +800,15 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           return { status: "delivered", stderr: spawned.stderr };
         },
       });
+      } finally {
+        if (exitedSessionId !== undefined && exitedSessionId !== "") copyAndRecordHostDossier({
+          host: config.hostName, sessionId: exitedSessionId, cwd: request.cwd,
+          sessionDirectory: join(request.runDirectory, "session"), sessionParent,
+          continuation: request.continuation,
+          ...(request.model !== undefined ? { model: request.model } : {}),
+          ...(request.home !== undefined ? { home: request.home } : {}),
+        });
+      }
     } finally {
       try {
         await prepared.dispose?.();

package/src/host-contracts.ts

@@ -158,19 +158,6 @@ export type RoleTurnModelConfig = {
   readonly thinking?: string;
 };
 
-/**
- * Typed cross-host resume handoff (#617 DK-4).
- * Present only when post-admission projects a real host switch.
- * priorNativeKind names the record family the paths belong to — Pi's own
- * session file, or sitian run records (ADR 0077) — so a consuming adapter
- * reads the handoff without knowing which host wrote it.
- * Target host reads those files itself; projector never copies bytes.
- */
-export type RoleTurnHostTransition = {
-  readonly priorNativeKind: "pi-native" | "sitian";
-  readonly priorNativePaths: readonly string[];
-};
-
 /** One main-session turn request over the host-neutral execution seam. */
 export type RoleTurnRequest = {
   readonly principal: DurablePrincipal;
@@ -193,8 +180,6 @@ export type RoleTurnRequest = {
    * has no parent to observe and leaves it absent.
    */
   readonly signal?: AbortSignal;
-  /** Set by post-admission only on a real host switch; never on same-host resume. */
-  readonly hostTransition?: RoleTurnHostTransition;
   /**
    * Court-turn attempt (#637 / #833): sole-final per attempt. Open court, summons,
    * and resume-with-message set this; bare resume without an open court omits it.