@akagilnc/pi-workflow-roles 0.1.2521 → 0.1.2653-next.71811ca

package/src/sitian-appender.ts

@@ -0,0 +1,171 @@
+/**
+ * Sitian Appender kernel (ADR 0065).
+ * Computes destination automatically from ledger topology without destination parameters.
+ * Owns volume open, torn-tail recovery, entry-level idempotency, and commit boundary.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+import { resolveBookKeyFromGit } from "./activation-ledger-git.ts";
+import {
+  activationBookDirectory,
+  ensureRealDirectoryTree,
+  errorText,
+  physicallyContainedIn,
+  resolveActivationLedgerHome,
+} from "./activation-ledger-topology.ts";
+import {
+  SitianInfrastructureError,
+  type RecordPointer,
+  type SitianRecord,
+  type SitianRecordInput,
+} from "./sitian-contracts.ts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Authorized S4 submission ledger kinds that share a common run submission volume. */
+export const S4_SUBMISSION_LEDGER_KINDS = new Set([
+  "candidate",
+  "batchContext",
+  "outcome",
+  "sealed",
+  "post-seal-anomaly",
+]);
+
+/** Compute the volume partition key for directory placement. */
+export function resolveSitianVolumeCategory(kind: string): string {
+  if (S4_SUBMISSION_LEDGER_KINDS.has(kind)) {
+    return "submission-ledger";
+  }
+  return kind;
+}
+
+function safeBookKey(cwd: string): string {
+  try {
+    return resolveBookKeyFromGit(cwd);
+  } catch {
+    return basename(resolve(cwd)) || "default";
+  }
+}
+
+/** Compute the destination directory and record file from ledger topology (ADR 0065). */
+export function resolveSitianRecordPath(input: SitianRecordInput): {
+  readonly sessionDir: string;
+  readonly recordFile: string;
+  readonly ledgerHome: string;
+} {
+  const cwd = input.cwd ?? process.cwd();
+  const ledgerHome = resolveActivationLedgerHome();
+  const category = resolveSitianVolumeCategory(input.kind);
+
+  let sessionDir: string;
+
+  if (input.sessionParent !== undefined && input.sessionParent.length > 0 && physicallyContainedIn(ledgerHome, input.sessionParent)) {
+    sessionDir = join(dirname(input.sessionParent), category);
+  } else {
+    const bookKey = safeBookKey(cwd);
+    const bookDir = activationBookDirectory(ledgerHome, bookKey);
+    if (input.subject !== undefined) {
+      let subjectStr: string;
+      if (typeof input.subject === "string") {
+        subjectStr = input.subject;
+      } else if (typeof input.subject.runId === "string" && input.subject.runId.length > 0) {
+        subjectStr = input.subject.runId;
+      } else {
+        subjectStr = JSON.stringify(input.subject);
+      }
+      const digest = createHash("sha256").update(subjectStr).digest("hex").slice(0, 32);
+      sessionDir = join(bookDir, category, digest);
+    } else {
+      sessionDir = join(bookDir, category);
+    }
+  }
+
+  const recordFile = join(sessionDir, "records.jsonl");
+  return { sessionDir, recordFile, ledgerHome };
+}
+
+/**
+ * Appends a canonical record to its self-computed volume under the Sitian contract.
+ * - Idempotency: checks volume by deterministic canonical identity; returns existing pointer on hit.
+ * - Torn-tail recovery: checks file tail; un-terminated trailing bytes are sealed with a newline and re-parsed.
+ *   Substate a (valid JSON): committed on recovery, returns existing pointer.
+ *   Substate b (malformed): preserved as bad line, check misses, appends new row.
+ * - Commit point: full JSON string ending with newline.
+ */
+export function appendSitianRecord(input: SitianRecordInput): RecordPointer {
+  try {
+    const { sessionDir, recordFile, ledgerHome } = resolveSitianRecordPath(input);
+    ensureRealDirectoryTree(ledgerHome, sessionDir);
+
+    const identity = input.identity ?? randomUUID();
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const host = input.host ?? "pi";
+
+    const record: SitianRecord = {
+      level: input.level,
+      kind: input.kind,
+      identity,
+      ...(input.subject === undefined ? {} : { subject: input.subject }),
+      ...(input.sessionParent === undefined ? {} : { sessionParent: input.sessionParent }),
+      ...(input.priorEventId === undefined ? {} : { priorEventId: input.priorEventId }),
+      timestamp,
+      host,
+      ...(input.source === undefined ? {} : { source: input.source }),
+      ...(input.payload === undefined ? {} : { payload: input.payload }),
+      ...(input.raw === undefined ? {} : { raw: input.raw }),
+      ...(input.usage === undefined ? {} : { usage: input.usage }),
+    };
+
+    if (existsSync(recordFile)) {
+      const buffer = readFileSync(recordFile);
+      if (buffer.length > 0) {
+        // Torn-tail check: if last byte is not newline, seal the fragment with \n
+        if (buffer[buffer.length - 1] !== 0x0a) {
+          appendFileSync(recordFile, "\n", "utf8");
+        }
+
+        // Self-check volume by canonical identity
+        const text = readFileSync(recordFile, "utf8");
+        for (const line of text.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (isRecord(parsed) && parsed.identity === identity) {
+              // Existing record found (or substate a recovered record) -> return existing pointer
+              return {
+                identity,
+                recordFile,
+                kind: record.kind,
+                level: record.level,
+              };
+            }
+          } catch {
+            // Malformed lines (including substate b preserved bad lines) are ignored during self-check
+          }
+        }
+      }
+    }
+
+    // Not found -> append new canonical row terminating with newline
+    const row = `${JSON.stringify(record)}\n`;
+    appendFileSync(recordFile, row, "utf8");
+
+    return {
+      identity,
+      recordFile,
+      kind: record.kind,
+      level: record.level,
+    };
+  } catch (error) {
+    if (error instanceof SitianInfrastructureError) throw error;
+    throw new SitianInfrastructureError(
+      `Sitian appender persistence failure: ${errorText(error)}`,
+      { cause: error },
+    );
+  }
+}

