@akagilnc/pi-workflow-roles 0.1.5614 → 0.1.5650

package/dist/public-cli/post-admission.js

@@ -6,17 +6,19 @@
  * Role runners supply only turn request projection and narrow settlement adapters.
  */
 import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import { buildAutoResumeContinuationPrompt, findRunDirectoryById, readRoleRunState, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
 import { projectPublicTurnAxes } from "./turn-request.js";
 import { appendCallerFileFlagPaths, bindAdmittedTicketNumber, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { readRecordedSubmissionRows } from "../submission-ledger.js";
-import { parseTicketNumber, readDeclaredTicketNumber } from "../run-ticket-number.js";
+import { parseTicketNumber, readBoardTicketNumber, readDeclaredTicketNumber } from "../run-ticket-number.js";
+import { homeFromRunDirectory } from "../activation-ledger-topology.js";
 import { readStoredHostSessionId } from "../session-identity.js";
 import { reportRunRecord } from "../sitian-facade.js";
 import { createReceiptDeliveryPolicy, deliveryLimitFromConfig, } from "../receipt-delivery-policy.js";
-import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
+import { rewritePrincipalSessionPaths, rewriteRunDirectoryPathValue, rewriteAdmittedRoleRunPage } from "../role-run-relocation.js";
 import { isOfficerReviewSeat } from "../packaged-role-registry.js";
 /** Original error bytes, never relabeled — a secondary fact riding beside a classified cause. */
 function describeCaughtError(error) {
@@ -62,6 +64,89 @@ function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
         }
     }
 }
