@akagilnc/pi-workflow-roles 0.1.1751

package/dist/navigator-invocation-identity.js

@@ -0,0 +1,220 @@
+import { PACKAGED_ROLE_REGISTRY } from "./packaged-role-registry.js";
+import { isUuidV7, uuidv7 } from "./uuidv7.js";
+import { workSubjectKeysEqual } from "./work-subject-identity.js";
+const NAVIGATOR_INVOCATION_ENTRY = "ak-navigator-invocation";
+const NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND = "role_infrastructure_failure";
+const NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS = [
+  "kind",
+  "source",
+  "reasonCode"
+];
+function buildNavigatorInfrastructureFailureFact() {
+  return {
+    kind: NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND,
+    source: "shared-role-lifecycle",
+    reasonCode: "host_failure"
+  };
+}
+function isNavigatorInfrastructureFailureFact(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  const keys = Object.keys(record);
+  if (keys.length !== NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS.length) return false;
+  for (const key of NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS) {
+    if (!Object.hasOwn(record, key)) return false;
+  }
+  return record.kind === NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND && record.source === "shared-role-lifecycle" && record.reasonCode === "host_failure";
+}
+const PACKAGED_ROLE_OUTPUT_TOOLS = new Map(
+  PACKAGED_ROLE_REGISTRY.map((entry) => [entry.outputTool, entry.role])
+);
+function mintNavigatorInvocationId() {
+  return uuidv7();
+}
+function invocationPhaseFromUnknown(value) {
+  if (value === null || value === "plan" || value === "apply") return value;
+  return void 0;
+}
+function parseInvocationMarkerIdentity(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return void 0;
+  const record = data;
+  const invocationId = record.invocationId;
+  if (typeof invocationId !== "string") return void 0;
+  const trimmedId = invocationId.trim();
+  if (!isUuidV7(trimmedId)) return void 0;
+  if (typeof record.role !== "string" || record.role.trim() === "") return void 0;
+  const phase = invocationPhaseFromUnknown(record.phase);
+  if (phase === void 0) return void 0;
+  if (typeof record.subjectKey !== "string" || record.subjectKey.trim() === "") return void 0;
+  return {
+    invocationId: trimmedId,
+    role: record.role,
+    phase,
+    subjectKey: record.subjectKey
+  };
+}
+function markerMatchesExpectedIdentity(marker, expected) {
+  if (marker.role !== expected.role) return false;
+  if (expected.phase !== void 0) {
+    if (marker.phase !== expected.phase) return false;
+  } else if (expected.allowedPhases !== void 0) {
+    if (!expected.allowedPhases.includes(marker.phase)) return false;
+  }
+  if (expected.subjectKey !== void 0) {
+    if (!workSubjectKeysEqual(marker.subjectKey, expected.subjectKey)) return false;
+  }
+  return true;
+}
+function classifyPackagedRoleTerminalResult(message) {
+  if (typeof message.toolName !== "string") return { kind: "nonterminal" };
+  if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName)) return { kind: "nonterminal" };
+  const infraFact = isNavigatorInfrastructureFailureFact(message.details) ? message.details : void 0;
+  if (message.isError === true) {
+    if (infraFact === void 0) return { kind: "nonterminal" };
+    return { kind: "infrastructure", fact: infraFact };
+  }
+  if (message.isError === false) {
+    if (infraFact !== void 0) return { kind: "nonterminal" };
+    return { kind: "accepted" };
+  }
+  return { kind: "nonterminal" };
+}
+function isDurablePackagedRoleTerminalResult(message) {
+  const classification = classifyPackagedRoleTerminalResult(message);
+  return classification.kind === "accepted" || classification.kind === "infrastructure";
+}
+function isAcceptedPackagedRoleTerminalResult(message) {
+  return classifyPackagedRoleTerminalResult(message).kind === "accepted";
+}
+function durableTerminalAt(entries, index) {
+  const entry = entries[index];
+  if (entry?.type !== "message") return void 0;
+  const message = entry.message;
+  if (message?.role !== "toolResult") return void 0;
+  if (typeof message.toolName !== "string") return void 0;
+  const role = PACKAGED_ROLE_OUTPUT_TOOLS.get(message.toolName);
+  if (role === void 0) return void 0;
+  const classification = classifyPackagedRoleTerminalResult(message);
+  if (classification.kind !== "accepted" && classification.kind !== "infrastructure") {
+    return void 0;
+  }
+  return {
+    index,
+    role,
+    toolName: message.toolName,
+    classification: classification.kind,
+    message
+  };
+}
+function isPackagedRoleTerminalEntry(entry) {
+  if (entry?.type !== "message") return false;
+  const message = entry.message;
+  if (message?.role !== "toolResult") return false;
+  return isDurablePackagedRoleTerminalResult(message);
+}
+function isInvocationMarkerEntry(entry) {
+  return entry?.type === "custom" && entry.customType === NAVIGATOR_INVOCATION_ENTRY;
+}
+function latestInvocationMarkerIndex(entries) {
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    if (isInvocationMarkerEntry(entries[i])) return i;
+  }
+  return -1;
+}
+function findLatestDurablePackagedRoleTerminal(entries) {
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const terminal = durableTerminalAt(entries, i);
+    if (terminal !== void 0) return terminal;
+  }
+  return void 0;
+}
+function bindCurrentDurableTerminalToMarker(entries) {
+  const terminal = findLatestDurablePackagedRoleTerminal(entries);
+  if (terminal === void 0) return { kind: "absent" };
+  let markerIndex = -1;
+  for (let i = terminal.index - 1; i >= 0; i -= 1) {
+    if (isInvocationMarkerEntry(entries[i])) {
+      markerIndex = i;
+      break;
+    }
+  }
+  if (markerIndex < 0) {
+    return { kind: "unbound", terminal };
+  }
+  const marker = parseInvocationMarkerIdentity(entries[markerIndex]?.data);
+  if (marker === void 0) {
+    return { kind: "unbound", terminal };
+  }
+  let windowEnd = entries.length;
+  for (let i = markerIndex + 1; i < entries.length; i += 1) {
+    if (isInvocationMarkerEntry(entries[i])) {
+      windowEnd = i;
+      break;
+    }
+  }
+  let durableCount = 0;
+  for (let i = markerIndex + 1; i < windowEnd; i += 1) {
+    if (durableTerminalAt(entries, i) !== void 0) durableCount += 1;
+  }
+  if (durableCount !== 1) return { kind: "ambiguous" };
+  if (terminal.index <= markerIndex || terminal.index >= windowEnd) {
+    return { kind: "ambiguous" };
+  }
+  return {
+    kind: "bound",
+    terminal,
+    marker: { ...marker, index: markerIndex }
+  };
+}
+function isReceiptSettlementBindingClear(entries) {
+  return bindCurrentDurableTerminalToMarker(entries).kind !== "ambiguous";
+}
+function resolveLifecycleInvocationPrincipal(entries, expected) {
+  const markerIndex = latestInvocationMarkerIndex(entries);
+  if (markerIndex < 0) {
+    return { invocationId: mintNavigatorInvocationId(), resume: false };
+  }
+  const marker = parseInvocationMarkerIdentity(entries[markerIndex]?.data);
+  if (marker === void 0) {
+    return { invocationId: mintNavigatorInvocationId(), resume: false };
+  }
+  if (expected !== void 0 && !markerMatchesExpectedIdentity(marker, expected)) {
+    return { invocationId: mintNavigatorInvocationId(), resume: false };
+  }
+  for (let i = markerIndex + 1; i < entries.length; i += 1) {
+    if (isPackagedRoleTerminalEntry(entries[i])) {
+      return { invocationId: mintNavigatorInvocationId(), resume: false };
+    }
+  }
+  return { invocationId: marker.invocationId, resume: true };
+}
+function currentInvocationPrincipalFromSession(entries, beforeIndex = entries.length) {
+  return currentInvocationMarkerFromSession(entries, beforeIndex)?.invocationId;
+}
+function currentInvocationMarkerFromSession(entries, beforeIndex = entries.length) {
+  const limit = Math.min(Math.max(beforeIndex, 0), entries.length);
+  for (let i = limit - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (!isInvocationMarkerEntry(entry)) continue;
+    return parseInvocationMarkerIdentity(entry?.data);
+  }
+  return void 0;
+}
+export {
+  NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND,
+  NAVIGATOR_INVOCATION_ENTRY,
+  bindCurrentDurableTerminalToMarker,
+  buildNavigatorInfrastructureFailureFact,
+  classifyPackagedRoleTerminalResult,
+  currentInvocationMarkerFromSession,
+  currentInvocationPrincipalFromSession,
+  findLatestDurablePackagedRoleTerminal,
+  isAcceptedPackagedRoleTerminalResult,
+  isDurablePackagedRoleTerminalResult,
+  isNavigatorInfrastructureFailureFact,
+  isReceiptSettlementBindingClear,
+  markerMatchesExpectedIdentity,
+  mintNavigatorInvocationId,
+  parseInvocationMarkerIdentity,
+  resolveLifecycleInvocationPrincipal
+};