package/src/sitian-contracts.ts

@@ -0,0 +1,106 @@
+/**
+ * Sitian (司天台) canonical contracts, Layout schema, and pointer definitions.
+ * ADR 0065 single record entry + ADR 0068 Taishi analysis.
+ */
+
+/** Closed set of record levels. */
+export type SitianLevel = "run-summary" | "event" | "protocol-snapshot";
+
+/** Subject coordinate identifying the work identity or run attempt. */
+export type SitianSubject =
+  | string
+  | {
+      readonly runId: string;
+      readonly attemptId?: string | undefined;
+      readonly [key: string]: unknown;
+    };
+
+/** Raw reference pointing to original retained bytes/frames without duplication (#513). */
+export type SitianRawReference = {
+  readonly sessionFile: string;
+  readonly entryId: string | number;
+};
+
+/** Optional usage metrics carried on canonical records. */
+export type SitianUsage = {
+  readonly promptTokens?: number | undefined;
+  readonly completionTokens?: number | undefined;
+  readonly totalTokens?: number | undefined;
+  readonly [key: string]: unknown;
+};
+
+/** Canonical Sitian record layout. */
+export type SitianRecord = {
+  readonly level: SitianLevel;
+  readonly kind: string;
+  readonly identity: string;
+  readonly subject?: SitianSubject | undefined;
+  /** Parent session principal link / nesting origin. */
+  readonly sessionParent?: string | undefined;
+  /** Prior event identity in a submission ledger chain (S4; distinct from sessionParent). */
+  readonly priorEventId?: string | undefined;
+  readonly timestamp: string;
+  readonly host: string;
+  readonly source?: string | undefined;
+  readonly payload?: unknown;
+  readonly raw?: SitianRawReference | undefined;
+  readonly usage?: SitianUsage | undefined;
+};
+
+/** Typed pointer returned upon durable acceptance of a record. */
+export type RecordPointer = {
+  readonly identity: string;
+  readonly recordFile: string;
+  readonly kind: string;
+  readonly level: SitianLevel;
+};
+
+/** Input passed to the Sitian facade (sitianReport). */
+export type SitianRecordInput = {
+  readonly level: SitianLevel;
+  readonly kind: string;
+  /** Deterministic or explicit record identity. Minted if omitted. */
+  readonly identity?: string | undefined;
+  readonly subject?: SitianSubject | undefined;
+  readonly sessionParent?: string | undefined;
+  readonly priorEventId?: string | undefined;
+  readonly timestamp?: string | undefined;
+  readonly host?: string | undefined;
+  readonly source?: string | undefined;
+  readonly payload?: unknown;
+  readonly raw?: SitianRawReference | undefined;
+  readonly usage?: SitianUsage | undefined;
+  readonly cwd?: string | undefined;
+};
+
+/** Typed malformed diagnostic emitted by the canonical Reader upon encountering damaged lines. */
+export type SitianMalformedDiagnostic = {
+  readonly kind: "malformed";
+  readonly line: number;
+  readonly raw: string;
+  readonly error: string;
+};
+
+/** Canonical Reader result surfacing both valid records and non-destructive diagnostics. */
+export type SitianReadResult = {
+  readonly records: readonly SitianRecord[];
+  readonly diagnostics: readonly SitianMalformedDiagnostic[];
+};
+
+/** Lift direct-cause fs errno onto a wrap error (no chain walk). */
+export function attachDirectErrnoCode(error: Error, cause: unknown): void {
+  if (cause === null || typeof cause !== "object" || !("code" in cause)) return;
+  const code = (cause as { code?: unknown }).code;
+  if (typeof code === "string") (error as NodeJS.ErrnoException).code = code;
+}
+
+/** Typed infrastructure error for real ledger persistence / IO failures. */
+export class SitianInfrastructureError extends Error {
+  readonly knownCause = "session" as const;
+
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "SitianInfrastructureError";
+    attachDirectErrnoCode(this, options?.cause);
+  }
+}