+/**
+ * #1171: after the host returns, re-locate the leg by run id (report-ticket may
+ * have moved it mid-turn in the tool process). Settlement and render use the
+ * live path; lease cleanup follows when the held path changed.
+ * Failure is not best-effort: a missing former path with no replacement must not
+ * settle or write back under the vanished unbound leaf (失败诚实宪法).
+ */
+export async function refreshAdmittedPlacementAfterHostTurn(admitted, authority, heldLease) {
+    const home = homeFromRunDirectory(admitted.runDirectory);
+    const found = await findRunDirectoryById(home, admitted.runId, admitted.bookKey, admitted.role);
+    if (found === undefined && !existsSync(admitted.runDirectory)) {
+        throw new Error(`admitted run ${admitted.runId} missing after host turn; not found under ${home}`);
+    }
+    // Live identity first: later board-ticket read must not leave settlement on the
+    // pre-relocate path when facts are damaged (#1171 F4-R1).
+    let relocation;
+    if (found !== undefined && found !== admitted.runDirectory) {
+        const oldRunDirectory = admitted.runDirectory;
+        const coords = { ...authority.decode(admitted.principal) };
+        rewritePrincipalSessionPaths(coords, oldRunDirectory, found);
+        const principal = authority.seal(coords);
+        rewriteAdmittedRoleRunPage(admitted, [{ oldRunDirectory, newRunDirectory: found }]);
+        admitted.principal = principal;
+        heldLease?.relocate(found);
+        relocation = { oldRunDirectory, newRunDirectory: found };
+    }
+    // Board re-read discovers a ticket written mid-turn while still unbound
+    // (report-ticket board page). Already-bound identity needs no discovery —
+    // path relocate already used findRunDirectoryById. This is not damage
+    // recovery: when unbound, readBoardTicketNumber damage/non-ENOENT IO still
+    // propagates (失败诚实; notary: no damaged-control-plane → no-ticket wash).
+    if (admitted.ticketNumber === undefined) {
+        const boardTicket = await readBoardTicketNumber(found ?? admitted.runDirectory);
+        if (boardTicket !== undefined) {
+            admitted.ticketNumber = boardTicket;
+        }
+    }
+    return relocation;
+}
+/** Apply a successful post-host placement refresh onto the live turn request. */
+function applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed) {
+    projectRelocatedTurnIdentity(request, {}, admitted, refreshed);
+    return {
+        ...turnRequest,
+        runDirectory: admitted.runDirectory,
+        principal: admitted.principal,
+    };
+}
+/**
+ * #1171: host throw after a started turn — one live placement refresh, then the
+ * one settlement authority (ADR 0080). Shared by first turn and 催交; never
+ * settle under a vanished unbound leaf.
+ */
+async function settleHostThrowAfterLivePlacementRefresh(input) {
+    let refreshError;
+    let turnRequest = input.turnRequest;
+    try {
+        const refreshed = await refreshAdmittedPlacementAfterHostTurn(input.admitted, input.env.principalAuthority, input.lease);
+        if (refreshed !== undefined) {
+            turnRequest = applyRefreshedPlacementToTurn(input.request, turnRequest, input.admitted, refreshed);
+        }
+    }
+    catch (err) {
+        refreshError = err;
+    }
+    const processCancelName = processCancelSignalName(input.env.signal);
+    // Secondary hostThrow only when the host actually threw and refresh also failed.
+    // Package-side refresh failure must not borrow that label (#1171 F10).
+    const hostThrowSecondary = refreshError !== undefined && input.hostTurnCompleted === false
+        ? { knownDetails: { hostThrow: describeCaughtError(input.hostError) } }
+        : {};
+    const settled = await settleAfterTurnStarted(input.admitted, withEngineDetourInvocationScope({
+        timedOut: false,
+        code: null,
+        stderr: "",
+        // Prefer the refresh failure when the live path is gone; otherwise the
+        // host throw remains the cause (失败诚实：不在旧 unbound 上结算写回).
+        ...(processCancelName === undefined ? {} : { cancelName: processCancelName }),
+        thrown: refreshError ?? input.hostError,
+        ...hostThrowSecondary,
+    }, input.request.invocationScopeId), input.adapters, input.env.principalAuthority, input.io, input.persistRunState, input.notePackageFault, input.courtAttemptId);
+    return { settled, turnRequest };
+}
 /** #855: process-cancel settlement never re-enters auto-resume. */
 function withProcessCancelSkipAutoResume(result, signal) {
     if (processCancelSignalName(signal) === undefined) {
@@ -573,6 +658,8 @@ export async function dispatchPostAdmissionTurn(input) {
         if (afterDispatchApplied)
             return result;
         afterDispatchApplied = true;
+        // #1171: placement refresh runs once after each host return (below), before
+        // settlement — not again here. finishAfterTurn only binds/relocates sealed tickets.
         // #855: re-read cancel before committing the terminal and afterDispatch.
         // A signal after the history-first commit cannot retroactively erase it.
         // skipRunStateWrite: run-state
@@ -603,12 +690,31 @@ export async function dispatchPostAdmissionTurn(input) {
             pendingTerminal !== undefined &&
             result.terminal === pendingTerminal) {
             try {
+                // #1171 F2-R2 / F2-R3 (#419) / F2-R5: only the soft-reask turn itself
+                // preserves the sealed terminal face. ticketReasksSpent is budget across
+                // rounds — after audit continue, ordinary no-volume turns publish
+                // no_receipt honestly. previewOnly skips the terminal pointer;
+                // recordAttemptHistory still appends.
+                const softTicketReaskNoSeal = pendingSettlement !== "sealed" && env.softTicketReaskTurn === true;
+                const noSealScope = softTicketReaskNoSeal
+                    ? {
+                        ...courtScope,
+                        previewOnly: true,
+                        recordAttemptHistory: true,
+                    }
+                    : { ...courtScope, recordAttemptHistory: true };
                 const terminal = pendingSettlement === "sealed"
                     ? await adapters.trySettle(admitted, env.principalAuthority, { ...courtScope, recordAttemptHistory: true })
-                    : await attachRecordedSubmissions(admitted, await settleHostEndedNoReceipt(admitted, env.principalAuthority, { ...courtScope, recordAttemptHistory: true }, receiptDelivery.issuedDeliveryRequests()), courtScope);
+                    : await attachRecordedSubmissions(admitted, await settleHostEndedNoReceipt(admitted, env.principalAuthority, noSealScope, receiptDelivery.issuedDeliveryRequests()), noSealScope);
                 if (terminal === undefined)
                     throw new Error("settled host attempt vanished before publication");
                 result = { ...result, terminal, exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome) };
+                // #1171 F2-R7: ownership evidence at this soft-reask turn's seal —
+                // mutate the live ownership cell carried on env (survives spreads).
+                if (pendingSettlement === "sealed" && env.softTicketReaskTurn === true
+                    && env.softTicketReaskOwnership !== undefined) {
+                    env.softTicketReaskOwnership.sealedSubstitute = true;
+                }
                 if (pendingSettlement === "sealed" && terminal.roleOutcome.kind === "accepted"
                     && request.courtAttemptId !== undefined && request.courtAttemptId.length > 0) {
                     try {
@@ -719,6 +825,7 @@ export async function dispatchPostAdmissionTurn(input) {
         // (runPostAdmissionResumable / ManualResume / station-child), not here:
         // auto-resume re-enters this dispatch and must reuse the same scope.
         let result;
+        let hostTurnCompleted = false;
         try {
             // A bare `ak-role resume` only forwards the caller's instruction to the
             // host CLI's native resume. Nothing here may gate, redirect or reshape
@@ -726,19 +833,36 @@ export async function dispatchPostAdmissionTurn(input) {
             // the authoritative post-turn settlement reads whatever really happened.
             turnDispatched = true;
             result = await env.roleTurnHost.executeTurn(turnRequest);
+            hostTurnCompleted = true;
+            // #1171: one placement refresh before settlement, same try as executeTurn.
+            // Failure shares the catch below (refresh-then-settle + #855 cancel wrap).
+            const refreshed = await refreshAdmittedPlacementAfterHostTurn(admitted, env.principalAuthority, lease);
+            if (refreshed !== undefined) {
+                turnRequest = applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed);
+            }
         }
         catch (error) {
-            const processCancelName = processCancelSignalName(env.signal);
-            const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
-                timedOut: false,
-                code: null,
-                stderr: "",
-                // The thrown value is the host's report. A cancel received on this
-                // call is a second fact; it must not become a new Error in its place.
-                ...(processCancelName === undefined ? {} : { cancelName: processCancelName }),
-                thrown: error,
-            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId);
-            return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...settled, turnDispatched: true, ...deferredPersist }, env.signal));
+            // #1171: one placement refresh before settlement — failure is a real cause,
+            // never catch-and-continue onto a vanished unbound leaf.
+            // Host throw and post-success refresh throw share this catch (#1171 F9).
+            const thrown = await settleHostThrowAfterLivePlacementRefresh({
+                admitted,
+                hostError: error,
+                hostTurnCompleted,
+                request,
+                turnRequest,
+                lease,
+                adapters,
+                env,
+                io,
+                persistRunState,
+                notePackageFault: courtScope.notePackageFault,
+                ...(courtScope.courtAttemptId === undefined
+                    ? {}
+                    : { courtAttemptId: courtScope.courtAttemptId }),
+            });
+            turnRequest = thrown.turnRequest;
+            return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...thrown.settled, turnDispatched: true, ...deferredPersist }, env.signal));
         }
         // #1132: settle this turn through the ONE post-turn settlement authority,
         // then — if it simply produced no receipt — 催交 before settling no_receipt.
