@akagilnc/pi-workflow-roles 0.1.5406 → 0.1.5475

package/dist/collector-tool-schemas.js

@@ -3,7 +3,7 @@ import { openToolObject } from "./open-tool-schema.js";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.js";
 /**
  * #1088: LLM gathers evidence via host CLI and submits the receipt.
- * Field declarations guide the model — host must not pure-shape-reject (第 0 条 / ADR 0057).
+ * Field declarations guide the model — host must not pure-shape-reject (仓内 CLAUDE.md 开篇 / ADR 0057).
  * Presence of `groups` remains the Collector terminal discriminator for settlement/analyst.
  */
 export const collectorOutputBaseSchema = openToolObject(Type.Object({

package/dist/compliance-transport.js

@@ -1,7 +1,7 @@
 import { auditorRunDirectory } from "./auditor-dossier-tool.js";
 import { officerConclusionReask } from "./gatekeeper-role.js";
 import { receivedDiscriminator } from "./submission-errors.js";
-import { coalesceSubmissionRows } from "./public-cli/terminal.js";
+import { currentReplyRows } from "./public-cli/terminal.js";
 import { readableGateItem } from "./readable-gate-item.js";
 import { deliveryLimitFromConfig } from "./receipt-delivery-policy.js";
 import { isRecord } from "./unknown-value.js";
@@ -78,10 +78,7 @@ async function projectAuditorTerminal(summoned) {
     };
   }
   if (outcome.kind === "accepted") {
-    const rows = coalesceSubmissionRows(
-      outcome.payloads,
-      summoned.terminal?.submissions
-    );
+    const rows = currentReplyRows(summoned.terminal);
     if (rows.length === 0) {
       return readComplianceCandidate({}, usage);
     }

package/dist/engine-detour-usage.js

@@ -27,8 +27,8 @@ export const ENGINE_DETOUR_CALL_KIND = "engine-detour-call";
 export const ENGINE_DETOUR_TOOL_USAGE_FACT_KEY = "engineDetourToolUsage";
 /**
  * Run-relative sitian volume path for one detour call.
- * Openable once the run directory is known (resume.command / top-level runId);
- * contains no runId bytes itself (#108 + #537 AC8).
+ * Openable once the run directory is known from the terminal's run id.
+ * Contains no runId bytes itself (#108 + #537).
  */
 export const ENGINE_DETOUR_CALL_RECORD_FILE_RELATIVE = `session/${ENGINE_DETOUR_CALL_KIND}/records.jsonl`;
 /** stdout UTF-8 byte length (ticket-frozen metric; empty stdout is real 0). */
@@ -167,7 +167,7 @@ export async function readEngineDetourToolUsage(input) {
         }
         const pointer = {
             identity: record.identity,
-            recordFile,
+            recordFile: ENGINE_DETOUR_CALL_RECORD_FILE_RELATIVE,
             kind: record.kind,
             level: record.level,
         };
@@ -180,33 +180,6 @@ export async function readEngineDetourToolUsage(input) {
     const calls = Array.from(callsByToolCallId.values());
     return { callCount: calls.length, calls };
 }
-/**
- * Project usage onto the public Terminal face.
- * Non-resumable: keep absolute recordFile (runId already public via top-level runId).
- * Resumable: keep an openable run-relative recordFile and identity with no runId
- * bytes (#108 single disclosure + #537 AC8 reopen).
- */
-export function projectEngineDetourToolUsageForPublicTerminal(usage, options) {
-    if (options.discloseRecordFile)
-        return usage;
-    return {
-        callCount: usage.callCount,
-        calls: usage.calls.map((call) => ({
-            toolCallId: call.toolCallId,
-            durationMs: call.durationMs,
-            ...(call.code === undefined ? {} : { code: call.code }),
-            ...(call.stdoutByteLength === undefined
-                ? {}
-                : { stdoutByteLength: call.stdoutByteLength }),
-            recordPointer: {
-                identity: call.recordPointer.identity,
-                kind: call.recordPointer.kind,
-                level: call.recordPointer.level,
-                recordFile: ENGINE_DETOUR_CALL_RECORD_FILE_RELATIVE,
-            },
-        })),
-    };
-}
 /** One shared invocation.json reader (ENOENT → undefined; other errors propagate). */
 function readInvocationRecord(runDirectory) {
     try {

package/dist/gatekeeper-role.js

@@ -5,8 +5,10 @@ import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.js";
 import { REVIEW_QUEUE_STATUSES, REVIEW_SUBMISSION_OUTPUT_TOOL_NAME } from "./review-submission.js";
 import { GATEKEEPER_OUTPUT_TOOL_NAME } from "./package-contracts/gatekeeper-output.js";
 import { roleSubmissionDeclaration } from "./role-submission-declarations.js";
+import { currentReplyRows } from "./public-cli/terminal.js";
 import { runIdFromRunDirectory } from "./run-terminal-artifacts.js";
 import { isRecord } from "./unknown-value.js";
+import { serializeThrownValue } from "./serialize-thrown-value.js";
 export const INSPECTOR_OUTPUT_TOOL = INSPECTOR_OUTPUT_TOOL_NAME;
 export const NOTARY_OUTPUT_TOOL = REVIEW_SUBMISSION_OUTPUT_TOOL_NAME;
 function gateSeatLabel(stage) {
@@ -31,11 +33,6 @@ export { GatekeeperDecisionError } from "./submission-errors.js";
  * the shared contract module (with infrastructure-failure declaration).
  */
 export const GATEKEEPER_TOOL_SPEC = roleSubmissionDeclaration("gatekeeper");
-function failureReason(error) {
-    if (error instanceof AggregateError)
-        return error.errors.map(failureReason).join("; ");
-    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-}
 /** Original decision bytes — no sentinel replacement (#836). */
 function retainedReceipt(decision) {
     return decision;
@@ -72,17 +69,6 @@ function projectOfficerDecision(officer, decision, fallbackStatus) {
  * identity. Never guess from undivided submissions — sole row included — history
  * stays on terminal.submissions (#836 presentation).
  */
-function thisCourtOfficerPayloads(terminal) {
-    const outcome = terminal?.roleOutcome;
-    // This-court identity only from accepted/audit_escalation settlement payloads
-    // (#879). Failure history is not this-court (#953) — it rides submissions.
-    if (outcome !== undefined && (outcome.kind === "accepted" || outcome.kind === "audit_escalation")) {
-        if (outcome.payloads !== undefined && outcome.payloads.length > 0)
-            return outcome.payloads;
-    }
-    // No sole-row identity guess: undivided submissions are not this-court (#879).
-    return [];
-}
 /**
  * Failure/transport channel surfaces recorded history beside the failure
  * (#836 A.3) via the historical carrier only (#953 — not failure.payloads).
@@ -130,7 +116,7 @@ function withOfficerRunId(result, summoned) {
 function projectOfficerTerminal(officer, summoned) {
     const terminal = summoned.terminal;
     const outcome = terminal?.roleOutcome;
-    const thisCourt = thisCourtOfficerPayloads(terminal);
+    const thisCourt = currentReplyRows(terminal);
     if (outcome === undefined) {
         const detail = summoned.stderr ?? "";
         const failurePayloads = officerFailurePayloads(terminal);
@@ -221,7 +207,7 @@ export async function projectGatekeeperRun(options) {
     catch (error) {
         return {
             officer,
-            result: { status: "transport_failure", stage: officer, reason: failureReason(error) },
+            result: { status: "transport_failure", stage: officer, reason: serializeThrownValue(error) },
         };
     }
     return {

package/dist/headless-host/description.js

@@ -54,215 +54,6 @@ function codexTomlStringTable(entries) {
     const parts = Object.entries(entries).map(([key, value]) => `${key}=${codexTomlString(value)}`);
     return `{${parts.join(",")}}`;
 }
-/**
- * Free-form JSON leaf for Type.Unknown under Codex strict transport.
- * Strict rejects bare untyped nodes and root-level additionalProperties:true;
- * a $defs anyOf of JSON values (with nested additionalProperties as $ref)
- * is accepted and keeps array/object receipts expressible.
- * Package code still does not validate or reject the receipt against schema.
- */
-const CODEX_JSON_VALUE_DEF = "codexJsonValue";
-const CODEX_JSON_VALUE_REF = `#/$defs/${CODEX_JSON_VALUE_DEF}`;
-const CODEX_JSON_VALUE_SCHEMA = Object.freeze({
-    anyOf: Object.freeze([
-        Object.freeze({ type: "string" }),
-        Object.freeze({ type: "number" }),
-        Object.freeze({ type: "boolean" }),
-        Object.freeze({ type: "null" }),
-        Object.freeze({ type: "array", items: Object.freeze({ $ref: CODEX_JSON_VALUE_REF }) }),
-        Object.freeze({
-            type: "object",
-            properties: Object.freeze({}),
-            required: Object.freeze([]),
-            additionalProperties: Object.freeze({ $ref: CODEX_JSON_VALUE_REF }),
-        }),
-    ]),
-});
-/**
- * Derive a Codex/OpenAI-strict transport schema from the package open schema.
- * Legal open schema is untouched; this is a host-only transmission projection
- * (#646 / 0057 法意 / 0054 strict): every object closes, every property is
- * required, and only originally-optional fields become a null union (official
- * guidance: emulate optional via type|null). Originally-required fields stay
- * non-nullable. Nested open-tool anyOf wrappers are flattened so every branch
- * carries `type`. Type.Unknown / description-only leaves become a free JSON
- * $ref. Package code still does not validate or reject the receipt.
- */
-export function closeJsonSchemaForCodex(schema) {
-    const closed = closeSchemaNode(schema);
-    const existingDefs = isRecord(closed.$defs)
-        ? closed.$defs
-        : {};
-    return {
-        ...closed,
-        $defs: {
-            ...existingDefs,
-            [CODEX_JSON_VALUE_DEF]: CODEX_JSON_VALUE_SCHEMA,
-        },
-    };
-}
-/** Pure null leaf only — composite type|null is stripped in-leaf, not dropped whole. */
-function isPureNullTypeSchema(value) {
-    if (!isRecord(value))
-        return false;
-    if (value.type === "null")
-        return true;
-    if (Array.isArray(value.type) && value.type.length > 0 && value.type.every((t) => t === "null")) {
-        return true;
-    }
-    return false;
-}
-/**
- * Within a leaf, remove null members from type arrays.
- * Required edges keep the non-null type(s); optional edges re-add null once.
- */
-function stripNullFromLeafType(leaf) {
-    if (!isRecord(leaf) || !Array.isArray(leaf.type))
-        return leaf;
-    const nonNull = leaf.type.filter((t) => t !== "null");
-    if (nonNull.length === leaf.type.length)
-        return leaf;
-    if (nonNull.length === 0)
-        return { ...leaf, type: "null" };
-    if (nonNull.length === 1)
-        return { ...leaf, type: nonNull[0] };
-    return { ...leaf, type: nonNull };
-}
-/**
- * Flatten nested anyOf wrappers into concrete leaf schemas.
- * Open-tool unions often wrap leaves in description-only anyOf shells that
- * lack `type`; strict structured output rejects those intermediate nodes.
- */
-function flattenUnionLeaves(schema) {
-    if (!isRecord(schema))
-        return [schema];
-    if (Array.isArray(schema.anyOf)) {
-        return schema.anyOf.flatMap(flattenUnionLeaves);
-    }
-    return [schema];
-}
-/** Drop pure-null leaves after in-leaf null stripping; optional edges re-add null once. */
-function nonNullLeaves(schema) {
-    return flattenUnionLeaves(schema)
-        .map(stripNullFromLeafType)
-        .filter((leaf) => !isPureNullTypeSchema(leaf));
-}
-/**
- * Property edge under strict transport.
- * Required → closed non-null leaf(s). Optional → closed leaf(s) + null.
- */
-function closePropertySchema(schema, optional) {
-    const description = isRecord(schema) && typeof schema.description === "string"
-        ? { description: schema.description }
-        : {};
-    const leaves = nonNullLeaves(schema).map(closeSchemaNode);
-    if (leaves.length === 0)
-        return { type: "null", ...description };
-    if (!optional) {
-        const closed = leaves.length === 1 ? leaves[0] : { anyOf: leaves };
-        // Codex strict does not allow sibling keys on $ref; put property guidance
-        // on an enclosing schema instead of losing it or weakening the free-JSON ref.
-        if (isRecord(closed) && typeof closed.$ref === "string") {
-            return { anyOf: [closed], ...description };
-        }
-        return isRecord(closed) ? { ...closed, ...description } : closed;
-    }
-    return { anyOf: [...leaves, { type: "null" }], ...description };
-}
-/**
- * Strict generators require every schema node to declare `type` (or a $ref).
- * Type.Unknown / description-only leaves → free JSON $ref (not string): array
- * and object receipts stay expressible under --output-schema.
- */
-function ensureTypedLeaf(schema) {
-    if (schema.type !== undefined)
-        return schema;
-    if (typeof schema.$ref === "string")
-        return schema;
-    if (isRecord(schema.properties) || schema.additionalProperties !== undefined) {
-        return { ...schema, type: "object" };
-    }
-    if (schema.items !== undefined) {
-        return { ...schema, type: "array" };
-    }
-    if (schema.const !== undefined) {
-        const value = schema.const;
-        if (value === null)
-            return { ...schema, type: "null" };
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-            return { ...schema, type: typeof value };
-        }
-    }
-    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
-        const sample = schema.enum.find((item) => item !== null);
-        if (typeof sample === "string" || typeof sample === "number" || typeof sample === "boolean") {
-            return { ...schema, type: typeof sample };
-        }
-    }
-    // Free JSON via $defs. $ref must stand alone (strict rejects sibling keys).
-    return { $ref: CODEX_JSON_VALUE_REF };
-}
-function originalRequiredNames(node) {
-    if (!Array.isArray(node.required))
-        return new Set();
-    return new Set(node.required.filter((item) => typeof item === "string"));
-}
-function closeSchemaNode(node) {
-    if (!isRecord(node))
-        return node;
-    // Already a ref (free-JSON leaf or pre-existing) — do not retype.
-    if (typeof node.$ref === "string")
-        return node;
-    // Union node: flatten then close each concrete leaf (do not keep untyped shells).
-    if (Array.isArray(node.anyOf)) {
-        const leaves = nonNullLeaves(node).map(closeSchemaNode);
-        if (leaves.length === 0)
-            return { type: "null" };
-        if (leaves.length === 1)
-            return leaves[0];
-        return { anyOf: leaves };
-    }
-    let out = { ...node };
-    if (node.items !== undefined) {
-        out.items = closeSchemaNode(node.items);
-    }
-    if (isRecord(node.$defs)) {
-        out.$defs = Object.fromEntries(Object.entries(node.$defs).map(([key, value]) => [key, closeSchemaNode(value)]));
-    }
-    const hasProperties = isRecord(node.properties);
-    const isObjectType = node.type === "object"
-        || (Array.isArray(node.type) && node.type.includes("object"))
-        || hasProperties
-        || node.additionalProperties !== undefined;
-    if (hasProperties) {
-        const props = node.properties;
-        const wasRequired = originalRequiredNames(node);
-        const closedProps = {};
-        const required = [];
-        for (const [name, propSchema] of Object.entries(props)) {
-            required.push(name);
-            closedProps[name] = closePropertySchema(propSchema, !wasRequired.has(name));
-        }
-        out.properties = closedProps;
-        out.required = required;
-        out.additionalProperties = false;
-        if (out.type === undefined)
-            out.type = "object";
-        // Object nodes must not also carry residual anyOf from the open copy.
-        delete out.anyOf;
-    }
-    else if (isObjectType) {
-        out.additionalProperties = false;
-        if (!Array.isArray(out.required))
-            out.required = [];
-        if (out.type === undefined)
-            out.type = "object";
-    }
-    else {
-        out = ensureTypedLeaf(out);
-    }
-    return out;
-}
 /**
  * Project shared-envelope MCP rows into `codex -c mcp_servers.<name>.*` argv pairs.
  * Dot-path + TOML values per official config-advanced; spawn argv (no shell).