package/dist/open-tool-schema.js

@@ -0,0 +1,39 @@
+import { Type } from "typebox";
+function described(name, schema) {
+    if (typeof schema.description === "string")
+        return schema;
+    throw new Error(`Tool field ${name} has no semantic description at its schema owner`);
+}
+function declarationIdentity(schema) {
+    const { description: _description, ...semantic } = schema;
+    return JSON.stringify(semantic);
+}
+/** Collapse transport variants into one provider-compatible, zero-required open object. */
+export function openToolObjectFromUnion(schema) {
+    const declarations = new Map();
+    for (const variant of schema.anyOf) {
+        for (const [name, declaration] of Object.entries(variant.properties ?? {})) {
+            const entries = declarations.get(name) ?? [];
+            const identity = declarationIdentity(declaration);
+            if (!entries.some((entry) => declarationIdentity(entry) === identity))
+                entries.push(declaration);
+            declarations.set(name, entries);
+        }
+    }
+    const properties = Object.fromEntries([...declarations].map(([name, entries]) => {
+        const descriptions = [...new Set(entries.map((entry) => entry.description).filter((value) => typeof value === "string"))].join(" ");
+        const declaration = entries.length === 1
+            ? entries[0]
+            : Type.Union(entries, descriptions === "" ? {} : { description: descriptions });
+        return [name, Type.Optional(described(name, declaration))];
+    }));
+    const object = Type.Object(properties, { additionalProperties: true });
+    object.required = [];
+    return object;
+}
+/** Open a pre-existing object transport schema without changing declarations. */
+export function openToolObject(schema) {
+    const object = Type.Object(Object.fromEntries(Object.entries(schema.properties).map(([name, declaration]) => [name, Type.Optional(described(name, declaration))])), { additionalProperties: true });
+    object.required = [];
+    return object;
+}

