@akagilnc/pi-workflow-roles 0.1.5762 → 0.1.5797

package/dist/ticket-progress.js

@@ -0,0 +1,306 @@
+/**
+ * #1199 ticket-level progress: current.jsonl + leg-local receipts/session.
+ * Write at seal (createSubmissionLedgerHost → projectClosure), never by
+ * post-turn history guessing. Per-leg dossiers stay until #1202.
+ *
+ * Originals stay in the leg directory (owner 14b58f6c / a8d2e72d):
+ * `runs/<leg>/receipts/<n>.json`, `runs/<leg>/session/<原件>`.
+ * Unbound legs stage rows in `progress.jsonl` (round empty); bind renames the
+ * whole leg, then this module fills rounds and appends ticket current.jsonl.
+ * Round authority is progress lines only — no receipt-filename counting,
+ * occupancy placeholders, or claim-retry loops. Reviewer dual-lens series
+ * count independently (`<n>.<lens>`).
+ */
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { resolveHostDossierLandingPath } from "./host-session-record.js";
+import { runDirectoryFromHostContext } from "./host-contracts.js";
+import { acceptedFacts, isTerminatingToolName, } from "./package-contracts/terminating-tools.js";
+import { packagedRoleOutputTool } from "./packaged-role-registry.js";
+import { isUnboundRunDirectory, sessionDirectoryOf, sessionFileOf, subjectDirectoryOfRun, } from "./role-run-placement.js";
+import { readPageSync } from "./run-dossier.js";
+import { parseSitianRecordText } from "./sitian-reader.js";
+import { isRecord } from "./unknown-value.js";
+const CURRENT_FILENAME = "current.jsonl";
+const RECEIPTS_DIRNAME = "receipts";
+const LEG_PROGRESS_FILENAME = "progress.jsonl";
+/**
+ * Append-only progress JSONL — same posture as run-dossier row files:
+ * sole Sitian decoder keeps reachable rows; malformed lines leave diagnostics
+ * on stderr and do not abort seal/relocate.
+ */
+function parseProgressText(text, pathForDiagnostic) {
+    if (text.trim() === "")
+        return [];
+    const { records, diagnostics } = parseSitianRecordText(text);
+    for (const diagnostic of diagnostics) {
+        process.stderr.write(`[ticket-progress] ${pathForDiagnostic} has malformed row(s); keeps reachable rows and retains the diagnostic: line ${diagnostic.line}: ${diagnostic.error}\n`);
+    }
+    const lines = [];
+    for (const record of records) {
+        const parsed = record;
+        if (!isRecord(parsed))
+            continue;
+        if (typeof parsed.seat !== "string" || typeof parsed.round !== "string")
+            continue;
+        lines.push(parsed);
+    }
+    return lines;
+}
+function readProgressFile(path) {
+    if (!existsSync(path))
+        return [];
+    return parseProgressText(readFileSync(path, "utf8"), path);
+}
+/**
+ * Read progress rows under a subject.
+ * Ticket: append-only `current.jsonl`.
+ * Unbound: each leg's `runs/<leaf>/progress.jsonl` (no shared file).
+ */
+export function readTicketProgressLines(subjectDirectory) {
+    if (basename(subjectDirectory) === "unbound") {
+        const runsDir = join(subjectDirectory, "runs");
+        if (!existsSync(runsDir))
+            return [];
+        const out = [];
+        for (const name of readdirSync(runsDir).sort()) {
+            out.push(...readProgressFile(join(runsDir, name, LEG_PROGRESS_FILENAME)));
+        }
+        return out;
+    }
+    return readProgressFile(join(subjectDirectory, CURRENT_FILENAME));
+}
+function roundBaseNumber(round) {
+    if (round.trim() === "")
+        return 0;
+    const base = round.includes(".") ? round.slice(0, round.indexOf(".")) : round;
+    const n = Number(base);
+    return Number.isSafeInteger(n) && n > 0 ? n : 0;
+}
+function roundLens(round) {
+    return round.includes(".") ? round.slice(round.indexOf(".") + 1) : undefined;
+}
+function nextRoundFromLines(lines, seat, lens) {
+    const want = lens === undefined || lens.trim() === "" ? undefined : lens;
+    let max = 0;
+    for (const line of lines) {
+        if (line.seat !== seat)
+            continue;
+        if (roundLens(line.round) !== want)
+            continue;
+        max = Math.max(max, roundBaseNumber(line.round));
+    }
+    const base = max + 1;
+    return want === undefined ? String(base) : `${base}.${want}`;
+}
+/** Leg-local receipt ordinal: `receipts/<n>.json` (not seat#round). */
+function nextLegReceiptIndex(runDirectory) {
+    const dir = join(runDirectory, RECEIPTS_DIRNAME);
+    if (!existsSync(dir))
+        return 1;
+    let max = 0;
+    for (const name of readdirSync(dir)) {
+        const match = /^(\d+)\.json$/.exec(name);
+        if (match === null)
+            continue;
+        const n = Number(match[1]);
+        if (Number.isSafeInteger(n) && n > max)
+            max = n;
+    }
+    return max + 1;
+}
+/**
+ * Copy structured status/summary from the seat receipt.
+ * Status leaves reuse acceptedFacts (terminating-tools authority) via the seat's
+ * current output tool — legacy judgeStatus/countersignStatus keys are unreachable
+ * at this seal seam (tool is the live registry name, not ak_judge_output).
+ * summary is seat-authored prose on the receipt and is not part of AcceptedFacts.
+ * Missing fields stay absent — never invent "" or "accepted".
+ *
+ * Not receiptStatusFromRegistry: that scans every registry key for navigator
+ * projection when the seat is unknown; here the seal already knows the seat.
+ */
+function statusAndSummaryFromPayload(seat, payload) {
+    if (!isRecord(payload))
+        return {};
+    const toolName = packagedRoleOutputTool(seat);
+    const status = toolName !== undefined && isTerminatingToolName(toolName)
+        ? acceptedFacts(toolName, payload).status
+        : undefined;
+    const summary = typeof payload.summary === "string" ? payload.summary : undefined;
+    return {
+        ...(status === undefined ? {} : { status }),
+        ...(summary === undefined ? {} : { summary }),
+    };
+}
+/** Worktree HEAD at seal. On failure head is empty and fault carries the true cause. */
+export function captureWorktreeHead(projectRoot) {
+    try {
+        const result = spawnSync("git", ["rev-parse", "HEAD"], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+        });
+        if (result.error != null) {
+            const err = result.error;
+            const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+            return { head: "", fault: `git rev-parse HEAD spawn failed cwd=${projectRoot}: ${detail}` };
+        }
+        if (result.status !== 0) {
+            const detail = [result.stderr, result.stdout]
+                .map((part) => (typeof part === "string" ? part.trim() : ""))
+                .filter((part) => part !== "")
+                .join(" | ");
+            const status = result.status === null ? "null" : String(result.status);
+            const signal = result.signal == null ? "" : ` signal=${result.signal}`;
+            return {
+                head: "",
+                fault: detail === ""
+                    ? `git rev-parse HEAD failed (status=${status}${signal}) cwd=${projectRoot}`
+                    : `git rev-parse HEAD failed (status=${status}${signal}) cwd=${projectRoot}: ${detail}`,
+            };
+        }
+        return { head: (result.stdout ?? "").trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        return { head: "", fault: `git rev-parse HEAD threw cwd=${projectRoot}: ${message}` };
+    }
+}
+function progressSessionAbsolute(runDirectory, context) {
+    const host = typeof context.host === "string" ? context.host.trim() : "";
+    const sessionDirectory = sessionDirectoryOf(runDirectory);
+    // External hosts: ADR 0086 copy landing (codex.jsonl / grok-build / …), not the
+    // principal wire file. Responsibility unchanged (#1199 R3 disposition).
+    if (host !== "" && host !== "pi" && host !== "hermes") {
+        return resolveHostDossierLandingPath({ host, sessionDirectory });
+    }
+    // Pi/hermes: prefer the issued durable coordinate on the live handle.
+    const issued = context.sessionManager.getSessionFile?.();
+    if (typeof issued === "string" && issued.trim() !== "") {
+        return issued;
+    }
+    return sessionFileOf(runDirectory);
+}
+function lensFromRunDirectory(runDirectory, role) {
+    if (role !== "reviewer")
+        return undefined;
+    const lens = readPageSync(runDirectory, "admitted")?.lens;
+    return lens === "completeness" || lens === "correctness" ? lens : undefined;
+}
+/**
+ * Seal-time landing from createSubmissionLedgerHost (before projectClosure).
+ * Missing run directory → no-op (ledger still sealed).
+ */
+export function landTicketProgressForSealedSubmission(input) {
+    const runDirectory = runDirectoryFromHostContext(input.context);
+    if (runDirectory === undefined)
+        return undefined;
+    const subjectDirectory = subjectDirectoryOfRun(runDirectory);
+    if (subjectDirectory === undefined)
+        return undefined;
+    const lens = (input.lens === "completeness" || input.lens === "correctness"
+        ? input.lens
+        : lensFromRunDirectory(runDirectory, input.role));
+    const leaf = basename(runDirectory);
+    const unbound = basename(subjectDirectory) === "unbound";
+    const progressPath = unbound
+        ? join(runDirectory, LEG_PROGRESS_FILENAME)
+        : join(subjectDirectory, CURRENT_FILENAME);
+    // Original receipt first — independent of derived progress read/append.
+    // Progress I/O failure must not erase an already-accepted payload (#1199 F1).
+    const receiptIndex = nextLegReceiptIndex(runDirectory);
+    const relativePath = `runs/${leaf}/${RECEIPTS_DIRNAME}/${receiptIndex}.json`;
+    const absolutePath = join(subjectDirectory, relativePath);
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, `${JSON.stringify(input.accepted, null, 2)}\n`, "utf8");
+    // #1199 R1: bound leg with leftover progress.jsonl must publish before this
+    // seal takes the next ticket round — optional ticketNumber must not be required.
+    if (!unbound) {
+        relocateTicketProgressForLeg({ runDirectory });
+    }
+    const existing = unbound
+        ? readProgressFile(progressPath)
+        : readTicketProgressLines(subjectDirectory);
+    // Unbound: round stays empty until whole-leg bind publishes into ticket current.
+    const round = unbound ? "" : nextRoundFromLines(existing, input.role, lens);
+    const sessionFile = progressSessionAbsolute(runDirectory, input.context);
+    const sessionRelative = relative(subjectDirectory, sessionFile).split(sep).join("/");
+    const { status, summary } = statusAndSummaryFromPayload(input.role, input.accepted);
+    const instruction = typeof input.context.summonsInstruction === "string"
+        ? input.context.summonsInstruction
+        : "";
+    const line = {
+        at: new Date().toISOString(),
+        seat: input.role,
+        round,
+        instruction,
+        head: input.sealHead.head,
+        ...(status === undefined ? {} : { status }),
+        ...(summary === undefined ? {} : { summary }),
+        receipt: relativePath,
+        session: sessionRelative,
+    };
+    mkdirSync(dirname(progressPath), { recursive: true });
+    appendFileSync(progressPath, `${JSON.stringify(line)}\n`, "utf8");
+    // HEAD capture fault: keep the raw cause on stderr. Do not invent a second
+    // dossier custom-frame channel beside post-admission's existing retain path.
+    if (input.sealHead.fault !== undefined) {
+        process.stderr.write(`${input.sealHead.fault}\n`);
+    }
+    return line;
+}
+/**
+ * After whole-leg rename (or retry when already under the ticket): fill rounds
+ * on staged `progress.jsonl`, append ticket `current.jsonl`, then drop staging.
+ * Receipt / session / head / instruction keep seal-time values and relative
+ * paths — no copy, delete-source, or rewrite of relative pointers.
+ *
+ * Unbound staging leaves `round` empty; publish takes the leg's sealed lens from
+ * the admitted page (`lensFromRunDirectory`), never from receipt prose.
+ */
+export function relocateTicketProgressForLeg(input) {
+    if (isUnboundRunDirectory(input.runDirectory))
+        return;
+    const subjectDirectory = subjectDirectoryOfRun(input.runDirectory);
+    if (subjectDirectory === undefined)
+        return;
+    const stagedPath = join(input.runDirectory, LEG_PROGRESS_FILENAME);
+    const mine = readProgressFile(stagedPath);
+    if (mine.length === 0) {
+        if (existsSync(stagedPath)) {
+            rmSync(stagedPath, { force: true });
+        }
+        return;
+    }
+    const ticketLines = [...readTicketProgressLines(subjectDirectory)];
+    // Receipt path is the seal identity. Append-then-unlink partial success must
+    // not reassign rounds or re-append the same originals on re-entry (#1199 F2).
+    const publishedReceipts = new Set(ticketLines
+        .map((line) => line.receipt)
+        .filter((receipt) => typeof receipt === "string" && receipt !== ""));
+    const pending = mine.filter((line) => !publishedReceipts.has(line.receipt));
+    if (pending.length === 0) {
+        rmSync(stagedPath, { force: true });
+        return;
+    }
+    const movedLines = [];
+    for (const line of pending) {
+        // Current unbound staging publishes empty rounds; lens comes only from this
+        // leg's admitted page. No legacy staged-round mirror-suffix branch.
+        const lens = lensFromRunDirectory(input.runDirectory, line.seat);
+        const round = nextRoundFromLines(ticketLines, line.seat, lens);
+        const moved = {
+            ...line,
+            round,
+        };
+        movedLines.push(moved);
+        ticketLines.push(moved);
+    }
+    const newCurrent = join(subjectDirectory, CURRENT_FILENAME);
+    mkdirSync(dirname(newCurrent), { recursive: true });
+    appendFileSync(newCurrent, `${movedLines.map((line) => JSON.stringify(line)).join("\n")}\n`, "utf8");
+    // Append succeeded — drop staging. Failure above leaves progress.jsonl in place.
+    rmSync(stagedPath, { force: true });
+}