package/src/sitian-facade.ts

@@ -0,0 +1,18 @@
+/**
+ * Sitian Facade (司天门面) — Sole entrypoint for record reporting across all producers.
+ * ADR 0065 single record entry, #520 r8.
+ */
+import { appendSitianRecord } from "./sitian-appender.ts";
+import type { RecordPointer, SitianRecordInput } from "./sitian-contracts.ts";
+
+export * from "./sitian-contracts.ts";
+export * from "./sitian-appender.ts";
+export * from "./sitian-reader.ts";
+
+/**
+ * Sole write API for Sitian canonical records.
+ * Returns typed RecordPointer with durable record identity and readable file location.
+ */
+export function sitianReport(input: SitianRecordInput): RecordPointer {
+  return appendSitianRecord(input);
+}

package/src/sitian-reader.ts

@@ -0,0 +1,62 @@
+/**
+ * Sitian Reader kernel (ADR 0068 / #520 r8).
+ * Sole authoritative read path for canonical Sitian records.
+ * Traversal contract:
+ * - Malformed lines are exposed as typed malformed diagnostics and traversal continues.
+ * - Zero whitewashing, zero deduplication.
+ * - Canonical rows after malformed lines are always reachable.
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+import type {
+  SitianMalformedDiagnostic,
+  SitianReadResult,
+  SitianRecord,
+} from "./sitian-contracts.ts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read a Sitian record volume with full traversal and non-destructive diagnostics. */
+export async function readSitianRecords(recordFile: string): Promise<SitianReadResult> {
+  if (!existsSync(recordFile)) {
+    return { records: [], diagnostics: [] };
+  }
+
+  const text = await readFile(recordFile, "utf8");
+  const lines = text.split("\n");
+
+  const records: SitianRecord[] = [];
+  const diagnostics: SitianMalformedDiagnostic[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]!;
+    if (!line.trim()) continue;
+
+    try {
+      const parsed = JSON.parse(line);
+      if (isRecord(parsed)) {
+        records.push(parsed as unknown as SitianRecord);
+      } else {
+        const typeDesc = parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed;
+        diagnostics.push({
+          kind: "malformed",
+          line: index + 1,
+          raw: line,
+          error: `expected JSON object, got ${typeDesc}`,
+        });
+      }
+    } catch (error) {
+      diagnostics.push({
+        kind: "malformed",
+        line: index + 1,
+        raw: line,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return { records, diagnostics };
+}

package/src/worker-role.ts

@@ -1,15 +1,7 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  AgentToolResult,
-} from "@earendil-works/pi-coding-agent";
+import type { RoleHost, HostContext, HostToolResult, HostGatekeeperActions } from "./host-contracts.ts";
+import { stringEnum } from "./host-contracts.ts";
 import { Type, type Static } from "typebox";
 import { openToolObjectFromUnion } from "./open-tool-schema.ts";
-import {
-  failOnInfrastructureFailureDeclaration,
-  withInfrastructureFailureDeclaration,
-} from "./package-contracts/terminating-infrastructure.ts";
 
 import type {
   AnyCanonicalSkillBinding,
@@ -32,7 +24,6 @@ import {
   parseFixerPrerequisites,
   type FixerInvocationInput,
 } from "./package-contracts/fixer-packet.ts";
-import { requireGatekeeperPass, type GatekeeperPassHostActions } from "./gatekeeper-role.ts";
 import {
   createWorkerSubmissionGate,
   WorkerCommitReminderError,
@@ -65,18 +56,18 @@ function matchFixerBashForbiddenLiteral(
 
 const coderOutputVariants = Type.Union([
   Type.Object({
-    status: StringEnum(["planned"] as const, { description: "planned — 形状指引，非 schema 闸" }),
+    status: stringEnum(["planned"] as const, { description: "planned — 形状指引，非 schema 闸" }),
     report: Type.String({ minLength: 1, description: "如实结果报告" }),
   }, { additionalProperties: false }),
   Type.Object({
-    status: StringEnum(["completed", "refused"] as const, {
+    status: stringEnum(["completed", "refused"] as const, {
       description:
         "completed | refused — 形状指引，非 schema 闸；completed 回执含 TDD、同模式、引入回归、行为事实四项证据",
     }),
     report: Type.String({ minLength: 1, description: "如实结果报告" }),
   }, { additionalProperties: false }),
   Type.Object({
-    status: StringEnum(["unfinished"] as const, {
+    status: stringEnum(["unfinished"] as const, {
       description:
         "unfinished — 形状指引，非 schema 闸；缺前置或违宪约束致本局未完成时可用。缺待决 owner 决定或答复属缺前置。",
     }),
@@ -89,9 +80,7 @@ const coderOutputVariants = Type.Union([
     })),
   }, { additionalProperties: false }),
 ]);
-export const coderOutputSchema = withInfrastructureFailureDeclaration(
-  openToolObjectFromUnion(coderOutputVariants),
-);
+const coderOutputSchema = openToolObjectFromUnion(coderOutputVariants);
 export type { FixerOutput, CoderOutput };
 export const FIXER_FLAG_DEFINITIONS = {
   packet: {
@@ -125,7 +114,26 @@ function isWorkerPhase(value: unknown): value is WorkerPhase {
   return typeof value === "string" && (FIXER_PHASES as readonly string[]).includes(value);
 }
 
-export type WorkerRoleHostActions = GatekeeperPassHostActions;
+export type WorkerRoleHostActions = HostGatekeeperActions;
+
+/** Stable code for completed apply without host skill-expansion capability evidence (#525). */
+export const CODER_SKILL_EXPANSION_EVIDENCE_MISSING_CODE =
+  "coder_skill_expansion_evidence_missing" as const;
+
+export type CoderSkillExpansionEvidenceMissingResult = {
+  readonly code: typeof CODER_SKILL_EXPANSION_EVIDENCE_MISSING_CODE;
+};
+
+/** Correct completed rejection — not infrastructure; projected via submission non-pass bridge. */
+export class CoderSkillExpansionEvidenceMissingError extends Error {
+  readonly code = CODER_SKILL_EXPANSION_EVIDENCE_MISSING_CODE;
+  readonly result: CoderSkillExpansionEvidenceMissingResult;
+  constructor() {
+    super("Coder completed requires host skill-expansion capability evidence");
+    this.name = "CoderSkillExpansionEvidenceMissingError";
+    this.result = Object.freeze({ code: CODER_SKILL_EXPANSION_EVIDENCE_MISSING_CODE });
+  }
+}
 
 export type FixerRoleDependencies = {
   loadSoul(): Promise<string>;
@@ -141,7 +149,7 @@ export type CoderRoleDependencies = {
 };
 
 export type WorkerRoleRuntime = {
-  activate(ctx?: ExtensionContext): Promise<void>;
+  activate(ctx?: HostContext): Promise<void>;
   /** Arm gate ① baseline after envelope places the worktree (coder/fixer). Parent feeds archivist durability. */
   armSubmissionGate(cwd: string, parent?: { getSessionFile(): string | undefined }): void;
 };
@@ -169,14 +177,14 @@ function requireSingletonSubmissionCall(
   toolCallId: string,
   expectedToolName: string,
   roleLabel: WorkerRoleLabel,
-  ctx: ExtensionContext,
+  ctx: HostContext,
 ): void {
   const leaf = ctx.sessionManager.getLeafEntry();
   const seat = roleLabel === "Fixer" ? "修内司" : "将作监";
-  if (leaf?.type !== "message" || leaf.message.role !== "assistant") {
+  if (leaf?.type !== "message" || leaf.message === undefined || leaf.message.role !== "assistant" || !Array.isArray(leaf.message.content)) {
     throw new Error(`${seat}回执非唯一终局工具调用`);
   }
-  const calls = leaf.message.content.filter((part) => part.type === "toolCall");
+  const calls = leaf.message.content.filter((part): part is Extract<typeof part, { type: "toolCall" }> => part.type === "toolCall");
   const call = calls[0];
   if (
     calls.length !== 1 || call === undefined || call.id !== toolCallId ||
@@ -192,7 +200,7 @@ function assertAcceptableThroughHost(
   status: string,
   details: unknown,
   hostActions: WorkerRoleHostActions,
-  ctx: ExtensionContext,
+  ctx: HostContext,
   toolCallId: string,
 ): void {
   try {
@@ -210,7 +218,7 @@ function assertAcceptableThroughHost(
 }
 
 export function createFixerRoleRuntime(
-  pi: ExtensionAPI,
+  pi: RoleHost,
   dependencies: FixerRoleDependencies,
   hostActions: WorkerRoleHostActions,
 ): WorkerRoleRuntime {
@@ -268,16 +276,13 @@ export function createFixerRoleRuntime(
         pi.registerTool({
           name: FIXER_OUTPUT_TOOL_NAME,
           label: "修内司输出",
-          description: "提交修内司终局回执",
+          description: "提交修内司终局回执；基础设施失败走 abort，不经本工具。",
           promptSnippet: "提交修内司终局回执",
           parameters: fixerOutputSchema,
-          async execute(toolCallId, parameters, _signal, _onUpdate, ctx): Promise<AgentToolResult<unknown>> {
+          async execute(toolCallId: string, parameters: unknown, _signal: AbortSignal | undefined, _onUpdate: unknown, ctx: HostContext): Promise<HostToolResult<unknown>> {
             if (packet === undefined || phase === undefined) {
               throw new Error("修内司修理包与阶段未装载");
             }
-            // #541: infra declaration fails via the shared host seam before any
-            // submission gate + Gatekeeper work.
-            failOnInfrastructureFailureDeclaration(parameters, hostActions, ctx, toolCallId);
             requireSingletonSubmissionCall(
               toolCallId,
               FIXER_OUTPUT_TOOL_NAME,
@@ -293,7 +298,7 @@ export function createFixerRoleRuntime(
               ctx,
               toolCallId,
             );
-            await requireGatekeeperPass({
+            await pi.requireGatekeeperPass!({
               context: ctx,
               subject: { kind: "worker_completion", material: JSON.stringify(output) },
               ...(_signal === undefined ? {} : { signal: _signal }),
@@ -336,7 +341,7 @@ export function createFixerRoleRuntime(
 }
 
 export function createCoderRoleRuntime(
-  pi: ExtensionAPI,
+  pi: RoleHost,
   dependencies: CoderRoleDependencies,
   hostActions: WorkerRoleHostActions,
 ): WorkerRoleRuntime {
@@ -405,13 +410,10 @@ export function createCoderRoleRuntime(
           description: "提交将作监终局回执；本工具无 escalate 通道。",
           promptSnippet: "提交将作监终局回执",
           parameters: coderOutputSchema,
-          async execute(toolCallId, parameters, _signal, _onUpdate, ctx) {
+          async execute(toolCallId: string, parameters: unknown, _signal: AbortSignal | undefined, _onUpdate: unknown, ctx: HostContext) {
             if (task === undefined || phase === undefined) {
               throw new Error("将作监任务与阶段未装载");
             }
-            // #541: infra declaration fails via the shared host seam before any
-            // submission gate + Gatekeeper work.
-            failOnInfrastructureFailureDeclaration(parameters, hostActions, ctx, toolCallId);
             requireSingletonSubmissionCall(
               toolCallId,
               CODER_OUTPUT_TOOL_NAME,
@@ -423,9 +425,9 @@ export function createCoderRoleRuntime(
               phase === "apply" && output.status === "completed" &&
               !expansionCaptured
             ) {
-              throw new Error(
-                "Coder completed requires the Matt tdd skill to be expanded through Pi /skill:tdd",
-              );
+              const rejection = new CoderSkillExpansionEvidenceMissingError();
+              hostActions.bindSubmissionNonPass(toolCallId, rejection.result);
+              throw rejection;
             }
             assertAcceptableThroughHost(
               submissionGate,
@@ -435,7 +437,7 @@ export function createCoderRoleRuntime(
               ctx,
               toolCallId,
             );
-            await requireGatekeeperPass({
+            await pi.requireGatekeeperPass!({
               context: ctx,
               subject: { kind: "worker_completion", material: JSON.stringify(output) },
               ...(_signal === undefined ? {} : { signal: _signal }),
@@ -483,7 +485,7 @@ export function createCoderRoleRuntime(
               expansionPending = false;
               if (originalRequest !== undefined) {
                 expansionCaptured = binding.captureExpansion(
-                  event.prompt,
+                  pi.capabilities?.skillExpansion(event.prompt),
                   originalRequest,
                 ) !== undefined;
               }

package/src/worker-submission-gates.ts

@@ -9,6 +9,7 @@ import {
   type RecordSessionParent,
   WORKER_SUBMISSION_GATE_KIND,
 } from "./archivist-record-entry.ts";
+import { sitianReport } from "./sitian-facade.ts";
 
 export const WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 export const WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
@@ -275,6 +276,18 @@ export function createWorkerSubmissionGate(): {
         version: 1,
         head: baseline,
       });
+      sitianReport({
+        level: "event",
+        kind: "gate",
+        cwd,
+        ...(parent?.getSessionFile() ? { sessionParent: parent.getSessionFile() } : {}),
+        payload: {
+          type: WORKER_COMMIT_BASELINE_ENTRY_TYPE,
+          version: 1,
+          head: baseline,
+        },
+        source: "worker-submission-gates",
+      });
     },
     assertAcceptable(status, details) {
       if (status === "unfinished" && !unfinishedReasonPresent(details)) {
@@ -291,6 +304,16 @@ export function createWorkerSubmissionGate(): {
       if (!headMoved && !reminded) {
         reminded = true;
         record?.appendCustomEntry(WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
+        sitianReport({
+          level: "event",
+          kind: "gate",
+          cwd: root,
+          payload: {
+            type: WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE,
+            version: 1,
+          },
+          source: "worker-submission-gates",
+        });
         throw new WorkerCommitReminderError();
       }
       reminded = true;
@@ -307,6 +330,16 @@ export function createWorkerSubmissionGate(): {
       }
       prefixReminded = true;
       record?.appendCustomEntry(WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
+      sitianReport({
+        level: "event",
+        kind: "gate",
+        cwd: root,
+        payload: {
+          type: WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE,
+          version: 1,
+        },
+        source: "worker-submission-gates",
+      });
       throw new WorkerPrefixReminderError();
     },
   };

package/dist/archivist-role-run-coordinates.js

@@ -1,28 +0,0 @@
-import { join } from "node:path";
-import { resolveBookKeyFromGit } from "./activation-ledger-git.js";
-import {
-  activationBookDirectory,
-  resolveActivationLedgerHome
-} from "./activation-ledger-topology.js";
-function roleRunSessionCoordinates(options) {
-  const ledgerHome = resolveActivationLedgerHome(
-    options.home === void 0 ? void 0 : () => options.home
-  );
-  const bookKey = resolveBookKeyFromGit(options.cwd);
-  const runDirectory = join(
-    activationBookDirectory(ledgerHome, bookKey),
-    "runs",
-    `${options.runId}@${options.role}`
-  );
-  const sessionDirectory = join(runDirectory, "session");
-  return {
-    ledgerHome,
-    bookKey,
-    runDirectory,
-    sessionDirectory,
-    sessionFile: join(sessionDirectory, "session.jsonl")
-  };
-}
-export {
-  roleRunSessionCoordinates
-};