@@ -771,6 +895,7 @@ export async function dispatchPostAdmissionTurn(input) {
             // that never reached the host.
             let deliveryResult;
             let deliveryTurnRequest;
+            let deliveryHostTurnCompleted = false;
             try {
                 // Host and the other axes already selected on this turn ride the
                 // shared projection. The pre-projection request does not have them.
@@ -788,15 +913,43 @@ export async function dispatchPostAdmissionTurn(input) {
                 };
                 receiptDelivery.recordDeliveryRequest();
                 deliveryResult = await env.roleTurnHost.executeTurn(deliveryTurnRequest);
+                deliveryHostTurnCompleted = true;
+                // Same single refresh-before-settle rule as the first turn (#1171):
+                // stay inside this try so cancel wrap is not dropped (#1171 F9 / #855).
+                const refreshed = await refreshAdmittedPlacementAfterHostTurn(admitted, env.principalAuthority, lease);
+                if (refreshed !== undefined) {
+                    turnRequest = applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed);
+                    deliveryTurnRequest = {
+                        ...deliveryTurnRequest,
+                        runDirectory: admitted.runDirectory,
+                        principal: admitted.principal,
+                    };
+                }
             }
             catch (error) {
                 // 催交 cannot substitute for host failure recovery: a real failure with
                 // its true cause, through the one settlement authority (ADR 0080).
-                // The turn started, so the caller's loop resumes instead of replaying
-                // the initial payload. The issued count survives that re-entry.
-                const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({ timedOut: false, code: null, stderr: "", thrown: error }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId);
+                // Same refresh-before-settle seam as the first turn (#1171 F4-R1).
+                // Host throw and post-success refresh throw share this catch (#1171 F9).
+                const thrown = await settleHostThrowAfterLivePlacementRefresh({
+                    admitted,
+                    hostError: error,
+                    hostTurnCompleted: deliveryHostTurnCompleted,
+                    request,
+                    turnRequest,
+                    lease,
+                    adapters,
+                    env,
+                    io,
+                    persistRunState,
+                    notePackageFault: courtScope.notePackageFault,
+                    ...(courtScope.courtAttemptId === undefined
+                        ? {}
+                        : { courtAttemptId: courtScope.courtAttemptId }),
+                });
+                turnRequest = thrown.turnRequest;
                 return await finishAfterTurn(withProcessCancelSkipAutoResume({
-                    ...settled,
+                    ...thrown.settled,
                     turnDispatched: true,
                     ...deferredPersist,
                 }, env.signal));

package/dist/public-cli/settlement.js

@@ -116,16 +116,23 @@ function roleOutcomeFromRows(role, rows) {
     // keep that earlier receipt (#1057).
     const payloads = mine.map((row) => row.accepted);
     const latest = terminal[terminal.length - 1];
+    const submissionToolCallId = typeof latest.toolCallId === "string" && latest.toolCallId.length > 0
+        ? latest.toolCallId
+        : undefined;
+    const belonging = submissionToolCallId === undefined ? {} : { submissionToolCallId };
     if (latest.kind === "audit-escalation") {
         return {
-            kind: "audit_escalation", role, status: "audit_escalation", payloads,
-            ...(Object.hasOwn(latest, "auditReceipt") ? { decisiveFacts: {
-                    auditEscalationReceipt: latest.auditReceipt,
-                    ...(Object.hasOwn(latest, "auditOfficer") ? { auditEscalationOfficer: latest.auditOfficer } : {}),
-                } } : {}),
+            outcome: {
+                kind: "audit_escalation", role, status: "audit_escalation", payloads,
+                ...(Object.hasOwn(latest, "auditReceipt") ? { decisiveFacts: {
+                        auditEscalationReceipt: latest.auditReceipt,
+                        ...(Object.hasOwn(latest, "auditOfficer") ? { auditEscalationOfficer: latest.auditOfficer } : {}),
+                    } } : {}),
+            },
+            ...belonging,
         };
     }
-    return { kind: "accepted", role, payloads };
+    return { outcome: { kind: "accepted", role, payloads }, ...belonging };
 }
 async function sealedLedgerOutcome(admitted, role, scope) {
     const home = sealedLedgerHome(admitted);
@@ -970,17 +977,17 @@ function entriesOf(read) {
 /** Sealed seats present the ledger. A session tool error does not invent a host failure. */
 async function settleSealedSeat(admitted, authority, scope, options) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
-    const roleOutcome = await sealedLedgerOutcome(admitted, admitted.role, scope);
-    if (roleOutcome === undefined || (options.acceptedOnly && roleOutcome.kind !== "accepted")) {
+    const settled = await sealedLedgerOutcome(admitted, admitted.role, scope);
+    if (settled === undefined || (options.acceptedOnly && settled.outcome.kind !== "accepted")) {
         return undefined;
     }
     const read = await readLawfulSettlementEntries(coordinates.sessionFile);
     if (read.kind === "fault") {
         await noteSettlementFault(admitted.runDirectory, scope, `session read failed beside lawful terminal: ${describeErrorIdentity(read.error)}`);
     }
-    return finishLawfulSeat(admitted, coordinates, entriesOf(read), roleOutcome, scope);
+    return finishLawfulSeat(admitted, coordinates, entriesOf(read), settled.outcome, scope, settled.submissionToolCallId);
 }
-async function finishLawfulSeat(admitted, coordinates, entries, roleOutcome, scope) {
+async function finishLawfulSeat(admitted, coordinates, entries, roleOutcome, scope, submissionToolCallId) {
     const artifacts = scope?.previewOnly === true
         ? []
         : await publishDeclaredSeatTerminal(admitted, roleOutcome, coordinates, entries, scope);
@@ -989,6 +996,9 @@ async function finishLawfulSeat(admitted, coordinates, entries, roleOutcome, sco
         navigator: extractNavigatorFact(entries),
         artifacts,
         runId: admitted.runId,
+        ...(submissionToolCallId === undefined || submissionToolCallId.length === 0
+            ? {}
+            : { submissionToolCallId }),
     }, coordinates.sessionDirectory, detourUsageContext(admitted, scope));
     return attachRecordedSubmissions(admitted, terminal, scope);
 }

package/dist/report-ticket-tool.js

@@ -0,0 +1,136 @@
+/**
+ * Mid-turn ticket report (#1171): roles call this as soon as they know the
+ * ticket number; the executing process binds and relocates immediately.
+ * When to call lives in this tool's description — not Soul.
+ */
+import { Type } from "typebox";
+import { existsSync } from "node:fs";
+import { runDirectoryFromHostContext } from "./host-contracts.js";
+import { piDurablePrincipalAuthority } from "./pi/durable-principal.js";
+import { bindAdmittedTicketNumber, relocateAdmittedRunToTicket, } from "./public-cli/invocation.js";
+import { isUnboundRunDirectory, sessionDirectoryOf, sessionFileOf } from "./role-run-placement.js";
+import { readPageSync } from "./run-dossier.js";
+import { readDeclaredTicketNumber } from "./run-ticket-number.js";
+import { isRecord } from "./unknown-value.js";
+export const REPORT_TICKET_TOOL_NAME = "ak_report_ticket";
+const reportTicketArgsSchema = Type.Object({
+    ticketNumber: Type.Unknown({
+        description: "本票号（正整数、数字串或前导 #N）。已知票号时开工即报；尚无票号时不要调用。",
+    }),
+}, { additionalProperties: true });
+export const REPORT_TICKET_TOOL_DESCRIPTION = "向包申报本票号。已知票号时开工第一件事调用；包当场把本腿归到票号目录。"
+    + "尚无票号（例如中书省建票前）不要调用，取得后再报。"
+    + "交卷时若仍未报过且交卷亦未带票号，包会经既有重交通道再问一次。";
+function pageString(page, key) {
+    const value = page?.[key];
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+/**
+ * Build the relocate seam's admitted face from durable pages + live principal.
+ * The executing process owns this snapshot for the bind/relocate call only.
+ */
+export function admittedForLiveTicketReport(runDirectory, authority) {
+    const admittedPage = readPageSync(runDirectory, "admitted") ?? {};
+    const invocationPage = readPageSync(runDirectory, "invocation") ?? {};
+    const role = pageString(admittedPage, "role") ?? pageString(invocationPage, "role");
+    const runId = pageString(admittedPage, "runId") ?? pageString(invocationPage, "runId");
+    const bookKey = pageString(admittedPage, "bookKey") ?? pageString(invocationPage, "bookKey");
+    const projectRoot = pageString(admittedPage, "projectRoot")
+        ?? pageString(invocationPage, "projectRoot");
+    if (role === undefined || runId === undefined || bookKey === undefined || projectRoot === undefined) {
+        throw new Error("ak_report_ticket requires durable role/runId/bookKey/projectRoot on the run");
+    }
+    const attachments = Array.isArray(admittedPage.attachments)
+        ? admittedPage.attachments
+        : [];
+    const sessionDirectory = sessionDirectoryOf(runDirectory);
+    const sessionFile = sessionFileOf(runDirectory);
+    const principal = authority.seal({ sessionDirectory, sessionFile });
+    const ticketNumber = readDeclaredTicketNumber(admittedPage.ticketNumber)
+        ?? readDeclaredTicketNumber(invocationPage.ticketNumber);
+    return {
+        role,
+        runId,
+        bookKey,
+        projectRoot,
+        instruction: typeof admittedPage.instruction === "string" ? admittedPage.instruction : "",
+        instructionEmpty: admittedPage.instructionEmpty === true
+            || (typeof admittedPage.instruction === "string" && admittedPage.instruction.trim() === ""),
+        attachments,
+        runDirectory,
+        principal,
+        ...(ticketNumber === undefined ? {} : { ticketNumber }),
+    };
+}
+/**
+ * Bind + relocate under the existing post-admission seams, then update the
+ * executing process's live path handles (HostContext + optional env + setSessionFile).
+ * Pi: native SessionManager.setSessionFile so later appends stay on the moved file.
+ */
+export async function reportTicketFromHostContext(context, rawTicketNumber, authority = piDurablePrincipalAuthority) {
+    const ticketNumber = readDeclaredTicketNumber(rawTicketNumber);
+    if (ticketNumber === undefined) {
+        throw new Error("ak_report_ticket requires an identifiable ticketNumber");
+    }
+    const runDirectory = runDirectoryFromHostContext(context);
+    if (runDirectory === undefined) {
+        throw new Error("ak_report_ticket requires a per-turn run directory");
+    }
+    if (!existsSync(runDirectory)) {
+        throw new Error(`ak_report_ticket run directory missing: ${runDirectory}`);
+    }
+    const admitted = admittedForLiveTicketReport(runDirectory, authority);
+    const alreadyPlaced = !isUnboundRunDirectory(runDirectory);
+    // #1171 B2 / #1025: already under a ticket leaf — do not rewrite durable identity.
+    // Placement stays put; no heterogenous-ticket refuse policy (#1171 judge).
+    if (!alreadyPlaced) {
+        await bindAdmittedTicketNumber(admitted, ticketNumber);
+    }
+    // Live handles belong with rename ownership — before derived renderCurrentSync
+    // (#1171 F4-R2). Reuse relocate's heldLease.relocate seam; keep raw I/O throw.
+    const applyLiveHandles = (nextDirectory) => {
+        context.runDirectory = nextDirectory;
+        // Same-leg spawn env only (#1171 F1): never overwrite another leg's ambient
+        // AK_ROLE_RUN_DIR in a shared process. HostContext is the per-turn authority
+        // (host-contracts); Pi dedicated children still refresh when env === old path.
+        if (process.env.AK_ROLE_RUN_DIR === runDirectory) {
+            process.env.AK_ROLE_RUN_DIR = nextDirectory;
+        }
+        // Native host rebind only — SessionManager has no setSessionDir; appends follow sessionFile.
+        context.sessionManager.setSessionFile?.(sessionFileOf(nextDirectory));
+    };
+    const relocation = alreadyPlaced
+        ? undefined
+        : await relocateAdmittedRunToTicket(admitted, authority, { relocate: applyLiveHandles });
+    const nextDirectory = relocation?.newRunDirectory ?? admitted.runDirectory;
+    if (relocation === undefined)
+        applyLiveHandles(nextDirectory);
+    return {
+        ticketNumber: alreadyPlaced
+            ? (admitted.ticketNumber ?? ticketNumber)
+            : ticketNumber,
+        relocated: relocation !== undefined,
+    };
+}
+/** Register the report-ticket tool on the shared host tool mouth (same as submission). */
+export function registerReportTicketTool(roleHost) {
+    if (roleHost.getAllTools().some((tool) => tool.name === REPORT_TICKET_TOOL_NAME))
+        return;
+    roleHost.registerTool({
+        name: REPORT_TICKET_TOOL_NAME,
+        label: "报票号",
+        description: REPORT_TICKET_TOOL_DESCRIPTION,
+        promptSnippet: "已知票号时立即申报，包当场归位",
+        parameters: reportTicketArgsSchema,
+        async execute(_toolCallId, parameters, _signal, _onUpdate, ctx) {
+            const raw = isRecord(parameters) ? parameters.ticketNumber : undefined;
+            const details = await reportTicketFromHostContext(ctx, raw);
+            return {
+                content: [],
+                details,
+            };
+        },
+    });
+}
+/** Soft re-ask when a sealed submission still leaves the leg unbound (#1171 / ADR 0073). */
+export const MISSING_TICKET_REASK_MATERIAL = "resources/missing-ticket-reask.md";

package/dist/role-run-placement.js

@@ -97,8 +97,7 @@ function roleRunPlacement(ledgerHome, input) {
   return {
     runDirectory,
     sessionDirectory,
-    sessionFile: sessionFileIn(sessionDirectory),
-    attachmentsDirectory: join(runDirectory, "attachments")
+    sessionFile: sessionFileIn(sessionDirectory)
   };
 }
 function isUnboundRunDirectory(runDirectory) {

package/dist/role-run-relocation.js

@@ -3,7 +3,7 @@
  * Live callers project typed fields; only historical migrators walk durable pages.
  *
  * Scope is typed machine-consumed path fields only — never free text, never
- * frozen attachment/artifact bytes. Nested walk is confined to package-owned
+ * caller file-flag path strings. Nested walk is confined to package-owned
  * `session/` seams.
  */
 import { readdir, readFile, writeFile } from "node:fs/promises";
@@ -36,6 +36,11 @@ const RUN_STATE_PAGE_FIELDS = [
     "sessionDirectory",
     "sessionFile",
 ];
+/** Typed principal session coordinates rewritten when the owning run leaf moves. */
+export const PRINCIPAL_SESSION_PATH_FIELDS = [
+    "sessionDirectory",
+    "sessionFile",
+];
 const SOURCE_RUN_LOCATOR_FIELDS = ["runDirectory"];
 const SUMMONS_PATH_FIELDS = ["sourceRunPath"];
 const OFFICER_POINTER_FIELDS = ["sessionFile", "runDirectory"];
@@ -115,6 +120,21 @@ export function rewriteRunDirectoryPathFields(record, fields, oldRunDirectory, n
         { oldRunDirectory, newRunDirectory },
     ]);
 }
+/** Principal session paths only — shared live + durable projection after a run move. */
+export function rewritePrincipalSessionPaths(principal, oldRunDirectory, newRunDirectory) {
+    rewriteRunDirectoryPathFields(principal, PRINCIPAL_SESSION_PATH_FIELDS, oldRunDirectory, newRunDirectory);
+}
+/**
+ * Live turn request: move runDirectory and rewrite principal session paths in place.
+ * Callers that lack authority.seal use this; admitted refresh seals after the same rewrite.
+ */
+export function projectTurnRequestLiveRunDirectory(request, newRunDirectory) {
+    const old = request.runDirectory;
+    if (old === newRunDirectory)
+        return;
+    request.runDirectory = newRunDirectory;
+    rewritePrincipalSessionPaths(request.principal, old, newRunDirectory);
+}
 /** In-place rewrite of selected fields against a rewrite set. */
 export function rewriteRunDirectoryPathFieldsAgainstRewrites(record, fields, rewrites) {
     for (const field of fields) {
@@ -163,7 +183,7 @@ export function rewriteAdmittedRoleRunPage(page, rewrites) {
     rewriteSourceRunLocator(page.sourceRun, rewrites);
     // #1165: admitted attachments are caller paths outside the run directory — do not rewrite.
     if (isRecord(page.principal)) {
-        rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, ["sessionDirectory", "sessionFile"], rewrites);
+        rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, PRINCIPAL_SESSION_PATH_FIELDS, rewrites);
     }
 }
 /** Pre-#1161 `session/auditor-roles/<officer>.pointer.json` (migrator input only). */
@@ -301,7 +321,7 @@ async function rewriteSessionTranscriptBindings(path, rewrites) {
 /**
  * Package-owned nested seams under session/ only:
  * sitian records.jsonl,
- * session transcript typed parent bindings. Never walks attachments/.
+ * session transcript typed parent bindings. Never walks caller file paths.
  */
 async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
     const sessionRoot = join(pagesDirectory, "session");
@@ -355,7 +375,7 @@ export async function rewriteRoleRunDurablePages(input) {
         runState: (page) => {
             rewriteRunDirectoryPathFieldsAgainstRewrites(page, RUN_STATE_PAGE_FIELDS, rewrites);
             if (isRecord(page.principal)) {
-                rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, ["sessionDirectory", "sessionFile"], rewrites);
+                rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, PRINCIPAL_SESSION_PATH_FIELDS, rewrites);
             }
             // Open court summons: source-run locators only; caller attach paths stay (#1165).
             if (isRecord(page.currentCourt)) {

package/package.json

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

package/resources/engine-dispatch.md

@@ -10,11 +10,14 @@ Material is data for the model, not a code contract. Do not invent package flags
 
 ## What goes into the prompt
 
-The labor prompt carries **task + paths only**:
+The labor prompt carries **task + caller paths only**:
 
 - the task itself: goal, constraints, required output shape;
-- paths the engine reads itself: worktree root, ticket/issue number, frozen
-  attachment paths, run/dossier directory pointers (e.g. `AK_ROLE_RUN_DIR`).
+- paths the caller already named (file-flag paths or paths written in the
+  dispatch text). The seat finds dossier records itself under the ticket
+  directory, or under `unbound/` when there is no ticket. Do not hand the
+  engine attachment copies, run-directory pointers, or `AK_ROLE_RUN_DIR`
+  (that variable is for the package subprocess only — not a pointer to pass on).
 
 **Never paste material bodies into argv or the prompt** — no review bundles,
 no distilled-evidence dumps, no receipt JSON, no full briefs copied out of the

package/resources/engines/claude-code.md

@@ -39,11 +39,10 @@ returned body.
 
 `--dangerously-skip-permissions` is required in headless labor: the CLI's
 permission prompts cannot be answered without a TTY and are auto-denied. In
-particular, reading any path outside the project root — such as frozen
-attachments under `~/.ak-roles/books/<book>/runs/<run>/attachments/` — is
-refused without the flag ("The read was not permitted — I don't have access to
-that file outside the current worktree") and succeeds with it (host-verified
-2026-08-28).
+particular, reading any path outside the project root — such as a caller-given
+absolute path under `~/.ak-roles/` — is refused without the flag ("The read was
+not permitted — I don't have access to that file outside the current worktree")
+and succeeds with it (host-verified 2026-08-28).
 
 Prefer `claude --help` on the host over any remembered flag set. Do not wrap
 this engine behind `ak-role` flags.

package/resources/missing-ticket-reask.md

@@ -0,0 +1 @@
+本腿仍无票号。请调用 ak_report_ticket 申报，或在交卷里带上 ticketNumber。只问这一次。