package/dist/user-dialogue-stdin.js

@@ -2,33 +2,39 @@
  * Typed user-dialogue stdin transport (#879 / #471).
  * Pi's piped-stdin reader trims the wrapper; the body field keeps original bytes.
  * No size cap and no path/pointer substitute — the whole dialogue rides the envelope.
+ *
+ * #1199: progress-line instruction is these same body bytes (what the seat
+ * actually receives). No parallel 传召词 field on the envelope.
  */
 import { isRecord } from "./unknown-value.js";
 export const USER_DIALOGUE_STDIN_KIND = "ak-user-dialogue";
 export function encodeUserDialogueStdin(body) {
-    return JSON.stringify({ kind: USER_DIALOGUE_STDIN_KIND, body });
+    const envelope = { kind: USER_DIALOGUE_STDIN_KIND, body };
+    return JSON.stringify(envelope);
 }
-function isUserDialogueEnvelope(value) {
-    if (!isRecord(value))
-        return false;
-    const record = value;
-    return record.kind === USER_DIALOGUE_STDIN_KIND && typeof record.body === "string";
-}
-/**
- * Host read: recover original dialogue after a trim-capable pipe.
- * Non-envelope text (interactive Pi, officer JSON, headless raw body) is unchanged.
- */
-export function readUserDialogueStdin(raw) {
+/** One parse for the model-facing body — callers must not re-implement. */
+export function tryParseUserDialogueStdin(raw) {
     const trimmed = raw.trim();
     if (!trimmed.startsWith("{"))
-        return raw;
+        return undefined;
     try {
         const parsed = JSON.parse(trimmed);
-        if (isUserDialogueEnvelope(parsed))
-            return parsed.body;
+        if (!isRecord(parsed))
+            return undefined;
+        const record = parsed;
+        if (record.kind !== USER_DIALOGUE_STDIN_KIND || typeof record.body !== "string") {
+            return undefined;
+        }
+        return { kind: USER_DIALOGUE_STDIN_KIND, body: record.body };
     }
     catch {
-        // Not our envelope — leave caller bytes intact.
+        return undefined;
     }
-    return raw;
+}
+/**
+ * Host read: recover original dialogue after a trim-capable pipe.
+ * Non-envelope text (interactive Pi, officer JSON, headless raw body) is unchanged.
+ */
+export function readUserDialogueStdin(raw) {
+    return tryParseUserDialogueStdin(raw)?.body ?? raw;
 }

package/package.json

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

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

@@ -129,7 +129,10 @@ export async function recordTurnDelivery(
   }
 }
 
