@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

package/dist/analyst-metric-families.js

@@ -0,0 +1,23 @@
+import acceptanceSuccessReworkFamily from "./analyst-metric-families/acceptance-success-rework.js";
+import b2FrameBucketsActionsFamily from "./analyst-metric-families/b2-frame-buckets-actions.js";
+import gateCyclesFamily from "./analyst-metric-families/gate-cycles.js";
+import legWallClockFamily from "./analyst-metric-families/leg-wall-clock.js";
+import roundTimelineFamily from "./analyst-metric-families/round-timeline.js";
+/**
+ * Production issue-page family modules in stable id order.
+ * Static graph — reachable from source and from the public CLI bundle alike.
+ */
+const ISSUE_METRIC_FAMILIES = [
+    acceptanceSuccessReworkFamily,
+    b2FrameBucketsActionsFamily,
+    gateCyclesFamily,
+    legWallClockFamily,
+    roundTimelineFamily,
+].sort((a, b) => a.id.localeCompare(b.id));
+/**
+ * Load the registered issue-page metric families.
+ * Always resolves the static package registry (never readdir of a sibling tree).
+ */
+export async function loadAnalystIssueMetricFamilies() {
+    return ISSUE_METRIC_FAMILIES;
+}

package/dist/analyst-metric-family.js

@@ -0,0 +1,11 @@
+/** Fold discovered family modules into one section bag (Object.assign order). */
+export function composeAnalystMetricFamilySections(families, input) {
+    const sections = {};
+    for (const family of families) {
+        const piece = family.contribute(input);
+        if (piece === undefined)
+            continue;
+        Object.assign(sections, piece);
+    }
+    return sections;
+}

package/dist/analyst-model-groups.js

