onto-mcp 0.3.0 → 0.3.2

package/dist/core-runtime/reconstruct/seed-candidate-validation.js

@@ -91,6 +91,16 @@ function readEvidenceRef(value, claimId) {
         violations,
     };
 }
+function isGenericClaimName(name, groupName) {
+    const normalized = name.trim().toLowerCase().replace(/[_\s-]+/g, "_");
+    const singularGroup = groupName.endsWith("ies")
+        ? groupName.slice(0, -3) + "y"
+        : groupName.endsWith("s")
+            ? groupName.slice(0, -1)
+            : groupName;
+    const normalizedGroup = singularGroup.toLowerCase().replace(/[_\s-]+/g, "_");
+    return new RegExp(`^${normalizedGroup}_?\\d+$`).test(normalized);
+}
 function readClaim(value, groupName) {
     const violations = [];
     if (!isRecord(value)) {
@@ -109,6 +119,24 @@ function readClaim(value, groupName) {
             message: `${groupName} claim_id is required`,
         }));
     }
+    const rawName = value.name;
+    const name = typeof rawName === "string" && rawName.trim().length > 0
+        ? rawName.trim()
+        : null;
+    if (!name) {
+        violations.push(violation({
+            code: "claim_name_missing",
+            message: `${groupName} name is required`,
+            claimId,
+        }));
+    }
+    else if (isGenericClaimName(name, groupName)) {
+        violations.push(violation({
+            code: "claim_name_generic",
+            message: `${groupName} name must be a meaningful user-facing label, not a numbered placeholder`,
+            claimId,
+        }));
+    }
     const rawStatement = value.statement;
     const statement = typeof rawStatement === "string" ? rawStatement : "";
     const rawEvidenceRefs = value.evidence_refs;