package/dist/package-contracts/collector-output.js

@@ -0,0 +1,50 @@
+/** Package-owned Collector receipt leaf — no role registration surface. */
+export const COLLECTOR_OUTPUT_TOOL = "ak_collector_output";
+export const COLLECTOR_ACCEPTED_TEXT = "Collector receipt accepted";
+export const COLLECTOR_HOST = "github.com";
+function safeGet(value, key) {
+    if ((typeof value !== "object" && typeof value !== "function") || value === null)
+        return undefined;
+    try {
+        return value[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function records(value) {
+    return Array.isArray(value) ? value.filter((item) => item !== null && typeof item === "object") : [];
+}
+function strings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+/** Settlement projection. Presence of the canonical groups array is the one Collector terminal discriminator. */
+export function validateAcceptedCollectorReceipt(value) {
+    const rawGroups = safeGet(value, "groups");
+    if (!Array.isArray(rawGroups))
+        throw new Error("Collector receipt has no typed groups terminal discriminator");
+    const groups = records(rawGroups).map((group) => ({
+        identity: (safeGet(group, "identity") ?? null),
+        ...(typeof safeGet(group, "displayLogin") === "string" ? { displayLogin: safeGet(group, "displayLogin") } : {}),
+        attendance: true,
+        materials: records(safeGet(group, "materials")),
+        findings: records(safeGet(group, "findings")),
+    }));
+    return {
+        host: safeGet(value, "host"),
+        repository: safeGet(value, "repository"),
+        prNumber: safeGet(value, "prNumber"),
+        manifestDigest: safeGet(value, "manifestDigest"),
+        activationTime: safeGet(value, "activationTime"),
+        deadlineTime: safeGet(value, "deadlineTime"),
+        finalObservationTime: safeGet(value, "finalObservationTime"),
+        finalSnapshotId: safeGet(value, "finalSnapshotId"),
+        targetHead: safeGet(value, "targetHead"),
+        groups,
+        requestAttempts: records(safeGet(value, "requestAttempts")),
+        snapshots: records(safeGet(value, "snapshots")).map((snapshot) => ({
+            snapshotId: safeGet(snapshot, "snapshotId"), observedAt: safeGet(snapshot, "observedAt"), completedAt: safeGet(snapshot, "completedAt"), completedMono: safeGet(snapshot, "completedMono"), host: safeGet(snapshot, "host"), repository: safeGet(snapshot, "repository"), prNumber: safeGet(snapshot, "prNumber"), prState: safeGet(snapshot, "prState"), headOid: safeGet(snapshot, "headOid"), complete: safeGet(snapshot, "complete"), evidenceIds: strings(safeGet(snapshot, "evidenceIds")), pageDiagnostics: records(safeGet(snapshot, "pageDiagnostics")), normalizedByteLength: safeGet(snapshot, "normalizedByteLength"),
+        })),
+        evidenceRecords: records(safeGet(value, "evidenceRecords")).map((record) => ({ evidenceId: safeGet(record, "evidenceId"), kind: safeGet(record, "kind"), versionId: safeGet(record, "versionId"), contentDigest: safeGet(record, "contentDigest"), firstObservedAt: safeGet(record, "firstObservedAt"), raw: safeGet(record, "raw") })),
+    };
+}

package/dist/package-contracts/fixer-output.js

@@ -0,0 +1,72 @@
+import { Type } from "typebox";
+import { FIXER_PREREQUISITE_ID_PATTERN } from "./fixer-packet.js";
+import { openToolObjectFromUnion } from "../open-tool-schema.js";
+export const FIXER_OUTPUT_TOOL_NAME = "ak_fixer_output";
+export const FIXER_ACCEPTED_TEXT = "Fixer report accepted";
+const nonblankTransportString = Type.String({ minLength: 1 });
+const authorityBlockerSchema = Type.Object({ cause: Type.Literal("authority_violation"), evidence: nonblankTransportString });
+const prerequisiteBlockerSchema = Type.Object({ cause: Type.Literal("prerequisite_unmet"), prerequisiteId: Type.String({ pattern: FIXER_PREREQUISITE_ID_PATTERN }), evidence: nonblankTransportString });
+const blockerSchema = Type.Union([authorityBlockerSchema, prerequisiteBlockerSchema]);
+const exceptionSchema = Type.Object({ where: nonblankTransportString, reason: nonblankTransportString });
+/** ⑥ test evidence slip — require submit when diff has test changes; machine does not check existence/completeness/coverage. */
+const testEvidenceSchema = Type.Object({
+    contract: Type.String({ minLength: 1, description: "Contract the test change proves." }),
+    minimumNecessaryCost: Type.String({ minLength: 1, description: "One-line minimum necessary cost of the test change." }),
+    measuredDuration: Type.String({ minLength: 1, description: "Measured duration of the focused verification run." }),
+}, { description: "Test evidence slip (submit when diff includes test changes; machine does not verify)." });
+const completedClassResultSchema = Type.Object({
+    name: nonblankTransportString,
+    disposition: Type.Literal("completed"),
+    searchScope: nonblankTransportString,
+    exceptions: Type.Array(exceptionSchema),
+    commitSha: nonblankTransportString,
+});
+const refusedClassResultSchema = Type.Object({
+    name: nonblankTransportString,
+    disposition: Type.Literal("refused"),
+    remainingScope: nonblankTransportString,
+    blocker: blockerSchema,
+});
+const classResultSchema = Type.Union([completedClassResultSchema, refusedClassResultSchema]);
+const completedClassResultsSchema = Type.Array(completedClassResultSchema, { minItems: 1 });
+const fixerOutputVariants = Type.Union([
+    Type.Object({ status: Type.Literal("planned", { description: "Plan-phase proposal outcome." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }) }),
+    Type.Object({ status: Type.Literal("refused", { description: "Lawfully refused outcome." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }), remainingScope: Type.String({ minLength: 1, description: "Work that cannot lawfully be performed." }), blocker: Type.Unsafe({ ...blockerSchema, description: "Lawful blocker preventing completion." }) }),
+    Type.Object({ status: Type.Literal("unfinished", { description: "Honest unfinished apply outcome." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }), remainingScope: Type.String({ minLength: 1, description: "Work remaining after this invocation." }), classResults: Type.Optional(Type.Unsafe({ ...completedClassResultsSchema, description: "Completed class settlements from this invocation." })), testEvidence: Type.Optional(testEvidenceSchema) }),
+    Type.Object({ status: Type.Literal("completed", { description: "All assigned classes completed." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }), classResults: Type.Array(classResultSchema, { minItems: 1, description: "Completed class settlements." }), testEvidence: Type.Optional(testEvidenceSchema) }),
+    Type.Object({ status: Type.Literal("refused", { description: "All assigned classes lawfully refused." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }), classResults: Type.Array(classResultSchema, { minItems: 1, description: "Per-class refusal settlements." }) }),
+    Type.Object({ status: Type.Literal("partially_completed", { description: "Assigned classes include completions and lawful refusals." }), report: Type.String({ minLength: 1, description: "Truthful Fixer outcome report." }), classResults: Type.Array(classResultSchema, { minItems: 1, description: "Per-class completion or refusal settlements." }), testEvidence: Type.Optional(testEvidenceSchema) }),
+]);
+export const fixerOutputSchema = openToolObjectFromUnion(fixerOutputVariants);
+export function validateFixerOutput(value, _phase) {
+    return value;
+}
+function safeProperty(value, property) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    try {
+        return value[property];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Bind recognizable prerequisite blockers to the packet declaration. */
+export function validateFixerOutputForPacket(value, phase, packet) {
+    const output = validateFixerOutput(value, phase);
+    const declaredIds = new Set(packet.prerequisites.map((entry) => entry.id));
+    const topLevelBlocker = safeProperty(output, "blocker");
+    const classResults = safeProperty(output, "classResults");
+    const blockers = topLevelBlocker === undefined
+        ? (Array.isArray(classResults) ? classResults.map((entry) => safeProperty(entry, "blocker")) : [])
+        : [topLevelBlocker];
+    for (const blocker of blockers) {
+        if (safeProperty(blocker, "cause") !== "prerequisite_unmet")
+            continue;
+        const prerequisiteId = safeProperty(blocker, "prerequisiteId");
+        if (typeof prerequisiteId === "string" && !declaredIds.has(prerequisiteId)) {
+            throw new Error("Fixer output violates blocker.prerequisiteId declared-prerequisite constraint");
+        }
+    }
+    return output;
+}

package/dist/package-contracts/fixer-packet.js

@@ -0,0 +1,77 @@
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+export const FIXER_PREREQUISITE_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]*$";
+export const fixerPrerequisiteSchema = Type.Object({
+    id: Type.String({ pattern: FIXER_PREREQUISITE_ID_PATTERN }),
+    requirement: Type.String({ pattern: "\\S" }),
+}, { additionalProperties: false });
+export const fixerPrerequisitesSchema = Type.Array(fixerPrerequisiteSchema);
+function causeMessage(cause) {
+    if (cause instanceof Error)
+        return cause.message;
+    if (typeof cause === "string")
+        return cause;
+    try {
+        return JSON.stringify(cause) ?? String(cause);
+    }
+    catch {
+        return String(cause);
+    }
+}
+export class FixerPacketValidationError extends Error {
+    code = "AK_INVALID_FIX_PACKET";
+    constructor(cause) {
+        const prefix = "Fixer prerequisites or instructions violate the invocation contract";
+        super(cause === undefined ? prefix : `${prefix}: ${causeMessage(cause)}`, cause === undefined ? undefined : { cause });
+        this.name = "FixerPacketValidationError";
+    }
+}
+function fail(cause) {
+    throw new FixerPacketValidationError(cause);
+}
+function parseFailure(value) {
+    if (!Array.isArray(value))
+        fail(new Error("Fixer prerequisites must be a JSON array"));
+    for (const entry of value) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            fail(new Error("Fixer prerequisite entry must be an object with id and requirement fields"));
+        }
+        const keys = Object.keys(entry);
+        if (keys.length !== 2 || !keys.includes("id") || !keys.includes("requirement")) {
+            fail(new Error("Fixer prerequisite entry fields must be exactly id and requirement"));
+        }
+        if (typeof entry.id !== "string" ||
+            !(new RegExp(FIXER_PREREQUISITE_ID_PATTERN)).test(entry.id)) {
+            fail(new Error(`Fixer prerequisite id violates pattern ${FIXER_PREREQUISITE_ID_PATTERN}`));
+        }
+        if (typeof entry.requirement !== "string" ||
+            !/\S/.test(entry.requirement)) {
+            fail(new Error("Fixer prerequisite requirement must be nonblank"));
+        }
+    }
+    fail(new Error("Fixer prerequisites violate the attachment schema"));
+}
+export function validateFixerPrerequisites(value) {
+    if (!Value.Check(fixerPrerequisitesSchema, value))
+        parseFailure(value);
+    const entries = value;
+    const ids = new Set();
+    const prerequisites = entries.map((entry) => {
+        if (ids.has(entry.id)) {
+            fail(new Error(`Fixer prerequisites contain duplicate id: ${entry.id}`));
+        }
+        ids.add(entry.id);
+        return Object.freeze({ id: entry.id, requirement: entry.requirement });
+    });
+    return Object.freeze(prerequisites);
+}
+export function parseFixerPrerequisites(source) {
+    let decoded;
+    try {
+        decoded = JSON.parse(source);
+    }
+    catch (error) {
+        fail(error);
+    }
+    return validateFixerPrerequisites(decoded);
+}

package/dist/package-contracts/judge-output.js

@@ -0,0 +1,17 @@
+/** Package-owned Judge output leaf — no role registration surface. */
+export const JUDGE_OUTPUT_TOOL_NAME = "ak_judge_output";
+export const JUDGE_ACCEPTED_TEXT = "Judge verdict accepted";
+export function validateAcceptedJudgeDetails(verdict) {
+    if (verdict === null || typeof verdict !== "object" || Array.isArray(verdict))
+        throw new Error("Judge verdict has no execution discriminator");
+    let judgeStatus;
+    try {
+        judgeStatus = verdict.judgeStatus;
+    }
+    catch {
+        throw new Error("Judge verdict has no execution discriminator");
+    }
+    if (["converged", "continue", "escalate"].includes(String(judgeStatus)))
+        return verdict;
+    throw new Error("Judge verdict has no execution discriminator");
+}

package/dist/package-contracts/reviewer-output.js

@@ -0,0 +1,82 @@
+/** Package-owned Reviewer intent and runtime-receipt leaves — no role registration surface. */
+export const REVIEWER_OUTPUT_TOOL_NAME = "ak_reviewer_output";
+export const REVIEWER_ACCEPTED_TEXT = "Reviewer report accepted";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function read(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    try {
+        return value[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function validateReviewerIntent(output) {
+    const status = read(output, "status");
+    if (status === "completed")
+        return { status };
+    if (status === "refused")
+        return { status, diagnostic: read(output, "diagnostic") };
+    throw new Error("Reviewer output has no recognized execution intent");
+}
+/** Validate runtime-owned facts at their real identity seams (target pins + plain text). */
+export function validateRuntimeReviewerReceipt(output) {
+    const acceptedBatch = read(output, "acceptedBatch");
+    const identities = read(output, "identities");
+    const construction = read(identities, "construction");
+    const target = read(identities, "target");
+    const reports = read(output, "reports");
+    const outcomes = read(output, "outcomes");
+    const legs = read(acceptedBatch, "legs");
+    // A recognizable accepted batch must remain bound to its exact target pin.
+    if (acceptedBatch !== undefined || construction !== undefined || target !== undefined) {
+        if (!isRecord(acceptedBatch) || !isRecord(construction) || !isRecord(target) || !Array.isArray(legs))
+            throw new Error("Incomplete Reviewer accepted-batch identity");
+        const objectFormat = read(target, "objectFormat");
+        const objectId = (value) => typeof value === "string" && new RegExp(objectFormat === "sha1" ? "^[0-9a-f]{40}$" : "^[0-9a-f]{64}$").test(value);
+        const refs = read(target, "refs");
+        const skillText = read(read(identities, "canonicalSkill"), "text");
+        if (typeof skillText !== "string" ||
+            read(construction, "recipe") !== "reviewer-common-bundle-v1" ||
+            (objectFormat !== "sha1" && objectFormat !== "sha256") || !objectId(read(target, "targetHead")) || !isRecord(refs) ||
+            Object.values(refs).some((ref) => !isRecord(ref) || !objectId(read(ref, "objectId")) || (read(ref, "peeledCommitId") !== null && !objectId(read(ref, "peeledCommitId")))))
+            throw new Error("Invalid Reviewer construction or target identity");
+        const expectedAxes = legs.map((leg) => read(leg, "axis"));
+        if (expectedAxes[0] !== "standards" || (expectedAxes.length === 2 && expectedAxes[1] !== "spec") || expectedAxes.length < 1 || expectedAxes.length > 2)
+            throw new Error("Invalid Reviewer accepted-leg projection");
+        if (!isRecord(outcomes) || !isRecord(reports))
+            throw new Error("Accepted Reviewer batch lacks outcomes or reports");
+        const outcomeAxes = Object.keys(outcomes).filter(axis => axis === "standards" || axis === "spec");
+        if (outcomeAxes.length !== expectedAxes.length || outcomeAxes.some((axis, index) => axis !== expectedAxes[index]))
+            throw new Error("Reviewer outcomes must exactly cover accepted legs in canonical order");
+        for (const [index, axisValue] of expectedAxes.entries()) {
+            const axis = axisValue;
+            const outcome = read(outcomes, axis);
+            if (!isRecord(outcome))
+                throw new Error("Reviewer accepted leg lacks outcome");
+            const expectedPrompt = read(read(legs[index], "prompt"), "text");
+            const actualPrompt = read(read(outcome, "prompt"), "text");
+            if (expectedPrompt !== actualPrompt)
+                throw new Error("Reviewer outcome prompt disagrees with accepted leg");
+            const status = read(outcome, "status");
+            const report = read(reports, axis);
+            if (status === "successful" && report === undefined)
+                throw new Error("Successful Reviewer outcome lacks report");
+            if (status === "failed" && report !== undefined)
+                throw new Error("Failed Reviewer outcome cannot bind a report");
+        }
+    }
+    return output;
+}
+/** Project thin submitted intent onto runtime enrichment without comparing runtime-owned fields. */
+export function projectReviewerIntentToReceipt(intentValue, receiptValue) {
+    const intent = validateReviewerIntent(intentValue);
+    const receipt = validateRuntimeReviewerReceipt(receiptValue);
+    if (receipt.status !== intent.status || (intent.status === "completed" ? receipt.diagnostic !== undefined : receipt.diagnostic !== intent.diagnostic)) {
+        throw new Error("Reviewer intent and runtime receipt disagree");
+    }
+    return receipt;
+}