@@ -0,0 +1,135 @@
+/**
+ * Analyst model-group mode kernel (PRD #298 output ④ / ticket #331).
+ *
+ * Per-leg raw model grouping (single | mixed:ordered-dedup whole-leg unit)
+ * over a caller-typed issue set. Combination mapping is display-alias only:
+ * raw group identity and denominators never merge.
+ *
+ * Acceptance / success faces reuse the B3 terminal map (受理≠成功, planned
+ * out of success den) — no second outcome kernel.
+ */
+import { buildAcceptanceSuccessReworkSection } from "./analyst-metric-families/acceptance-success-rework.js";
+import { medianNumber } from "./analyst-median.js";
+/**
+ * Build the raw group key for one leg from its ordered-unique model sequence.
+ * Empty sequence → undefined (no inventable group; caller lists as typed vacancy).
+ * One model → that raw id. Multi → `mixed:` + `+`-joined ordered uniques.
+ */
+export function analystModelGroupKey(models) {
+    if (models.length === 0)
+        return undefined;
+    if (models.length === 1)
+        return models[0];
+    return `mixed:${models.join("+")}`;
+}
+function rate(numerator, denominator) {
+    if (denominator === 0)
+        return undefined;
+    return numerator / denominator;
+}
+function displayNameFor(rawGroupKey, combinationMapping) {
+    if (combinationMapping === undefined)
+        return rawGroupKey;
+    const aliased = combinationMapping[rawGroupKey];
+    return aliased === undefined ? rawGroupKey : aliased;
+}
+function sortUnreadable(unreadable) {
+    return [...unreadable].sort((a, b) => {
+        if (a.book !== b.book)
+            return a.book.localeCompare(b.book);
+        return a.runId.localeCompare(b.runId);
+    });
+}
+/**
+ * Legs with no usable session model identity cannot join any model group.
+ * Reuse the typed unreadable path (locatable missing-source) — not an empty-key group.
+ */
+function modelIdentityAbsentEntry(run) {
+    return {
+        runId: run.runId,
+        book: run.book,
+        missingSources: ["session-model"],
+        reason: "session has no usable model identity",
+        firstFrameAt: { status: "present", at: run.frameSpan.startedAt },
+        // Readable legs already admitted a full span — retain end edge for lastActivityAt.
+        lastFrameAt: { status: "present", at: run.frameSpan.endedAt },
+    };
+}
+/**
+ * Aggregate readable runs into model groups.
+ * Stats identity is always the raw key; mapping only projects displayName.
+ * Model-identity vacancy is excluded from every group den and listed as unreadable.
+ */
+export function buildAnalystModelGroupsPage(input) {
+    // Split before B3 projection: only model-bearing legs enter group dens.
+    // Carry the non-empty raw key so aggregation need not re-check vacancy.
+    const groupedRuns = [];
+    const modelAbsent = [];
+    for (const run of input.runs) {
+        const rawGroupKey = analystModelGroupKey(run.models);
+        if (rawGroupKey === undefined) {
+            modelAbsent.push(modelIdentityAbsentEntry(run));
+        }
+        else {
+            groupedRuns.push({ run, rawGroupKey });
+        }
+    }
+    const acceptance = buildAcceptanceSuccessReworkSection(groupedRuns.map(({ run }) => run));
+    const legByRunId = new Map((acceptance?.legs ?? []).map((leg) => [leg.runId, leg]));
+    const byRaw = new Map();
+    for (const { run, rawGroupKey } of groupedRuns) {
+        const leg = legByRunId.get(run.runId);
+        if (leg === undefined) {
+            // Readable run must project through B3 map; missing is an invariant break.
+            throw new Error(`analyst model-groups: missing acceptance projection for run ${run.runId}`);
+        }
+        let acc = byRaw.get(rawGroupKey);
+        if (acc === undefined) {
+            acc = {
+                acceptedCount: 0,
+                successCount: 0,
+                successEligibleCount: 0,
+                noReceiptCount: 0,
+                walls: [],
+            };
+            byRaw.set(rawGroupKey, acc);
+        }
+        if (leg.accepted)
+            acc.acceptedCount += 1;
+        if (leg.success)
+            acc.successCount += 1;
+        if (leg.successEligible)
+            acc.successEligibleCount += 1;
+        if (leg.noReceipt)
+            acc.noReceiptCount += 1;
+        acc.walls.push(leg.wallMs);
+    }
+    const rawKeys = [...byRaw.keys()].sort((a, b) => a.localeCompare(b));
+    const groups = rawKeys.map((rawGroupKey) => {
+        const acc = byRaw.get(rawGroupKey);
+        const legCount = acc.walls.length;
+        return {
+            rawGroupKey,
+            displayName: displayNameFor(rawGroupKey, input.combinationMapping),
+            legCount,
+            acceptedCount: acc.acceptedCount,
+            acceptanceRate: rate(acc.acceptedCount, legCount),
+            successCount: acc.successCount,
+            successEligibleCount: acc.successEligibleCount,
+            successRate: rate(acc.successCount, acc.successEligibleCount),
+            noReceiptCount: acc.noReceiptCount,
+            noReceiptRate: rate(acc.noReceiptCount, legCount),
+            wallClockMedianMs: medianNumber(acc.walls),
+        };
+    });
+    const unreadable = sortUnreadable([...input.unreadable, ...modelAbsent]);
+    return {
+        kind: "analyst-model-groups",
+        mode: "model-groups",
+        projectRoots: [...input.projectRoots].sort((a, b) => a.localeCompare(b)),
+        groups,
+        legCount: groupedRuns.length,
+        unreadableCount: unreadable.length,
+        unreadable,
+    };
+}

package/dist/analyst-page.js