@@ -125,6 +153,7 @@ function readClaim(value, groupName) {
     return {
         claim: {
             claim_id: claimId ?? `${groupName}:missing-claim-id`,
+            name: name ?? "",
             statement,
             evidence_refs: evidenceRefs,
         },

package/dist/core-runtime/review/continuation-plan.js

@@ -0,0 +1,160 @@
+import { isTrustedLedgerUnit } from "../pipeline-execution-ledger.js";
+function normalizeRequestedTargetUnitId(unitId) {
+    if (unitId.startsWith("lens:"))
+        return unitId.slice("lens:".length);
+    if (unitId.startsWith("deliberation:")) {
+        return `deliberation-${unitId.slice("deliberation:".length)}`;
+    }
+    if (unitId.startsWith("issue-artifact:")) {
+        return unitId.slice("issue-artifact:".length);
+    }
+    if (unitId === "controlled-lens-deliberation") {
+        return "controlled-deliberation";
+    }
+    return unitId;
+}
+function lensIdFromUnit(unit) {
+    if (unit.unitKind === "lens")
+        return unit.unitId;
+    if (unit.unitId.startsWith("deliberation-")) {
+        return unit.unitId.slice("deliberation-".length) || null;
+    }
+    return null;
+}
+function toContinuationUnit(unit, dispatchDecision, reason) {
+    const lensId = lensIdFromUnit(unit);
+    return {
+        unitId: unit.unitId,
+        unitKind: unit.unitKind,
+        ...(lensId !== null ? { lensId } : {}),
+        packetPath: unit.packetRef ?? null,
+        outputPath: unit.outputRefs[0] ?? null,
+        priorStatus: unit.status,
+        dispatchDecision,
+        reason,
+    };
+}
+function trustedUnitIds(ledger) {
+    return new Set(ledger.units
+        .filter((unit) => isTrustedLedgerUnit(unit))
+        .map((unit) => unit.unitId));
+}
+function isFrontierUnit(unit, trustedIds) {
+    if (isTrustedLedgerUnit(unit))
+        return false;
+    return unit.upstreamUnitIds.every((unitId) => trustedIds.has(unitId));
+}
+function reachableDownstreamUnitIds(args) {
+    const byId = new Map(args.ledger.units.map((unit) => [unit.unitId, unit]));
+    const result = new Set();
+    const queue = [...args.frontierUnitIds];
+    while (queue.length > 0) {
+        const unitId = queue.shift();
+        if (!unitId)
+            continue;
+        const unit = byId.get(unitId);
+        if (!unit)
+            continue;
+        for (const downstreamUnitId of unit.downstreamUnitIds) {
+            if (args.frontierUnitIds.has(downstreamUnitId))
+                continue;
+            if (result.has(downstreamUnitId))
+                continue;
+            result.add(downstreamUnitId);
+            queue.push(downstreamUnitId);
+        }
+    }
+    return result;
+}
+function targetRejectedUnits(args) {
+    const byId = new Map(args.ledger.units.map((unit) => [unit.unitId, unit]));
+    return args.targetUnits.flatMap((unitId) => {
+        const unit = byId.get(unitId);
+        if (!unit) {
+            return [
+                {
+                    unitId,
+                    unitKind: "unknown",
+                    packetPath: null,
+                    outputPath: null,
+                    priorStatus: "missing",
+                    dispatchDecision: "reject",
+                    reason: "Target unit is not present in the pipeline execution ledger.",
+                },
+            ];
+        }
+        if (isTrustedLedgerUnit(unit)) {
+            return [
+                toContinuationUnit(unit, "reject", "Target unit is already trusted and completed; completed outputs are reuse-only."),
+            ];
+        }
+        if (!args.naturalFrontierUnitIds.has(unitId)) {
+            return [
+                toContinuationUnit(unit, "reject", "Target unit is not the current continuation frontier; continue from the earliest untrusted unit first."),
+            ];
+        }
+        return [];
+    });
+}
+export function buildReviewContinuationPlan(params) {
+    const trustedIds = trustedUnitIds(params.ledger);
+    const requestedTargets = (params.targetUnits ?? []).map(normalizeRequestedTargetUnitId);
+    const naturalFrontier = params.ledger.units.filter((unit) => isFrontierUnit(unit, trustedIds));
+    const naturalFrontierUnitIds = new Set(naturalFrontier.map((unit) => unit.unitId));
+    const rejectedTargets = targetRejectedUnits({
+        ledger: params.ledger,
+        targetUnits: requestedTargets,
+        naturalFrontierUnitIds,
+    });
+    const requestedTargetSet = new Set(requestedTargets);
+    const missingFrontierTargets = requestedTargetSet.size === 0 || rejectedTargets.length > 0
+        ? []
+        : naturalFrontier.filter((unit) => !requestedTargetSet.has(unit.unitId));
+    const rejectedMissingFrontierTargets = missingFrontierTargets.map((unit) => toContinuationUnit(unit, "reject", "Target units must match the current continuation frontier so no untrusted sibling unit is skipped."));
+    const allRejectedTargets = [...rejectedTargets, ...rejectedMissingFrontierTargets];
+    const targetFrontier = requestedTargetSet.size === 0
+        ? naturalFrontier
+        : params.ledger.units.filter((unit) => requestedTargetSet.has(unit.unitId) && !isTrustedLedgerUnit(unit));
+    const frontierUnits = allRejectedTargets.length > 0
+        ? allRejectedTargets
+        : targetFrontier.map((unit) => toContinuationUnit(unit, "run", requestedTargetSet.size === 0
+            ? "Earliest untrusted unit whose upstream units are trusted."
+            : "Requested untrusted target unit."));
+    const frontierUnitIds = new Set(frontierUnits
+        .filter((unit) => unit.dispatchDecision === "run")
+        .map((unit) => unit.unitId));
+    const downstreamIds = reachableDownstreamUnitIds({
+        ledger: params.ledger,
+        frontierUnitIds,
+    });
+    const downstreamUnits = params.ledger.units
+        .filter((unit) => downstreamIds.has(unit.unitId) && !isTrustedLedgerUnit(unit))
+        .map((unit) => toContinuationUnit(unit, "run", "Downstream unit must be recomputed after the continuation frontier."));
+    const preservedArtifactRefs = params.ledger.units
+        .filter((unit) => isTrustedLedgerUnit(unit))
+        .flatMap((unit) => unit.producedArtifactRefs);
+    const supersededArtifactRefs = [...frontierUnits, ...downstreamUnits]
+        .filter((unit) => unit.dispatchDecision === "run" && unit.outputPath !== null)
+        .map((unit) => unit.outputPath)
+        .filter((outputPath) => preservedArtifactRefs.includes(outputPath) === false);
+    const eligible = allRejectedTargets.length === 0 &&
+        (frontierUnits.length > 0 || downstreamUnits.length > 0);
+    const ineligibleReason = eligible
+        ? null
+        : allRejectedTargets.length > 0
+            ? "One or more requested target units cannot be continued."
+            : "No untrusted continuation frontier remains.";
+    return {
+        schemaVersion: "1",
+        sessionId: params.ledger.sessionId,
+        eligible,
+        ineligibleReason,
+        sourceRefs: params.ledger.sourceRefs,
+        validationRefs: params.ledger.sourceRefs,
+        unitLedger: params.ledger,
+        frontierUnits,
+        downstreamUnits,
+        preservedArtifactRefs,
+        supersededArtifactRefs: [...new Set(supersededArtifactRefs)].sort(),
+    };
+}

package/dist/core-runtime/review/execution-plan-boundary.js

@@ -0,0 +1,123 @@
+import path from "node:path";
+import { assertPathInsideRoot, realpathIfExists } from "../path-boundary.js";
+async function assertSamePath(args) {
+    const expected = path.resolve(args.expected);
+    const actual = path.resolve(args.actual);
+    if (expected === actual)
+        return;
+    const realExpected = await realpathIfExists(expected);
+    const realActual = await realpathIfExists(actual);
+    if (realExpected && realActual && path.resolve(realExpected) === path.resolve(realActual)) {
+        return;
+    }
+    throw new Error(`${args.label} mismatch: expected ${expected}, received ${actual}`);
+}
+async function assertExecutionPlanRefInsideSession(args) {
+    const sessionRoot = path.resolve(args.sessionRoot);
+    const resolvedRef = path.isAbsolute(args.ref)
+        ? path.resolve(args.ref)
+        : path.resolve(sessionRoot, args.ref);
+    try {
+        await assertPathInsideRoot({
+            root: sessionRoot,
+            candidate: resolvedRef,
+            label: args.label,
+        });
+    }
+    catch (error) {
+        const message = (error instanceof Error ? error.message : String(error))
+            .replace("parent realpath escapes allowed root", "parent realpath escapes the session root")
+            .replace("realpath escapes allowed root", "realpath escapes the session root")
+            .replace("escapes allowed root", "escapes the session root");
+        throw new Error(`Review execution blocked because ${message}`);
+    }
+}
+export async function assertReviewExecutionPlanSessionBoundary(args) {
+    const { executionPlan, sessionRoot } = args;
+    const plannedSessionRoot = path.isAbsolute(executionPlan.session_root)
+        ? executionPlan.session_root
+        : path.resolve(sessionRoot, executionPlan.session_root);
+    await assertSamePath({
+        label: "ReviewExecutionPlan.session_root",
+        expected: sessionRoot,
+        actual: plannedSessionRoot,
+    });
+    const refs = [
+        { label: "interpretation_artifact_path", ref: executionPlan.interpretation_artifact_path },
+        { label: "binding_output_path", ref: executionPlan.binding_output_path },
+        { label: "session_metadata_path", ref: executionPlan.session_metadata_path },
+        { label: "execution_preparation_root", ref: executionPlan.execution_preparation_root },
+        { label: "round1_root", ref: executionPlan.round1_root },
+        { label: "prompt_packets_root", ref: executionPlan.prompt_packets_root },
+        {
+            label: "teamlead_deliberation_prompt_packet_path",
+            ref: executionPlan.teamlead_deliberation_prompt_packet_path,
+        },
+        { label: "synthesize_prompt_packet_path", ref: executionPlan.synthesize_prompt_packet_path },
+        { label: "actor_invocation_profiles_path", ref: executionPlan.actor_invocation_profiles_path },
+        { label: "actor_consumer_bindings_path", ref: executionPlan.actor_consumer_bindings_path },
+        { label: "domain_binding_path", ref: executionPlan.domain_binding_path },
+        { label: "review_target_profile_path", ref: executionPlan.review_target_profile_path },
+        {
+            label: "review_value_alignment_criteria_path",
+            ref: executionPlan.review_value_alignment_criteria_path,
+        },
+        { label: "review_context_manifest_path", ref: executionPlan.review_context_manifest_path },
+        { label: "synthesis_output_path", ref: executionPlan.synthesis_output_path },
+        { label: "finding_ledger_path", ref: executionPlan.finding_ledger_path },
+        {
+            label: "finding_relation_graph_path",
+            ref: executionPlan.finding_relation_graph_path,
+        },
+        { label: "issue_ledger_path", ref: executionPlan.issue_ledger_path },
+        { label: "issue_stance_matrix_path", ref: executionPlan.issue_stance_matrix_path },
+        { label: "deliberation_plan_path", ref: executionPlan.deliberation_plan_path },
+        { label: "problem_framing_path", ref: executionPlan.problem_framing_path },
+        { label: "lens_completion_barrier_path", ref: executionPlan.lens_completion_barrier_path },
+        { label: "deliberation_root_path", ref: executionPlan.deliberation_root_path },
+        { label: "deliberation_output_path", ref: executionPlan.deliberation_output_path },
+        { label: "execution_result_path", ref: executionPlan.execution_result_path },
+        { label: "error_log_path", ref: executionPlan.error_log_path },
+        { label: "final_output_path", ref: executionPlan.final_output_path },
+        { label: "review_record_path", ref: executionPlan.review_record_path },
+        ...executionPlan.lens_execution_seats.map((seat) => ({
+            label: `lens_execution_seats.${seat.lens_id}.output_path`,
+            ref: seat.output_path,
+        })),
+        ...executionPlan.lens_prompt_packet_seats.flatMap((seat) => [
+            {
+                label: `lens_prompt_packet_seats.${seat.lens_id}.packet_path`,
+                ref: seat.packet_path,
+            },
+            {
+                label: `lens_prompt_packet_seats.${seat.lens_id}.output_path`,
+                ref: seat.output_path,
+            },
+        ]),
+        ...executionPlan.issue_artifact_prompt_packet_seats.flatMap((seat) => [
+            {
+                label: `issue_artifact_prompt_packet_seats.${seat.artifact_id}.packet_path`,
+                ref: seat.packet_path,
+            },
+            {
+                label: `issue_artifact_prompt_packet_seats.${seat.artifact_id}.output_path`,
+                ref: seat.output_path,
+            },
+        ]),
+        ...executionPlan.lens_deliberation_prompt_packet_seats.flatMap((seat) => [
+            {
+                label: `lens_deliberation_prompt_packet_seats.${seat.lens_id}.packet_path`,
+                ref: seat.packet_path,
+            },
+            {
+                label: `lens_deliberation_prompt_packet_seats.${seat.lens_id}.output_path`,
+                ref: seat.output_path,
+            },
+        ]),
+    ];
+    for (const { label, ref } of refs) {
+        if (!ref)
+            continue;
+        await assertExecutionPlanRefInsideSession({ sessionRoot, ref, label });
+    }
+}

package/dist/core-runtime/review/materializers.js

@@ -773,9 +773,14 @@ function goalsForRole(role) {
 function domainGoalAdditions(domain) {
     switch (normalizeDomainValue(domain)) {
         case "software-engineering":
-            return ["runtime_contract", "test_evidence", "error_path_clarity"];
-        case "llm-native-development":
-            return ["context_isolation", "artifact_truth", "fail_loud_behavior"];
+            return [
+                "runtime_contract",
+                "test_evidence",
+                "error_path_clarity",
+                "context_isolation",
+                "artifact_truth",
+                "fail_loud_behavior",
+            ];
         default:
             return [];
     }

package/dist/core-runtime/review/pipeline-execution-ledger.js

@@ -0,0 +1,250 @@
+import path from "node:path";
+import { PIPELINE_EXECUTION_LEDGER_SCHEMA_VERSION, buildLedgerTrust, buildOutputHashes, fileSha256IfPresent, isTrustedLedgerUnit, normalizeLedgerRefs, } from "../pipeline-execution-ledger.js";
+const PRE_DELIBERATION_ISSUE_ARTIFACT_ORDER = [
+    "finding-ledger",
+    "finding-relation-graph",
+    "issue-ledger",
+    "issue-stance-matrix",
+    "deliberation-plan",
+];
+function issueArtifactOutputPath(executionPlan, artifactId) {
+    switch (artifactId) {
+        case "finding-ledger":
+            return executionPlan.finding_ledger_path;
+        case "finding-relation-graph":
+            return executionPlan.finding_relation_graph_path;
+        case "issue-ledger":
+            return executionPlan.issue_ledger_path;
+        case "issue-stance-matrix":
+            return executionPlan.issue_stance_matrix_path;
+        case "deliberation-plan":
+            return executionPlan.deliberation_plan_path;
+        case "problem-framing":
+            return executionPlan.problem_framing_path;
+    }
+}
+function issueArtifactPacketPath(executionPlan, artifactId) {
+    return (executionPlan.issue_artifact_prompt_packet_seats.find((seat) => seat.artifact_id === artifactId)?.packet_path ?? null);
+}
+function allExecutionResults(executionResult) {
+    if (!executionResult)
+        return [];
+    return [
+        ...executionResult.lens_execution_results,
+        ...(executionResult.issue_artifact_execution_results ?? []),
+        ...(executionResult.deliberation_execution_results ?? []),
+        ...(executionResult.synthesize_execution_result
+            ? [executionResult.synthesize_execution_result]
+            : []),
+    ];
+}
+function statusFromWorkerUnit(workerUnit) {
+    if (workerUnit?.status === "completed")
+        return "completed";
+    if (workerUnit?.status === "failed")
+        return "failed";
+    if (workerUnit?.status === "skipped")
+        return "skipped";
+    return null;
+}
+function plannedReviewUnits(executionPlan) {
+    const lensUnitIds = executionPlan.lens_execution_seats.map((seat) => seat.lens_id);
+    const units = executionPlan.lens_execution_seats.map((seat) => ({
+        unitId: seat.lens_id,
+        unitKind: "lens",
+        owner: "host_llm",
+        packetRef: executionPlan.lens_prompt_packet_seats.find((packetSeat) => packetSeat.lens_id === seat.lens_id)?.packet_path ?? null,
+        outputRefs: [seat.output_path],
+        upstreamUnitIds: [],
+    }));
+    for (const [index, artifactId] of PRE_DELIBERATION_ISSUE_ARTIFACT_ORDER.entries()) {
+        const previousArtifactId = PRE_DELIBERATION_ISSUE_ARTIFACT_ORDER[index - 1];
+        const upstreamUnitIds = index === 0
+            ? lensUnitIds
+            : previousArtifactId
+                ? [previousArtifactId]
+                : lensUnitIds;
+        units.push({
+            unitId: artifactId,
+            unitKind: "issue_artifact",
+            owner: "host_llm",
+            packetRef: issueArtifactPacketPath(executionPlan, artifactId),
+            outputRefs: [issueArtifactOutputPath(executionPlan, artifactId)],
+            upstreamUnitIds,
+        });
+    }
+    const deliberationPlanUnitId = "deliberation-plan";
+    const deliberationUnitIds = executionPlan.lens_deliberation_prompt_packet_seats.map((seat) => `deliberation-${seat.lens_id}`);
+    const deliberationInputUnitIds = [deliberationPlanUnitId, ...lensUnitIds];
+    for (const seat of executionPlan.lens_deliberation_prompt_packet_seats) {
+        units.push({
+            unitId: `deliberation-${seat.lens_id}`,
+            unitKind: "deliberation",
+            owner: "host_llm",
+            packetRef: seat.packet_path,
+            outputRefs: [seat.output_path],
+            upstreamUnitIds: deliberationInputUnitIds,
+        });
+    }
+    units.push({
+        unitId: "controlled-deliberation",
+        unitKind: "deliberation",
+        owner: "host_llm",
+        packetRef: executionPlan.teamlead_deliberation_prompt_packet_path,
+        outputRefs: [executionPlan.deliberation_output_path],
+        upstreamUnitIds: deliberationUnitIds,
+    });
+    units.push({
+        unitId: "problem-framing",
+        unitKind: "issue_artifact",
+        owner: "host_llm",
+        packetRef: issueArtifactPacketPath(executionPlan, "problem-framing"),
+        outputRefs: [executionPlan.problem_framing_path],
+        upstreamUnitIds: ["controlled-deliberation"],
+    });
+    units.push({
+        unitId: "synthesize",
+        unitKind: "synthesize",
+        owner: "host_llm",
+        packetRef: executionPlan.synthesize_prompt_packet_path,
+        outputRefs: [executionPlan.synthesis_output_path],
+        upstreamUnitIds: ["controlled-deliberation", "problem-framing"],
+    });
+    return units;
+}
+function downstreamMap(units) {
+    const map = new Map();
+    for (const unit of units)
+        map.set(unit.unitId, []);
+    for (const unit of units) {
+        for (const upstreamUnitId of unit.upstreamUnitIds) {
+            map.set(upstreamUnitId, [...(map.get(upstreamUnitId) ?? []), unit.unitId]);
+        }
+    }
+    return map;
+}
+function statusFromBarrier(args) {
+    const barrier = args.lensCompletionBarrier;
+    if (!barrier)
+        return null;
+    if (barrier.completed_lens_ids.includes(args.unitId))
+        return "completed";
+    if (barrier.failed_lens_ids.includes(args.unitId))
+        return "failed";
+    if (barrier.missing_lens_ids.includes(args.unitId))
+        return "missing";
+    return null;
+}
+function deriveMissingStatus(args) {
+    if (!args.hasExecutionResult && !args.hasReviewRunManifest) {
+        return args.unit.upstreamUnitIds.length === 0 ? "planned" : "not_reached";
+    }
+    if (!args.upstreamTrusted)
+        return "not_reached";
+    return "missing";
+}
+async function buildUnitEntry(args) {
+    const packetRef = args.executionResult?.packet_path ??
+        args.workerUnit?.packet_path ??
+        args.plannedUnit.packetRef;
+    const outputRefs = [
+        args.executionResult?.output_path ??
+            args.workerUnit?.output_path ??
+            args.plannedUnit.outputRefs[0],
+    ].filter((ref) => typeof ref === "string" && ref.length > 0);
+    const outputHashes = await buildOutputHashes(outputRefs);
+    const upstreamTrusted = args.plannedUnit.upstreamUnitIds.every((unitId) => args.trustedUnitIds.has(unitId));
+    const status = args.executionResult?.status ??
+        statusFromWorkerUnit(args.workerUnit) ??
+        (args.plannedUnit.unitKind === "lens"
+            ? statusFromBarrier({
+                unitId: args.plannedUnit.unitId,
+                lensCompletionBarrier: args.lensCompletionBarrier,
+            })
+            : null) ??
+        deriveMissingStatus({
+            unit: args.plannedUnit,
+            hasExecutionResult: args.hasExecutionResult,
+            hasReviewRunManifest: args.hasReviewRunManifest,
+            upstreamTrusted,
+        });
+    const lastFailureMessage = args.executionResult?.failure_message ??
+        args.workerUnit?.failure_message ??
+        null;
+    const trust = buildLedgerTrust({
+        status,
+        outputRefs,
+        outputHashes,
+        upstreamTrusted,
+        lastFailureMessage,
+    });
+    const packetSha256 = args.workerUnit?.packet_sha256 ?? await fileSha256IfPresent(packetRef);
+    const upstreamOutputRefs = args.plannedUnit.upstreamUnitIds.flatMap((unitId) => args.outputRefsByUnitId.get(unitId) ?? []);
+    return {
+        unitId: args.plannedUnit.unitId,
+        unitKind: args.plannedUnit.unitKind,
+        owner: args.plannedUnit.owner,
+        producedArtifactRefs: outputRefs,
+        consumedArtifactRefs: normalizeLedgerRefs([
+            packetRef,
+            ...upstreamOutputRefs,
+        ]),
+        ...(packetRef !== null ? { packetRef } : {}),
+        ...(packetSha256 !== null ? { packetSha256 } : {}),
+        outputRefs,
+        outputHashes,
+        status,
+        trustStatus: trust.trustStatus,
+        trustReason: trust.trustReason,
+        attemptCount: args.executionResult || args.workerUnit ? 1 : 0,
+        lastFailureMessage,
+        upstreamUnitIds: args.plannedUnit.upstreamUnitIds,
+        downstreamUnitIds: args.downstreamUnitIds,
+    };
+}
+export async function buildReviewPipelineExecutionLedger(params) {
+    const units = plannedReviewUnits(params.executionPlan);
+    const downstreamUnitIds = downstreamMap(units);
+    const outputRefsByUnitId = new Map(units.map((unit) => [unit.unitId, unit.outputRefs]));
+    const executionResultsByUnitId = new Map(allExecutionResults(params.executionResult).map((result) => [
+        result.unit_id,
+        result,
+    ]));
+    const workerUnitsByUnitId = new Map((params.reviewRunManifest?.worker_units ?? [])
+        .filter((unit) => typeof unit.unit_id === "string")
+        .map((unit) => [unit.unit_id, unit]));
+    const trustedUnitIds = new Set();
+    const ledgerUnits = [];
+    for (const plannedUnit of units) {
+        const entry = await buildUnitEntry({
+            plannedUnit,
+            downstreamUnitIds: downstreamUnitIds.get(plannedUnit.unitId) ?? [],
+            outputRefsByUnitId,
+            executionResult: executionResultsByUnitId.get(plannedUnit.unitId),
+            workerUnit: workerUnitsByUnitId.get(plannedUnit.unitId),
+            lensCompletionBarrier: params.lensCompletionBarrier,
+            hasExecutionResult: params.executionResult !== null && params.executionResult !== undefined,
+            hasReviewRunManifest: params.reviewRunManifest !== null && params.reviewRunManifest !== undefined,
+            trustedUnitIds,
+        });
+        ledgerUnits.push(entry);
+        if (isTrustedLedgerUnit(entry))
+            trustedUnitIds.add(entry.unitId);
+    }
+    return {
+        schemaVersion: PIPELINE_EXECUTION_LEDGER_SCHEMA_VERSION,
+        pipeline: "review",
+        sessionId: params.executionPlan.session_id || path.basename(params.sessionRoot),
+        sourceRefs: normalizeLedgerRefs([
+            params.artifactRefs?.execution_plan,
+            params.artifactRefs?.review_run_manifest,
+            params.artifactRefs?.execution_result,
+            params.artifactRefs?.lens_completion_barrier,
+            params.artifactRefs?.review_context_manifest,
+            params.artifactRefs?.finding_ledger,
+            params.artifactRefs?.issue_ledger,
+            ...Object.values(params.reviewRunManifest?.artifact_refs ?? {}),
+        ]),
+        units: ledgerUnits,
+    };
+}

package/dist/core-runtime/review/review-artifact-utils.js

@@ -117,11 +117,24 @@ export function toRelativePath(targetPath, projectRoot) {
     const normalized = relativePath === "" ? "." : relativePath;
     return normalized.split(path.sep).join(path.posix.sep);
 }
+const DOMAIN_ALIAS_TO_CANONICAL = {
+    "llm-native-development": "software-engineering",
+    "software-development": "software-engineering",
+};
+function stripDomainSigil(domainValue) {
+    const trimmed = domainValue.trim();
+    return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
 export function normalizeDomainValue(domainValue) {
-    if (["", "-", "@-", "none"].includes(domainValue)) {
+    const stripped = stripDomainSigil(domainValue);
+    if (["", "-", "none"].includes(stripped)) {
         return "none";
     }
-    return domainValue.startsWith("@") ? domainValue.slice(1) : domainValue;
+    return DOMAIN_ALIAS_TO_CANONICAL[stripped] ?? stripped;
+}
+export function isDeprecatedDomainAlias(domainValue) {
+    const stripped = stripDomainSigil(domainValue);
+    return Object.prototype.hasOwnProperty.call(DOMAIN_ALIAS_TO_CANONICAL, stripped);
 }
 export function parseBooleanFlag(optionValue, optionName) {
     if (typeof optionValue === "boolean") {