@akagilnc/pi-workflow-roles 0.1.3644 → 0.1.3652

package/dist/public-role-summons.js

@@ -198,20 +198,6 @@ async function summonPublicRole(options) {
       );
       break;
     }
-    case "evidence-child": {
-      const [{ runPublicInstructionSeat }, { parseEvidenceChildArgv }] = await Promise.all([
-        import("./public-cli/instruction-seat-run.js"),
-        import("./public-cli/invocation.js")
-      ]);
-      result = await runPublicInstructionSeat(
-        options.argv,
-        env,
-        io,
-        "evidence-child",
-        parseEvidenceChildArgv
-      );
-      break;
-    }
     case "navigator": {
       const [{ runPublicInstructionSeat }, { parseNavigatorArgv }] = await Promise.all([
         import("./public-cli/instruction-seat-run.js"),

package/dist/reviewer-child-executor.js

@@ -1,4 +1,68 @@
-import { auditorRunDirectory } from "./auditor-dossier-tool.js";
+import { createEngineDetourToolDefinition } from "./engine-detour-tool.js";
+import { engineNameFromEnv } from "./engine-detour.js";
+import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, } from "./package-resources/engine-material.js";
+import { readPackageMaterial } from "./session-opening-materials.js";
+import { hasUpstreamErrorTestimony, isNonSuccessHttpStatus } from "./upstream-error-testimony.js";
+/** Path roster only — cadence prose stays in owner material (ADR 0073). */
+const AXIS_SUBSESSION_MATERIALS = ["souls/quality-law.md"];
+async function buildAxisSystemPrompt(engineMaterial) {
+    const materials = [];
+    for (const relativePath of AXIS_SUBSESSION_MATERIALS) {
+        materials.push(await readPackageMaterial(relativePath));
+    }
+    return appendEngineSessionMaterial(materials, engineMaterial).join("\n");
+}
+function classifiedError(error, evidenceChildFailure) {
+    const diagnostic = typeof error === "object" && error !== null && typeof error.errorMessage === "string"
+        ? error.errorMessage
+        : error === undefined ? "" : String(error);
+    const wrapped = error instanceof Error
+        ? error
+        : Object.assign(new Error(diagnostic, { cause: error }), { evidenceChildOriginal: error });
+    const classification = "evidenceChildFailure" in wrapped
+        ? wrapped.evidenceChildFailure
+        : evidenceChildFailure;
+    return Object.assign(wrapped, { evidenceChildFailure: classification });
+}
+/** Read envelope-projected testimony on an assistant/stop node — no private walker copy. */
+function nodeHasUpstreamTestimony(node) {
+    if (typeof node !== "object" || node === null)
+        return false;
+    const record = node;
+    const httpStatus = isNonSuccessHttpStatus(record.statusCode)
+        ? record.statusCode
+        : isNonSuccessHttpStatus(record.status)
+            ? record.status
+            : isNonSuccessHttpStatus(record.httpStatus)
+                ? record.httpStatus
+                : undefined;
+    const diagnostics = Array.isArray(record.diagnostics) && record.diagnostics.length > 0
+        ? record.diagnostics
+        : undefined;
+    return hasUpstreamErrorTestimony({
+        ...(httpStatus === undefined ? {} : { httpStatus }),
+        ...(diagnostics === undefined ? {} : { diagnostics }),
+    });
+}
+/** Parent seat model for the axis sub-session (pre-#675 parent-effective inheritance). Pi only. */
+async function parentSelection(context) {
+    const { toPiContext } = await import("./pi/adapter.js");
+    let pi;
+    try {
+        pi = toPiContext(context);
+    }
+    catch (error) {
+        throw classifiedError(new Error("Reviewer Standards/Spec sub-session requires pi host context (other hosts: subagent not in this ticket)", { cause: error }), "child");
+    }
+    if (pi.model === undefined) {
+        throw classifiedError(new Error("Reviewer axis sub-session requires parent model"), "child");
+    }
+    return {
+        provider: pi.model.provider,
+        model: pi.model.id,
+        ...(pi.thinkingLevel === undefined ? {} : { thinking: String(pi.thinkingLevel) }),
+    };
+}
 /**
  * Single conversion at the Reviewer adapter boundary: shared child classifications
  * become Reviewer failure classifications without a second error taxonomy.
@@ -12,39 +76,17 @@ export function projectSharedChildFailure(error) {
     }
     return error;
 }
-function failureClassification(cause) {
-    if (cause === "provider")
-        return "provider";
-    if (cause === "output"
-        || cause === "timeout"
-        || cause === "activation"
-        || cause === "session"
-        || cause === "unrecognized") {
-        return "child";
-    }
-    return "unknown";
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
 }
-function reportFromSummon(summoned) {
-    const outcome = summoned.terminal?.roleOutcome;
-    if (outcome === undefined) {
-        throw Object.assign(new Error(`Evidence-child public summon produced no terminal (exit ${summoned.exitCode})`), { evidenceChildFailure: "child" });
-    }
-    if (outcome.kind === "failure") {
-        throw Object.assign(new Error(outcome.diagnostic), {
-            evidenceChildFailure: failureClassification(outcome.cause),
-        });
-    }
-    if (outcome.kind === "accepted") {
-        // No field-presence reject (ADR 0055 / #675). Keep original accepted bytes:
-        // report key when present, otherwise the whole decisiveFacts body.
-        const facts = outcome.decisiveFacts;
-        if (Object.hasOwn(facts, "report"))
-            return facts.report;
-        return facts;
-    }
-    throw Object.assign(new Error("Evidence-child public summon returned no accepted report body"), { evidenceChildFailure: "child" });
-}
-/** Reviewer evidence leg via the public evidence-child activation path (#675). */
+/** Reviewer Standards/Spec leg via pi in-process sub-session (#744). */
 export async function executeReviewerChild(workspace, leg, context, options = {}) {
     try {
         if (options.signal?.aborted) {
@@ -52,47 +94,98 @@ export async function executeReviewerChild(workspace, leg, context, options = {}
                 evidenceChildFailure: "child",
             });
         }
-        const runDirectory = options.runDirectory ?? auditorRunDirectory(context);
-        const pointer = runDirectory === undefined
-            ? ""
-            : `\n卷宗指针：${runDirectory}`;
-        const argv = [`${String(leg.prompt)}${pointer}`];
-        const summon = options.summonEvidenceChild
-            ?? (async (nextArgv, childSignal) => {
-                const { summonPublicRole } = await import("./public-role-summons.js");
-                // Parent run home owns nested public seats; leg workspace cwd is a bare worktree.
-                let home;
-                if (runDirectory !== undefined) {
-                    const { homeFromRunDirectory } = await import("./activation-ledger-topology.js");
-                    // Hard path resolve: fail loud — no packageMachineHome fallback (#604 / #675).
-                    home = homeFromRunDirectory(runDirectory);
-                }
-                return summonPublicRole({
-                    role: "evidence-child",
-                    argv: nextArgv,
-                    cwd: workspace,
-                    ...(home === undefined ? {} : { home }),
-                    ...(options.packageRoot === undefined ? {} : { packageRoot: options.packageRoot }),
-                    ...(childSignal === undefined ? {} : { signal: childSignal }),
+        const signal = options.signal;
+        const selection = await parentSelection(context);
+        const { openPiInProcessSession } = await import("./pi/in-process-session.js");
+        const { createRecordSession } = await import("./archivist-record-entry.js");
+        const engineName = engineNameFromEnv();
+        const engineMaterial = engineName === undefined
+            ? undefined
+            : options.packageRoot === undefined || options.packageRoot.trim() === ""
+                ? Object.freeze({ name: engineName })
+                : engineSessionMaterialFromOptions({
+                    engine: engineName,
+                    packageRoot: options.packageRoot,
                 });
+        let engineDetourFailure;
+        const engineDetourTool = engineName === undefined
+            ? undefined
+            : createEngineDetourToolDefinition({
+                engineName,
+                fail(error) {
+                    engineDetourFailure ??= error instanceof Error ? error : new Error(String(error));
+                    throw engineDetourFailure;
+                },
             });
-        const summoned = await summon(argv, options.signal);
-        if (options.signal?.aborted) {
-            throw Object.assign(new DOMException("The operation was aborted.", "AbortError"), {
-                evidenceChildFailure: "child",
+        let opened;
+        try {
+            // No agentDir: envelope owns scratch via credentialScratchParent (ADR 0018).
+            opened = await openPiInProcessSession({
+                cwd: workspace,
+                selection,
+                systemPrompt: await buildAxisSystemPrompt(engineMaterial),
+                ...(options.credentialScratchParent === undefined
+                    ? {}
+                    : { credentialScratchParent: options.credentialScratchParent }),
+                ...(engineDetourTool === undefined
+                    ? {}
+                    : { customTools: [engineDetourTool] }),
+                sessionManager: createRecordSession({
+                    cwd: workspace,
+                    kind: "evidence-children",
+                    parent: context.sessionManager,
+                }),
+                ...(signal === undefined ? {} : { signal }),
+                label: "Reviewer axis sub-session",
             });
         }
-        const report = reportFromSummon(summoned);
-        const { usageFromPublicSummon } = await import("./session-assistant-usage.js");
-        // Real session usage when present; no session → token-zero without inventing cost.
-        const usage = (await usageFromPublicSummon(summoned)) ?? {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-        };
-        return { report, usage, prompt: leg.prompt };
+        catch (error) {
+            throw classifiedError(error, "provider");
+        }
+        const { handle } = opened;
+        try {
+            const delivered = leg.prompt;
+            let turnResult;
+            try {
+                turnResult = await handle.prompt(String(delivered));
+            }
+            catch (error) {
+                if (engineDetourFailure !== undefined) {
+                    throw classifiedError(engineDetourFailure, "child");
+                }
+                throw classifiedError(error, "provider");
+            }
+            if (engineDetourFailure !== undefined) {
+                throw classifiedError(engineDetourFailure, "child");
+            }
+            if (signal?.aborted)
+                throw new Error("Reviewer axis sub-session was cancelled");
+            const lastAssistant = turnResult.messages !== undefined
+                ? [...turnResult.messages].reverse().find((message) => typeof message === "object" && message !== null && message.role === "assistant")
+                : undefined;
+            if (turnResult.stopReason === "error" || turnResult.stopReason === "aborted"
+                || (typeof lastAssistant === "object" && lastAssistant !== null
+                    && (lastAssistant.stopReason === "error"
+                        || lastAssistant.stopReason === "aborted"))) {
+                const errMsg = turnResult.errorMessage
+                    ?? (typeof lastAssistant === "object" && lastAssistant !== null
+                        ? String(lastAssistant.errorMessage ?? "")
+                        : "");
+                // Envelope already attaches observed HTTP status onto error/aborted assistants.
+                const hasTestimony = nodeHasUpstreamTestimony(lastAssistant)
+                    || nodeHasUpstreamTestimony(opened.streamFailure);
+                throw classifiedError(new Error(errMsg, { cause: lastAssistant }), hasTestimony ? "provider" : "unknown");
+            }
+            const report = turnResult.text;
+            if (report.trim().length === 0) {
+                throw new Error("Reviewer axis sub-session returned a blank report");
+            }
+            const usage = turnResult.usage ?? emptyUsage();
+            return { report, usage, prompt: delivered };
+        }
+        finally {
+            await handle.close();
+        }
     }
     catch (error) {
         throw projectSharedChildFailure(error);

package/dist/reviewer-construction.js

@@ -18,7 +18,7 @@ export function reviewerAxisMethodAdapter(axis) {
     ].join("\n");
 }
 /**
- * Spec-only evidence-child material carrier for durable authority references.
+ * Spec-only axis material carrier for durable authority references.
  * Exact values preserved; no prose extraction and no Standards/parent injection.
  */
 export function reviewerAuthorityRefsMaterial(authorityRefs) {
@@ -72,7 +72,7 @@ export function constructReviewerDispatch(input) {
         : [{ axis: "standards" }];
     const legs = axes.map((x) => {
         const parts = [common, reviewerAxisMethodAdapter(x.axis)];
-        // Spec evidence-child only — never Standards or a parent replacement Spec leg.
+        // Spec axis only — never Standards or a parent replacement Spec leg.
         if (x.axis === "spec") {
             if (specFetchedMaterial !== undefined) {
                 parts.push(reviewerFetchedSpecMaterial(specFetchedMaterial));

package/dist/reviewer-role.js

@@ -0,0 +1,159 @@
+import { Type } from "typebox";
+import { openToolObjectFromUnion } from "./open-tool-schema.js";
+import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
+import {} from "./reviewer-construction.js";
+import { createReviewerDispatcher } from "./reviewer-dispatch.js";
+import { ReviewerDispatchExecutionError } from "./reviewer-agent.js";
+import { createReviewerExecutionLedger, projectAcceptedDispatch, projectReviewerDispatchOutcome } from "./reviewer-execution-ledger.js";
+import { assembleRuntimeReviewerReceipt } from "./reviewer-settlement.js";
+import { REVIEWER_ACCEPTED_TEXT, REVIEWER_OUTPUT_TOOL_NAME, validateReviewerIntent } from "./package-contracts/reviewer-output.js";
+export { REVIEWER_OUTPUT_TOOL_NAME };
+export const AGENT_TOOL_NAME = "Agent";
+const reviewerAmendmentsSchema = Type.Object({
+    standards: Type.Optional(Type.String({ description: "相对 Standards 子报告的增量：增 finding、撤回或事实更正" })),
+    spec: Type.Optional(Type.String({ description: "相对 Spec 子报告的增量：增 finding、撤回或事实更正" })),
+}, { additionalProperties: true, description: "相对子报告的可选轴增量；非替代报告。无增量的轴可省略。" });
+const reviewerOutputVariants = Type.Union([
+    Type.Object({
+        status: Type.Literal("completed", { description: "completed — 形状指引，非 schema 闸" }),
+        amendments: Type.Optional(reviewerAmendmentsSchema),
+    }, { additionalProperties: false }),
+    Type.Object({
+        status: Type.Literal("refused", { description: "refused — 形状指引，非 schema 闸" }),
+        diagnostic: Type.String({ minLength: 1, description: "拒绝诊断说明" }),
+        amendments: Type.Optional(reviewerAmendmentsSchema),
+    }, { additionalProperties: false }),
+]);
+export const reviewerOutputSchema = withInfrastructureFailureDeclaration(openToolObjectFromUnion(reviewerOutputVariants));
+/**
+ * Reviewer behavior runtime: label, soul, evidence tools, decision tool, projection.
+ * No flag registration/decoding and no agent_start prompt lifecycle (ADR 0018 / envelope).
+ * Reviewer-side 审刑院 gate retired (#495 S6 / 风闻奏事); accept on typed validate only.
+ */
+export function createReviewerRoleRuntime(pi, dependencies, hostActions) {
+    let soul;
+    let binding;
+    let reader;
+    let dispatcher;
+    let registered = false;
+    let fixedBaseRevision;
+    let acceptedDispatch;
+    const ledger = createReviewerExecutionLedger();
+    return {
+        async activate(_ctx, admitted) {
+            soul = (await dependencies.loadSoul()).trim();
+            if (!soul)
+                throw new Error("Reviewer soul is empty");
+            // Behavior layer receives frozen admitted inputs only — no pi.getFlag.
+            fixedBaseRevision = admitted.baseRevision;
+            const reviewScopeKeys = admitted.reviewScopeKeys;
+            const authorityRefs = admitted.authorityRefs;
+            const ticketNumber = admitted.ticketNumber;
+            const loaded = await dependencies.loadCanonicalSkillBinding("code-review");
+            if (loaded.name !== "code-review")
+                throw new Error("Canonical Skill binding loader returned tdd for code-review");
+            binding = loaded;
+            reader = await dependencies.createPinnedGitReader();
+            acceptedDispatch = undefined;
+            const executeAndProjectDispatch = async (execution, invocation) => {
+                const dispatch = acceptedDispatch;
+                if (dispatch === undefined || dispatch.identity !== execution.identity)
+                    throw new Error("Reviewer execution lacks accepted construction evidence");
+                const { context, signal } = invocation;
+                ledger.append({ source: "reviewer-agent", type: "dispatch-started", dispatchIdentity: execution.identity, cardinality: execution.legs.length });
+                try {
+                    const result = await dependencies.runDispatch(execution, { context, ...(signal === undefined ? {} : { signal }) });
+                    projectReviewerDispatchOutcome(ledger, dispatch, result);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof ReviewerDispatchExecutionError) {
+                        try {
+                            projectReviewerDispatchOutcome(ledger, dispatch, error.outcome);
+                        }
+                        catch (mismatch) {
+                            throw ledger.recordInfrastructureFailure(mismatch);
+                        }
+                        throw error;
+                    }
+                    throw ledger.recordInfrastructureFailure(error);
+                }
+            };
+            dispatcher = createReviewerDispatcher({
+                canonicalSkill: binding.snapshot.raw,
+                reader,
+                ...(reviewScopeKeys === undefined ? {} : { reviewScopeKeys }),
+                ...(authorityRefs === undefined ? {} : { authorityRefs }),
+                ...(ticketNumber === undefined ? {} : { ticketNumber }),
+                ...(dependencies.fetchIssue === undefined ? {} : { fetchIssue: dependencies.fetchIssue }),
+                decisionEvidence(decision) {
+                    try {
+                        if (decision.disposition === "accepted") {
+                            ledger.append(projectAcceptedDispatch(decision.dispatch));
+                            acceptedDispatch = decision.dispatch;
+                        }
+                        else
+                            ledger.append({ source: "reviewer-dispatch", type: "rejected", identity: decision.identity, violations: decision.violations, started: false });
+                    }
+                    catch (error) {
+                        throw ledger.recordInfrastructureFailure(error);
+                    }
+                },
+                run: executeAndProjectDispatch,
+            });
+            if (!registered) {
+                registered = true;
+                pi.registerTool({ name: REVIEWER_OUTPUT_TOOL_NAME, label: "御史台输出", description: "Standards/Spec 评审腿由 runtime 以取证子会话代跑，本席收腿报告后交薄回执。", promptSnippet: "提交御史台终局回执", parameters: reviewerOutputSchema,
+                    async execute(id, parameters, _signal, _update, toolCtx) {
+                        if (!soul || !binding)
+                            throw new Error("御史台输入未装载");
+                        const output = validateReviewerIntent(parameters);
+                        let record;
+                        try {
+                            record = ledger.recordForAudit(output.status);
+                        }
+                        catch (error) {
+                            if (error?.fatalReviewerInfrastructure)
+                                hostActions.failInfrastructure(error, toolCtx, id);
+                            throw error;
+                        }
+                        const candidate = assembleRuntimeReviewerReceipt({
+                            intent: output,
+                            record,
+                            canonicalSkillText: binding.snapshot.raw,
+                        });
+                        try {
+                            await dependencies.shutdownAgent?.();
+                        }
+                        catch (error) {
+                            hostActions.failInfrastructure(ledger.recordInfrastructureFailure(error), toolCtx, id);
+                        }
+                        return {
+                            content: [{ type: "text", text: REVIEWER_ACCEPTED_TEXT }],
+                            details: candidate,
+                            terminate: true,
+                        };
+                    } });
+                // Skill invocation transform + agent_start expansion/prompt lifecycle: shared envelope (ADR 0018).
+                pi.on("session_shutdown", async () => { try {
+                    await dependencies.shutdownAgent?.();
+                }
+                catch (error) {
+                    throw ledger.recordInfrastructureFailure(error);
+                } });
+            }
+            const activatedSoul = soul;
+            const activatedBase = fixedBaseRevision;
+            const activatedBinding = binding;
+            return Object.freeze({
+                dispatcher,
+                fixedBaseRevision: activatedBase,
+                soul: activatedSoul,
+                skillBinding: activatedBinding,
+                getSpecDisposition() {
+                    return acceptedDispatch?.specDisposition;
+                },
+            });
+        },
+    };
+}

package/dist/reviewer-settlement.js

@@ -0,0 +1,66 @@
+function freeze(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(freeze));
+    if (value !== null && typeof value === "object")
+        return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)])));
+    return value;
+}
+function receiptPrompt(prompt) {
+    return Object.freeze({ text: prompt });
+}
+export function assembleRuntimeReviewerReceipt(input) {
+    const reports = {};
+    const outcomes = {};
+    for (const axis of ["standards", "spec"]) {
+        const result = input.record.results[axis];
+        if (result === undefined)
+            continue;
+        if (result.status === "successful") {
+            outcomes[axis] = {
+                status: "successful",
+                prompt: receiptPrompt(result.prompt),
+                workspaceDisposition: result.workspaceDisposition,
+            };
+            reports[axis] = { text: result.report };
+        }
+        else {
+            outcomes[axis] = {
+                status: "failed",
+                prompt: receiptPrompt(result.prompt),
+                workspaceDisposition: result.workspaceDisposition,
+                failure: result.failure,
+                diagnostic: result.diagnostic,
+            };
+        }
+    }
+    const accepted = input.record.accepted;
+    const skillText = accepted?.input.canonicalSkill ?? input.canonicalSkillText;
+    // Seat-owned amendments sit beside reports; never rewrite runtime-owned child bytes.
+    const amendments = input.intent.amendments;
+    return freeze({
+        version: 2,
+        status: input.intent.status,
+        ...(input.intent.status === "refused" ? { diagnostic: input.intent.diagnostic } : {}),
+        ...(accepted === undefined ? {} : {
+            acceptedBatch: {
+                identity: accepted.identity,
+                legs: accepted.legs.map(({ axis, prompt }) => ({ axis, prompt: receiptPrompt(prompt) })),
+            },
+            // Honest Spec skipped/missing notation when independent discovery confirmed absence.
+            ...(accepted.specDisposition === undefined
+                ? {}
+                : { specDisposition: accepted.specDisposition }),
+            // Self-fetch bytes + source annotation retained for audit (#343 fetch-then-store).
+            ...(accepted.specFetchedMaterial === undefined
+                ? {}
+                : { specFetchedMaterial: accepted.specFetchedMaterial }),
+        }),
+        reports,
+        ...(amendments === undefined ? {} : { amendments }),
+        outcomes,
+        identities: {
+            canonicalSkill: { text: skillText },
+            ...(accepted === undefined ? {} : { construction: { recipe: accepted.recipe }, target: accepted.target }),
+        },
+    });
+}