@@ -0,0 +1,182 @@
+/**
+ * Analyst issue metrics page envelope + atomic persistence (ADR 0068 / PRD #298).
+ *
+ * A1 minimum fields: issue scope (projectRoot) + leg list + unreadable exclusion.
+ * A2: metric-family modules under analyst-metric-families/ contribute optional
+ * top-level sections via directory discovery — B/C waves add family files
+ * without forking the page writer or editing a shared registry list.
+ */
+import { createHash } from "node:crypto";
+import { dirname, join } from "node:path";
+import { writeFileAtomically } from "./atomic-write.js";
+import { assertLedgerFileInsideHome, ensureRealDirectoryTree, physicalPathIdentity, } from "./activation-ledger-topology.js";
+import { loadAnalystIssueMetricFamilies } from "./analyst-metric-families.js";
+import { composeAnalystMetricFamilySections } from "./analyst-metric-family.js";
+export function analystIssuePageKey(address) {
+    const parts = ["book", address.bookKey];
+    if (address.issueNumber !== undefined) {
+        parts.push("ticket", String(address.issueNumber));
+    }
+    else if (address.scopeRootIdentity !== undefined) {
+        parts.push("root", physicalPathIdentity(address.scopeRootIdentity));
+    }
+    return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
+}
+export function analystIssuePagePath(ledgerHome, address) {
+    return join(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
+}
+export function analystIssuePageAddressFromPage(page) {
+    return {
+        bookKey: page.bookKey,
+        ...(page.issueNumber === undefined ? {} : { issueNumber: page.issueNumber }),
+        ...(page.scopeRootIdentity === undefined
+            ? {}
+            : { scopeRootIdentity: page.scopeRootIdentity }),
+    };
+}
+function sortLegs(legs) {
+    return [...legs].sort((a, b) => {
+        if (a.book !== b.book)
+            return a.book.localeCompare(b.book);
+        if (a.role !== b.role)
+            return a.role.localeCompare(b.role);
+        return a.runId.localeCompare(b.runId);
+    });
+}
+function sortUnreadable(unreadable) {
+    return [...unreadable].sort((a, b) => {
+        if (a.book !== b.book)
+            return a.book.localeCompare(b.book);
+        return a.runId.localeCompare(b.runId);
+    });
+}
+function sortScopeConflicts(conflicts) {
+    return [...conflicts].sort((a, b) => {
+        // Caller dual-param (no runId) sorts before run conflicts; then by root.
+        const aRun = a.runId ?? "";
+        const bRun = b.runId ?? "";
+        if (aRun !== bRun)
+            return aRun.localeCompare(bRun);
+        return a.projectRoot.localeCompare(b.projectRoot);
+    });
+}
+/**
+ * Admit caller LOC at the typed input boundary.
+ * Finite non-negative only; 0 remains a lawful typed 空缺 signal (not rejected).
+ * NaN / negative / ±Infinity are structural rejects (sweep attach + issue mode).
+ */
+export function assertAnalystChangedLinesInput(changedLines) {
+    if (changedLines === undefined)
+        return;
+    if (typeof changedLines !== "number" || !Number.isFinite(changedLines) || changedLines < 0) {
+        throw new Error(`analyst changedLines must be a finite non-negative number, got ${String(changedLines)}`);
+    }
+}
+/**
+ * Normalize caller LOC: only omit or 0 → typed 空缺 (PRD efficiency口径).
+ * Callers must pass {@link assertAnalystChangedLinesInput} first.
+ */
+export function normalizeAnalystChangedLines(changedLines) {
+    assertAnalystChangedLinesInput(changedLines);
+    if (changedLines === undefined || changedLines === 0) {
+        return { status: "absent" };
+    }
+    return { status: "present", value: changedLines };
+}
+/**
+ * 耗时/千行 = totalElapsedMs ÷ (changedLines/1000).
+ * LOC absent/0 → typed 空缺 (no division; never emit 0 or ∞ as stand-in).
+ */
+export function computeAnalystMsPerKLines(totalElapsedMs, changedLines) {
+    if (changedLines.status === "absent")
+        return { status: "absent" };
+    return {
+        status: "present",
+        value: totalElapsedMs / (changedLines.value / 1000),
+    };
+}
+function frameSpanWallMs(span) {
+    return Date.parse(span.endedAt) - Date.parse(span.startedAt);
+}
+/**
+ * Σ readable wall clocks + max end-frame across ALL runs (C1 efficiency / index).
+ * Unreadable runs never enter totalElapsedMs; their available lastFrameAt still
+ * competes for lastActivityAt (PRD ②: 全部 run 末帧之最大者).
+ */
+export function summarizeAnalystRunEfficiency(runs, unreadable = []) {
+    let totalElapsedMs = 0;
+    let latestEndedAt;
+    for (const run of runs) {
+        totalElapsedMs += frameSpanWallMs(run.frameSpan);
+        const endedAt = run.frameSpan.endedAt;
+        if (latestEndedAt === undefined || endedAt > latestEndedAt) {
+            latestEndedAt = endedAt;
+        }
+    }
+    for (const entry of unreadable) {
+        if (entry.lastFrameAt.status !== "present")
+            continue;
+        const endedAt = entry.lastFrameAt.at;
+        if (latestEndedAt === undefined || endedAt > latestEndedAt) {
+            latestEndedAt = endedAt;
+        }
+    }
+    const lastActivityAt = latestEndedAt === undefined
+        ? { status: "absent" }
+        : { status: "present", at: latestEndedAt };
+    return { totalElapsedMs, lastActivityAt };
+}
+export async function buildAnalystIssueMetricsPage(input) {
+    // Discover before compose/write — missing family tree fails loud with native
+    // ENOENT/ENOTDIR (no empty-registry wash) and never emits a success page.
+    const families = await loadAnalystIssueMetricFamilies();
+    // Sole run→leg projection owner: page envelope maps typed runs to A1 legs.
+    const legs = sortLegs(input.runs.map((run) => ({
+        runId: run.runId,
+        book: run.book,
+        role: run.role,
+    })));
+    const unreadable = sortUnreadable(input.unreadable);
+    const scopeConflicts = sortScopeConflicts(input.scopeConflicts ?? []);
+    const projectRoot = physicalPathIdentity(input.projectRoot);
+    const { totalElapsedMs, lastActivityAt } = summarizeAnalystRunEfficiency(input.runs, unreadable);
+    const changedLines = normalizeAnalystChangedLines(input.changedLines);
+    const msPerKLines = computeAnalystMsPerKLines(totalElapsedMs, changedLines);
+    const envelope = {
+        kind: "analyst-issue-metrics",
+        mode: "issue",
+        bookKey: input.bookKey,
+        projectRoot,
+        // exactOptionalPropertyTypes: only materialize when caller supplied it.
+        ...(input.issueNumber === undefined ? {} : { issueNumber: input.issueNumber }),
+        ...(input.scopeRootIdentity === undefined
+            ? {}
+            : { scopeRootIdentity: physicalPathIdentity(input.scopeRootIdentity) }),
+        legs,
+        unreadable,
+        unreadableCount: unreadable.length,
+        scopeConflicts,
+        totalElapsedMs,
+        changedLines,
+        msPerKLines,
+        lastActivityAt,
+    };
+    const sections = composeAnalystMetricFamilySections(families, {
+        projectRoot,
+        runs: input.runs,
+        unreadable,
+    });
+    return { ...envelope, ...sections };
+}
+/**
+ * Atomically replace the issue metrics page (idempotent overwrite).
+ * Directory creation and file placement go through the ledger home physical
+ * containment owner (ADR 0038 / 0048) — never plain recursive mkdir alone.
+ */
+export async function writeAnalystIssueMetricsPage(ledgerHome, page) {
+    const path = analystIssuePagePath(ledgerHome, analystIssuePageAddressFromPage(page));
+    ensureRealDirectoryTree(ledgerHome, dirname(path));
+    assertLedgerFileInsideHome(path, ledgerHome);
+    await writeFileAtomically(path, `${JSON.stringify(page, null, 2)}\n`);
+    return path;
+}

package/dist/atomic-write.js

@@ -0,0 +1,23 @@
+/**
+ * Same-directory temp + rename atomic file replace.
+ * Shared primitive for ledger-adjacent typed pages (analyst metrics, etc.).
+ * Does not open/truncate an existing destination inode, so hard-linked twins
+ * keep prior bytes until the directory entry is swapped.
+ * Parent directory must already exist — callers that write under the package
+ * ledger home own confinement via ensureRealDirectoryTree (ADR 0038).
+ */
+import { randomUUID } from "node:crypto";
+import { rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export async function writeFileAtomically(destination, contents) {
+    const parent = dirname(destination);
+    const temporary = join(parent, `.atomic-write-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, contents);
+        await rename(temporary, destination);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}

package/dist/auditor-soul.js

@@ -40,7 +40,7 @@ export const AUDITOR_SESSION_MATERIALS = {
     doctor: ["CLAUDE.md", "souls/doctor-auditor.md"],
 };
 export function isAuditorSoulRole(value) {
-    return value === "judge" || value === "doctor";
+    return typeof value === "string" && Object.hasOwn(AUDITOR_SESSION_MATERIALS, value);
 }
 /** Resolve audited subject from explicit value or the subject-input env. */
 export function resolveAuditorSubject(raw) {

package/dist/countersign-contracts.js

@@ -1,5 +1,4 @@
 const COUNTERSIGN_OUTPUT_TOOL_NAME = "ak_countersign_output";
-const COUNTERSIGN_ACCEPTED_TEXT = "\u7ED9\u4E8B\u4E2D\u56DE\u6267\u5DF2\u63A5\u53D7";
 function validateRecordedCountersignOutput(verdict) {
   if (verdict === null || typeof verdict !== "object" || Array.isArray(verdict)) {
     throw new Error("Countersign verdict has no execution discriminator");
@@ -19,7 +18,6 @@ function validateRecordedCountersignOutput(verdict) {
   throw new Error("Countersign verdict has no execution discriminator");
 }
 export {
-  COUNTERSIGN_ACCEPTED_TEXT,
   COUNTERSIGN_OUTPUT_TOOL_NAME,
   validateRecordedCountersignOutput
 };

package/dist/diarist-contracts.js

@@ -9,7 +9,6 @@
 import { projectTicketProvenanceSessions, } from "./ticket-provenance-contracts.js";
 import { isSafePositiveTicketNumber, requireSafePositiveTicketNumber, } from "./run-ticket-number.js";
 export const DIARIST_OUTPUT_TOOL_NAME = "ak_diarist_output";
-export const DIARIST_ACCEPTED_TEXT = "起居郎回执已接受";
 /**
  * Sole shape projection for a typed co-review ticket set (#871).
  * Positive safe integers, first-seen order, duplicates dropped. Not content judgment.

package/dist/doctor-contracts.js

@@ -4,7 +4,7 @@ import { openToolObjectFromUnion } from "./open-tool-schema.js";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.js";
 const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
 const DOCTOR_OUTPUT_TOOL_NAME = "ak_doctor_output";
-const DOCTOR_ACCEPTED_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7";
+const DOCTOR_AUDIT_TOOL_NAME = "ak_doctor_audit_decision";
 const DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u65E0\u56DE\u6267";
 const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "\u63D0\u4EA4\u552F\u4E00\u7EC8\u5C40\u5355\u6848\u8BC1\u8BCD\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\u3002";
 const DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"];
@@ -116,7 +116,7 @@ function validateDoctorOutput(value, _patient, _store) {
 }
 export {
   DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT,
-  DOCTOR_ACCEPTED_TEXT,
+  DOCTOR_AUDIT_TOOL_NAME,
   DOCTOR_EVIDENCE_TOOL_NAME,
   DOCTOR_OUTPUT_TOOL_DESCRIPTION,
   DOCTOR_OUTPUT_TOOL_NAME,

package/dist/gatekeeper-role.js

@@ -1,4 +1,5 @@
 import { auditorRunDirectory } from "./auditor-dossier-tool.js";
+import { packagedGateDecision, packagedGateStageLabel } from "./packaged-role-registry.js";
 import { GatekeeperDecisionError } from "./submission-errors.js";
 import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.js";
 import { GATEKEEPER_OUTPUT_TOOL_NAME, gatekeeperDecisionSchema, gatekeeperOutputSchema, } from "./package-contracts/gatekeeper-output.js";
@@ -6,23 +7,19 @@ import { runIdFromRunDirectory } from "./run-terminal-artifacts.js";
 export const INSPECTOR_OUTPUT_TOOL = INSPECTOR_OUTPUT_TOOL_NAME;
 export const NOTARY_OUTPUT_TOOL = "ak_notary_output";
 function gateSeatLabel(stage) {
-    if (stage === "inspector")
-        return "台院";
-    if (stage === "auditor")
-        return "审刑院";
-    if (stage === "countersign")
-        return "给事中";
-    return "符宝郎";
+    return packagedGateStageLabel(stage) ?? stage;
 }
+/** Subject kind → review officer. One table; default is notary. */
+const GATE_OFFICER_BY_SUBJECT = {
+    worker_completion: "inspector",
+    judge_compliance: "auditor",
+    judge_draft: "notary",
+    countersign_verdict: "notary",
+    secretariat_verdict: "countersign",
+};
 /** Subject kind → review officer (#753 countersign/notary, #756 judge/auditor + worker/inspector, #969 secretariat/countersign). */
 export function gateOfficerForSubject(subject) {
-    if (subject.kind === "worker_completion")
-        return "inspector";
-    if (subject.kind === "judge_compliance")
-        return "auditor";
-    if (subject.kind === "secretariat_verdict")
-        return "countersign";
-    return "notary";
+    return GATE_OFFICER_BY_SUBJECT[subject.kind];
 }
 export { GatekeeperDecisionError } from "./submission-errors.js";
 /**
@@ -90,7 +87,7 @@ function projectOfficerDecision(officer, decision, fallbackStatus) {
     const record = readRecord(decision);
     // 给事中: only countersignStatus, strict three-word map; never generic status,
     // never unmapped raw word, never fallbackStatus (#969 / ADR 0040/0055).
-    if (officer === "countersign") {
+    if (packagedGateDecision(officer) === "countersign-status") {
         const countersignStatus = record !== undefined && typeof record.countersignStatus === "string"
             ? record.countersignStatus
             : undefined;
@@ -244,7 +241,9 @@ export const OFFICER_CONCLUSION_REASK = "上次交卷的结论不是 pass、boun
 export const COUNTERSIGN_CONCLUSION_REASK = "上次交卷的 countersignStatus 不是 converged、continue、escalate 三态之一。请重新输出，countersignStatus 写明其一；封驳或上呈的话就是给对方看的原文。";
 /** Pick the re-ask line for the officer under review. */
 export function officerConclusionReask(officer) {
-    return officer === "countersign" ? COUNTERSIGN_CONCLUSION_REASK : OFFICER_CONCLUSION_REASK;
+    return packagedGateDecision(officer) === "countersign-status"
+        ? COUNTERSIGN_CONCLUSION_REASK
+        : OFFICER_CONCLUSION_REASK;
 }
 /**
  * Summon (via injected seam) + project. Default summonGateOfficer drive lives

package/dist/gleaner-left-contracts.js

@@ -1,5 +1,4 @@
 const GLEANER_LEFT_OUTPUT_TOOL_NAME = "ak_gleaner_left_output";
-const GLEANER_LEFT_ACCEPTED_TEXT = "\u5DE6\u62FE\u9057\u56DE\u6267\u5DF2\u63A5\u53D7";
 const GLEANER_LEFT_BASE_FLAG = {
   name: "ak-gleaner-left-base",
   definition: {
@@ -23,7 +22,6 @@ function validateRecordedGleanerLeftOutput(value) {
   throw new Error("Gleaner-left output has no execution discriminator");
 }
 export {
-  GLEANER_LEFT_ACCEPTED_TEXT,
   GLEANER_LEFT_BASE_FLAG,
   GLEANER_LEFT_OUTPUT_TOOL_NAME,
   validateRecordedGleanerLeftOutput