-export type ExternalPreparedTurn = Pick<PreparedRoleTurn, "prompt" | "abortSignal" | "closeRound">;
+export type ExternalPreparedTurn = Pick<
+  PreparedRoleTurn,
+  "prompt" | "abortSignal" | "closeRound" | "recordSentInstruction"
+>;
 
 export type ExternalHostRoundOutcome =
   | {
@@ -318,6 +321,9 @@ export async function driveExternalRoleTurnRounds(
       }
     }
     prompt = closure.retry.message;
+    // #1199: same-envelope 催交 / correctable retry — progress instruction is
+    // the bytes actually sent this round, not the first-mint summons.
+    prepared.recordSentInstruction?.(prompt);
     driver.afterRetry?.();
   }
 

package/src/host-contracts.ts

@@ -264,7 +264,7 @@ export interface DurablePrincipalAuthority {
 type HostSessionManager = { getLeafEntry(): HostSessionEntry | undefined; getLeafId(): string | null | undefined; getEntries(): Iterable<HostSessionEntry>; getSessionDir(): string; getSessionFile(): string | undefined; getHeader?(): { readonly type: string; readonly id?: string } | null; setSessionFile?(path: string): void; appendCustomEntry?(customType: string, data?: unknown): unknown; };
 
 /** Context supplied by a host for one activation and its interceptable events. */
-export type HostContext = { cwd: string; mode: string; model: { readonly provider: string } | undefined; sessionManager: HostSessionManager; /** Per-turn admitted run directory (#879); never process-global env. */ runDirectory?: string; /** Per-turn court attempt (#879); never process-global env. */ courtAttemptId?: string; /** Public-invocation scope (#537); never process-global env. */ invocationScopeId?: string; /** Selected host axis (#537 / ADR 0082); never process-global env invent. */ host?: string; signal?: AbortSignal | undefined; ui?: { notify?(message: string, type?: "info" | "warning" | "error"): void }; transcript?(): string; abort(): void; };
+export type HostContext = { cwd: string; mode: string; model: { readonly provider: string } | undefined; sessionManager: HostSessionManager; /** Per-turn admitted run directory (#879); never process-global env. */ runDirectory?: string; /** Per-turn court attempt (#879); never process-global env. */ courtAttemptId?: string; /** Public-invocation scope (#537); never process-global env. */ invocationScopeId?: string; /** Selected host axis (#537 / ADR 0082); never process-global env invent. */ host?: string; /** #1199 bytes actually sent to the seat this turn (progress instruction); input-seam / in-process only — never env/argv body. */ summonsInstruction?: string; signal?: AbortSignal | undefined; ui?: { notify?(message: string, type?: "info" | "warning" | "error"): void }; transcript?(): string; abort(): void; };
 
 /** Per-turn run directory; adapters must project any child-process identity. */
 export function runDirectoryFromHostContext(context: HostContext): string | undefined {

package/src/navigator-attendance.ts

@@ -444,9 +444,10 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
         };
         await promptAllowingRejectedPrepare(request);
         // Correction after rejected prepare on the sole model round (#1160).
+        // #1208: resend this turn's prepare request; delivery-state stays on policy facts.
         while (output === undefined && prepareBatchRejected && delivery.nextAction() === "request-delivery") {
           delivery.recordDeliveryRequest();
-          await promptAllowingRejectedPrepare(JSON.stringify(delivery.deliveryState()));
+          await promptAllowingRejectedPrepare(request);
         }
         if (output === undefined && delivery.nextAction() === "request-delivery") {
           delivery.closeBudget();

package/src/packaged-role-registry.ts

@@ -294,9 +294,8 @@ export const PUBLIC_ROLE_RECORDS = [
     bareCommand: false,
     outputTool: NOTARY_OUTPUT_TOOL_NAME,
     settlement: "accepted",
-    /** Court reask replaces the initial prompt. Otherwise the fixed kickoff. */
+    /** Dialogue via shared resolveReviewSeatDialogueBody (review = fixed dispatch). */
     reaskPrompt: true,
-    transportPrompt: "fixed-kickoff",
     gateStageLabel: "符宝郎",
     /** Gate summon binds --source-run and keeps dialogue off the argv. */
     gateSummon: "source-run",
@@ -319,6 +318,8 @@ export const PUBLIC_ROLE_RECORDS = [
     phases: [null],
     outputTool: COUNTERSIGN_OUTPUT_TOOL_NAME,
     settlement: "accepted",
+    /** Same shared dialogue resolver as other review seats (#1208 C1). */
+    reaskPrompt: true,
     gateStageLabel: "给事中",
     /** Gate summon carries the parent payload as the instruction and a parent run id. */
     gateSummon: "parent-instruction",

package/src/pi/adapter.ts

@@ -45,44 +45,6 @@ export function createPiRoleRuntimeExtension(
   return (pi) => createRoleRuntimeExtension(dependencies)(createPiRoleHostAdapter(pi, options));
 }
 
-/** Project Pi's activation context onto the package-owned host contract. */
-function projectPiContext(context: ExtensionContext, transcriptFromContext?: (context: ExtensionContext) => string): HostContext {
-  const sessionManager = context.sessionManager as SessionManager;
-  const host: HostContext = {
-    cwd: context.cwd,
-    mode: context.mode,
-    model: context.model === undefined ? undefined : { provider: context.model.provider },
-    ...(typeof process.env.AK_ROLE_RUN_DIR === "string" && process.env.AK_ROLE_RUN_DIR.trim() !== ""
-      ? { runDirectory: process.env.AK_ROLE_RUN_DIR }
-      : {}),
-    ...(typeof process.env.AK_ROLE_COURT_ATTEMPT === "string" && process.env.AK_ROLE_COURT_ATTEMPT.trim() !== ""
-      ? { courtAttemptId: process.env.AK_ROLE_COURT_ATTEMPT }
-      : {}),
-    ...(typeof process.env.AK_ROLE_INVOCATION_SCOPE === "string" && process.env.AK_ROLE_INVOCATION_SCOPE.trim() !== ""
-      ? { invocationScopeId: process.env.AK_ROLE_INVOCATION_SCOPE }
-      : {}),
-    ...(typeof process.env.AK_ROLE_HOST === "string" && process.env.AK_ROLE_HOST.trim() !== ""
-      ? { host: process.env.AK_ROLE_HOST.trim() }
-      : {}),
-    sessionManager: {
-      getLeafEntry: () => context.sessionManager.getLeafEntry(),
-      getLeafId: () => context.sessionManager.getLeafId(),
-      getEntries: () => context.sessionManager.getEntries(),
-      getSessionDir: () => context.sessionManager.getSessionDir(),
-      getSessionFile: () => context.sessionManager.getSessionFile(),
-      getHeader: () => context.sessionManager.getHeader(),
-      setSessionFile: (path) => sessionManager.setSessionFile(path),
-      appendCustomEntry: (customType, data) => sessionManager.appendCustomEntry(customType, data),
-    },
-    ...(context.signal === undefined ? {} : { signal: context.signal }),
-    ...(context.ui === undefined ? {} : { ui: { notify: (message, type) => context.ui.notify(message, type) } }),
-    ...(transcriptFromContext === undefined ? {} : { transcript: () => transcriptFromContext(context) }),
-    abort: () => context.abort(),
-  };
-  piContexts.set(host, context);
-  return host;
-}
-
 /** Recover the Pi context only at the Pi composition boundary. */
 export function toPiContext(context: HostContext): ExtensionContext {
   const piContext = piContexts.get(context);
@@ -158,10 +120,63 @@ export function createPiRoleHostAdapter(
   let beforeAgentStartHandlers = 0;
   // Parameters of registered terminating tools — the schema Pi was handed.
   const registeredToolParameters = new Map<string, unknown>();
-  // Decode transport exactly once before Pi's native handler chain. Pi retains
-  // its own transform/image propagation and per-handler error isolation.
+  // Pi createContext() is fresh per emit/tool (runner.js). Do not cache HostContext by
+  // ExtensionContext identity. Share only this-turn 传召词 / 催交 on the adapter instance;
+  // model and identity pointers stay live on each fresh projection (#1199).
+  let turnSummonsInstruction: string | undefined;
+  const transcriptFromContext = options.transcriptFromContext;
+  const projectPiContext = (context: ExtensionContext): HostContext => {
+    const sessionManager = context.sessionManager as SessionManager;
+    const host: HostContext = {
+      cwd: context.cwd,
+      mode: context.mode,
+      model: context.model === undefined ? undefined : { provider: context.model.provider },
+      ...(typeof process.env.AK_ROLE_RUN_DIR === "string" && process.env.AK_ROLE_RUN_DIR.trim() !== ""
+        ? { runDirectory: process.env.AK_ROLE_RUN_DIR }
+        : {}),
+      ...(typeof process.env.AK_ROLE_COURT_ATTEMPT === "string" && process.env.AK_ROLE_COURT_ATTEMPT.trim() !== ""
+        ? { courtAttemptId: process.env.AK_ROLE_COURT_ATTEMPT }
+        : {}),
+      ...(typeof process.env.AK_ROLE_INVOCATION_SCOPE === "string" && process.env.AK_ROLE_INVOCATION_SCOPE.trim() !== ""
+        ? { invocationScopeId: process.env.AK_ROLE_INVOCATION_SCOPE }
+        : {}),
+      ...(typeof process.env.AK_ROLE_HOST === "string" && process.env.AK_ROLE_HOST.trim() !== ""
+        ? { host: process.env.AK_ROLE_HOST.trim() }
+        : {}),
+      sessionManager: {
+        getLeafEntry: () => context.sessionManager.getLeafEntry(),
+        getLeafId: () => context.sessionManager.getLeafId(),
+        getEntries: () => context.sessionManager.getEntries(),
+        getSessionDir: () => context.sessionManager.getSessionDir(),
+        getSessionFile: () => context.sessionManager.getSessionFile(),
+        getHeader: () => context.sessionManager.getHeader(),
+        setSessionFile: (path) => sessionManager.setSessionFile(path),
+        appendCustomEntry: (customType, data) => sessionManager.appendCustomEntry(customType, data),
+      },
+      ...(context.signal === undefined ? {} : { signal: context.signal }),
+      ...(context.ui === undefined ? {} : { ui: { notify: (message, type) => context.ui.notify(message, type) } }),
+      ...(transcriptFromContext === undefined ? {} : { transcript: () => transcriptFromContext(context) }),
+      abort: () => context.abort(),
+    };
+    // exactOptionalPropertyTypes: wire via accessors so undefined stays "absent value"
+    // while every fresh projection shares the adapter-instance turn field.
+    Object.defineProperty(host, "summonsInstruction", {
+      enumerable: true,
+      configurable: true,
+      get: () => turnSummonsInstruction,
+      set: (value: string | undefined) => {
+        turnSummonsInstruction = value;
+      },
+    });
+    piContexts.set(host, context);
+    return host;
+  };
+  // Decode transport exactly once before Pi's native handler chain. Progress
+  // instruction is the model-facing body (what the seat actually receives) —
+  // no parallel 传召词 channel. Every input refreshes the turn field.
   pi.on("input", (value) => {
     const text = readUserDialogueStdin(value.text);
+    turnSummonsInstruction = text;
     return text === value.text ? { action: "continue" } : { action: "transform", text };
   });
   const host: RoleHost = {
@@ -172,10 +187,7 @@ export function createPiRoleHostAdapter(
     getFlag: (name) => pi.getFlag(name),
     registerTool: (tool) => {
       registeredToolParameters.set(tool.name, tool.parameters);
-      return pi.registerTool(toPiToolDefinition(
-        tool,
-        (context) => projectPiContext(context, options.transcriptFromContext),
-      ));
+      return pi.registerTool(toPiToolDefinition(tool, projectPiContext));
     },
     getAllTools: () => pi.getAllTools().map(({ name, sourceInfo }) => ({
       name,
@@ -184,7 +196,7 @@ export function createPiRoleHostAdapter(
     setActiveTools: (names) => pi.setActiveTools(names),
     getActiveTools: () => pi.getActiveTools(),
     on(...registration: HostEventRegistration) {
-      const context = (value: ExtensionContext) => projectPiContext(value, options.transcriptFromContext);
+      const context = projectPiContext;
       if (registration[0] === "before_agent_start") {
         const [, handler] = registration;
         const position = beforeAgentStartHandlers;

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

@@ -438,7 +438,9 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
         config.extraPiArgs ?? [],
       );
       const args = buildExplicitInternalActivationArgs(roleEntry, extraArgs);
-      const stdin = encodeUserDialogueStdin(piUserDialogueBody(turnRequest));
+      const transportBody = piUserDialogueBody(turnRequest);
+      // #1199: progress instruction is these same body bytes (actual seat input).
+      const stdin = encodeUserDialogueStdin(transportBody);
       // 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 = {
@@ -458,6 +460,9 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
       // Selected host axis (#537 / ADR 0082): omit must not inherit a parent env value.
       if (request.host === undefined || request.host.trim() === "") delete env.AK_ROLE_HOST;
       else env.AK_ROLE_HOST = request.host.trim();
+      // #1199: 传召词 is unknown-length body — never argv/env (execve ARG_MAX / E2BIG).
+      // Typed stdin envelope carries dialogue + optional progress 传召词.
+      delete env.AK_ROLE_SUMMONS_INSTRUCTION;
       // #1132: the one effective delivery-request ceiling travels to the child
       // on its own env so the in-child role runtime and the worker submission
       // gate count with the same configured number the AK seam resolved. Omit

package/src/prepared-role-turn.ts

@@ -15,6 +15,12 @@ export type PreparedRoleTurn = Readonly<{
   systemPrompt: { readonly body: string; readonly materials: readonly unknown[] };
   /** Effective user prompt after host-side input transform (canonical Skill invocation). */
   prompt: string;
+  /**
+   * #1199: book the bytes actually sent this round as progress instruction
+   * (same-envelope 催交 / correctable retry). Production prepareRoleEnvelope
+   * always provides this; test stubs may omit.
+   */
+  recordSentInstruction?(text: string): void;
   /**
    * Host abort signal armed only by typed infrastructure failure (envelope
    * rememberInfrastructureFailure / non-correctable MCP catch). Lawful