context-probe 0.1.0

package/dist/src/core/providers-runner.js

@@ -0,0 +1,32 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { defaultProviderCommand } from "./providers-prompt.js";
+const execFile = promisify(execFileCallback);
+export async function runCodexCli(options, schemaPath, outputPath, prompt) {
+    const command = options.providerCommand ?? defaultProviderCommand(options.provider);
+    await execFile(command, ["exec", "--skip-git-repo-check", "-C", options.cwd, "--output-schema", schemaPath, "-o", outputPath, prompt], {
+        cwd: options.cwd,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return readFile(outputPath, "utf8");
+}
+export async function runClaudeCli(options, schema, prompt) {
+    const command = options.providerCommand ?? defaultProviderCommand(options.provider);
+    const { stdout } = await execFile(command, [
+        "-p",
+        "--output-format",
+        "json",
+        "--json-schema",
+        JSON.stringify(schema),
+        "--permission-mode",
+        "default",
+        "--tools",
+        "",
+        prompt,
+    ], {
+        cwd: options.cwd,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return stdout;
+}

package/dist/src/core/providers-types.d.ts

@@ -0,0 +1,10 @@
+import type { ExtractionKind, ExtractionProviderName, Fragment } from "./contracts.js";
+export interface CliExtractionOptions {
+    cwd: string;
+    provider: ExtractionProviderName;
+    providerCommand?: string;
+    kind: ExtractionKind;
+    promptProfile: string;
+    fragments: Fragment[];
+}
+export type RawProviderItem = Record<string, unknown>;

package/dist/src/core/providers-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/providers.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractionProviderResult } from "./contracts.js";
+export type { CliExtractionOptions } from "./providers-types.js";
+import type { CliExtractionOptions, RawProviderItem } from "./providers-types.js";
+export declare function runCliExtraction(options: CliExtractionOptions): Promise<ExtractionProviderResult<RawProviderItem>>;

package/dist/src/core/providers.js

@@ -0,0 +1,30 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { normalizeProviderPayload } from "./providers-normalization.js";
+import { buildPrompt, buildSchema } from "./providers-prompt.js";
+import { runClaudeCli, runCodexCli } from "./providers-runner.js";
+export async function runCliExtraction(options) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "context-probe-provider-"));
+    const schemaPath = path.join(tempDir, `${options.kind}-schema.json`);
+    const outputPath = path.join(tempDir, `${options.kind}-output.json`);
+    const schema = buildSchema(options.kind);
+    const prompt = buildPrompt(options.kind, options.promptProfile, options.fragments);
+    await writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
+    try {
+        const rawOutput = options.provider === "codex"
+            ? await runCodexCli(options, schemaPath, outputPath, prompt)
+            : await runClaudeCli(options, schema, prompt);
+        const parsed = normalizeProviderPayload(JSON.parse(rawOutput));
+        return {
+            items: parsed.items,
+            confidence: parsed.confidence,
+            unknowns: parsed.unknowns,
+            diagnostics: parsed.diagnostics,
+            provider: options.provider,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/src/core/report-actionability.d.ts

@@ -0,0 +1,4 @@
+import type { ReportResponse } from "./report-shared-predicates.js";
+export declare function renderMeasurementQualitySection(response: ReportResponse): string[];
+export declare function renderSuggestedNextEvidenceSection(response: ReportResponse): string[];
+export declare function renderActionQueueSection(response: ReportResponse): string[];

package/dist/src/core/report-actionability.js

@@ -0,0 +1,57 @@
+import { buildSuggestedNextEvidence, isApproximationNote, isMissingInputNote } from "./measurement-metadata.js";
+function uniq(values) {
+    return Array.from(new Set(values));
+}
+export function renderMeasurementQualitySection(response) {
+    const measurementQuality = response.meta?.measurementQuality;
+    if (!measurementQuality) {
+        return [];
+    }
+    const lines = ["", "## Measurement Quality"];
+    lines.push(`- Decision Risk: ${measurementQuality.decisionRisk}`);
+    lines.push(`- Unknown Count: ${measurementQuality.unknownsCount}`);
+    lines.push(`- Proxy Metrics: ${measurementQuality.proxyMetrics.length > 0 ? measurementQuality.proxyMetrics.join(", ") : "none"}`);
+    lines.push(`- Proxy Rate: ${measurementQuality.proxyRate.toFixed(3)}`);
+    if (measurementQuality.approximationNotes.length > 0) {
+        lines.push(...measurementQuality.approximationNotes.map((entry) => `- Approximation: ${entry}`));
+    }
+    return lines;
+}
+export function renderSuggestedNextEvidenceSection(response) {
+    const suggestions = buildSuggestedNextEvidence(response);
+    if (suggestions.length === 0) {
+        return [];
+    }
+    return ["", "## Suggested Next Evidence", ...suggestions.map((entry) => `- ${entry}`)];
+}
+function buildActionQueue(response) {
+    const actions = [];
+    if (response.result.scenarioQuality?.missingTopPriorityObservationIds.length) {
+        actions.push(`Add observations for top-priority scenarios: ${response.result.scenarioQuality.missingTopPriorityObservationIds.join(", ")}`);
+    }
+    if (response.result.localityWatchlist && response.result.localityWatchlist.length > 0) {
+        const hotspot = response.result.localityWatchlist[0];
+        if (hotspot) {
+            actions.push(`Review recurring co-change hotspot: ${hotspot.boundaries.join(" <-> ")} (${hotspot.count} commits)`);
+        }
+    }
+    if (response.meta?.measurementQuality?.proxyMetrics.length) {
+        actions.push(`Reduce proxy dependence in ${response.meta.measurementQuality.proxyMetrics.join(", ")} by adding stronger evidence inputs`);
+    }
+    const missingInputUnknown = response.unknowns.find(isMissingInputNote);
+    if (missingInputUnknown) {
+        actions.push(`Resolve missing or thin evidence: ${missingInputUnknown}`);
+    }
+    const approximationUnknown = response.unknowns.find(isApproximationNote);
+    if (approximationUnknown) {
+        actions.push(`Replace approximation with observed evidence: ${approximationUnknown}`);
+    }
+    return uniq(actions).slice(0, 5);
+}
+export function renderActionQueueSection(response) {
+    const actions = buildActionQueue(response);
+    if (actions.length === 0) {
+        return [];
+    }
+    return ["", "## Action Queue", ...actions.map((entry) => `- ${entry}`)];
+}

package/dist/src/core/report-architecture.d.ts

@@ -0,0 +1,2 @@
+import { type ReportResponse } from "./report-shared.js";
+export declare function renderArchitectureMarkdownReport(response: ReportResponse, profileName?: string): string;

package/dist/src/core/report-architecture.js

@@ -0,0 +1,80 @@
+import { renderActionQueueSection, renderMeasurementQualitySection, renderSuggestedNextEvidenceSection, } from "./report-actionability.js";
+import { dedupe, formatMetric, proxyOrPartialUnknowns, renderMetricGuidanceSection, } from "./report-shared.js";
+function architectureMetricMap(metrics) {
+    return new Map(metrics.map((metric) => [metric.metricId, metric]));
+}
+function detectPolicyProfile(response, explicitProfileName) {
+    if (explicitProfileName) {
+        return explicitProfileName;
+    }
+    const profileEntry = response.provenance.find((entry) => entry.note?.startsWith("profile="));
+    return profileEntry?.note?.slice("profile=".length);
+}
+export function renderArchitectureMarkdownReport(response, profileName) {
+    const lines = ["# Measurement Report", ""];
+    const metrics = architectureMetricMap(response.result.metrics);
+    const summaryMetric = metrics.get("APSI");
+    const supportingMetricIds = ["QSF", "DDS", "BPS", "IPS", "OAS", "EES", "CTI"];
+    const bridgeMetricIds = ["TIS", "AELS"];
+    const supportingMetrics = supportingMetricIds
+        .map((metricId) => metrics.get(metricId))
+        .filter((metric) => Boolean(metric));
+    const bridgeMetrics = bridgeMetricIds
+        .map((metricId) => metrics.get(metricId))
+        .filter((metric) => Boolean(metric));
+    const proxySignals = dedupe(response.result.metrics.flatMap((metric) => proxyOrPartialUnknowns(metric).map((entry) => `${metric.metricId}: ${entry}`)));
+    const activeProfile = detectPolicyProfile(response, profileName);
+    lines.push(`- Domain: ${response.result.domainId}`);
+    lines.push(`- Status: ${response.status}`);
+    lines.push(`- Confidence: ${response.confidence.toFixed(3)}`);
+    if (activeProfile) {
+        lines.push(`- Policy Profile: ${activeProfile}`);
+    }
+    lines.push("");
+    lines.push(...renderMeasurementQualitySection(response));
+    lines.push("## Architecture Summary");
+    if (summaryMetric) {
+        lines.push(formatMetric(summaryMetric));
+        lines.push("- APSI is a summary-only metric. Always read the supporting metrics below.");
+    }
+    else {
+        lines.push("- APSI is not available for this run.");
+    }
+    lines.push("", "## Supporting Metrics");
+    lines.push(...supportingMetrics.map(formatMetric));
+    if (bridgeMetrics.length > 0) {
+        lines.push("", "## Bridge Metrics");
+        lines.push(...bridgeMetrics.map(formatMetric));
+    }
+    lines.push(...renderMetricGuidanceSection([...(summaryMetric ? [summaryMetric] : []), ...supportingMetrics, ...bridgeMetrics]));
+    if (response.result.scenarioQuality) {
+        lines.push("", "## Scenario Quality");
+        lines.push(`- Observed Scenarios: ${response.result.scenarioQuality.observedScenarios}/${response.result.scenarioQuality.totalScenarios}`);
+        if (response.result.scenarioQuality.missingTopPriorityObservationIds.length > 0) {
+            lines.push(`- Missing Top-Priority Observations: ${response.result.scenarioQuality.missingTopPriorityObservationIds.join(", ")}`);
+        }
+        if (response.result.scenarioQuality.duplicateScenarioIds.length > 0) {
+            lines.push(`- Duplicate Scenario Intent: ${response.result.scenarioQuality.duplicateScenarioIds.join(", ")}`);
+        }
+        lines.push(...response.result.scenarioQuality.findings.map((item) => `- ${item}`));
+    }
+    if (response.result.localityWatchlist && response.result.localityWatchlist.length > 0) {
+        lines.push("", "## Locality Watchlist");
+        lines.push(...response.result.localityWatchlist.map((item) => `- ${item.boundaries.join(" <-> ")}: ${item.count} commits${item.sampleCommitHashes.length > 0 ? ` (${item.sampleCommitHashes.join(", ")})` : ""}`));
+    }
+    if (proxySignals.length > 0) {
+        lines.push("", "## Proxy / Partial Signals", ...proxySignals.map((item) => `- ${item}`));
+    }
+    lines.push(...renderSuggestedNextEvidenceSection(response));
+    lines.push(...renderActionQueueSection(response));
+    if (response.unknowns.length > 0) {
+        lines.push("", "## Unknowns", ...response.unknowns.map((item) => `- ${item}`));
+    }
+    if (response.diagnostics.length > 0) {
+        lines.push("", "## Diagnostics", ...response.diagnostics.map((item) => `- ${item}`));
+    }
+    if (response.result.violations && response.result.violations.length > 0) {
+        lines.push("", "## Direction Violations", `- Count: ${response.result.violations.length}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/src/core/report-domain.d.ts

@@ -0,0 +1,2 @@
+import { type ReportResponse } from "./report-shared.js";
+export declare function renderDomainMarkdownReport(response: ReportResponse): string;

package/dist/src/core/report-domain.js

@@ -0,0 +1,50 @@
+import { renderActionQueueSection, renderMeasurementQualitySection, renderSuggestedNextEvidenceSection, } from "./report-actionability.js";
+import { formatMetric, renderMetricGuidanceSection } from "./report-shared.js";
+function renderPilotRolloutSection(pilot) {
+    if (!pilot) {
+        return [];
+    }
+    const overallReasons = pilot.overallGate.reasons.length > 0 ? pilot.overallGate.reasons.join(", ") : "none";
+    const categoryReasons = pilot.categoryGate.reasons.length > 0 ? pilot.categoryGate.reasons.join(", ") : "none";
+    return [
+        "",
+        "## Pilot Rollout",
+        `- Category: ${pilot.category}`,
+        `- Applied: ${pilot.applied ? "yes" : "no"}`,
+        `- Locality Source: ${pilot.localitySource}`,
+        `- Baseline ELS: ${pilot.baselineElsValue.toFixed(3)}`,
+        `- Persistence Candidate: ${pilot.persistenceCandidateValue.toFixed(3)}`,
+        `- Effective ELS: ${pilot.effectiveElsValue.toFixed(3)}`,
+        `- Overall Gate: ${pilot.overallGate.rolloutDisposition} (${pilot.overallGate.replacementVerdict})`,
+        `- Overall Reasons: ${overallReasons}`,
+        `- Category Gate: ${pilot.categoryGate.rolloutDisposition} (${pilot.categoryGate.replacementVerdict})`,
+        `- Category Reasons: ${categoryReasons}`,
+    ];
+}
+export function renderDomainMarkdownReport(response) {
+    const lines = ["# Measurement Report", ""];
+    lines.push(`- Domain: ${response.result.domainId}`);
+    lines.push(`- Status: ${response.status}`);
+    lines.push(`- Confidence: ${response.confidence.toFixed(3)}`);
+    lines.push("");
+    lines.push(...renderMeasurementQualitySection(response));
+    lines.push("## Metrics");
+    lines.push(...response.result.metrics.map(formatMetric));
+    lines.push(...renderPilotRolloutSection(response.result.pilot));
+    lines.push(...renderMetricGuidanceSection(response.result.metrics));
+    lines.push(...renderSuggestedNextEvidenceSection(response));
+    lines.push(...renderActionQueueSection(response));
+    if (response.unknowns.length > 0) {
+        lines.push("", "## Unknowns", ...response.unknowns.map((item) => `- ${item}`));
+    }
+    if (response.diagnostics.length > 0) {
+        lines.push("", "## Diagnostics", ...response.diagnostics.map((item) => `- ${item}`));
+    }
+    if (response.result.leakFindings && response.result.leakFindings.length > 0) {
+        lines.push("", "## Boundary Leaks", `- Count: ${response.result.leakFindings.length}`);
+    }
+    if (response.result.violations && response.result.violations.length > 0) {
+        lines.push("", "## Direction Violations", `- Count: ${response.result.violations.length}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/src/core/report-gate.d.ts

@@ -0,0 +1,3 @@
+import type { MetricGateDecision, PolicyConfig } from "./contracts.js";
+import { type GateResponse } from "./report-shared.js";
+export declare function evaluateGate(response: GateResponse, policyConfig: PolicyConfig, profileName: string): MetricGateDecision;

package/dist/src/core/report-gate.js

@@ -0,0 +1,54 @@
+import { getDomainPolicy } from "./policy.js";
+import { dedupe, proxyOrPartialUnknowns } from "./report-shared.js";
+export function evaluateGate(response, policyConfig, profileName) {
+    const policy = getDomainPolicy(policyConfig, profileName, response.result.domainId);
+    const failures = [];
+    const warnings = [];
+    const architectureSummaryMetricIds = new Set(["APSI"]);
+    const isArchitecture = response.result.domainId === "architecture_design";
+    for (const metric of response.result.metrics) {
+        const thresholds = policy.metrics[metric.metricId]?.thresholds;
+        if (!thresholds) {
+            continue;
+        }
+        if (isArchitecture && architectureSummaryMetricIds.has(metric.metricId)) {
+            if (thresholds.fail !== undefined && metric.value < thresholds.fail) {
+                warnings.push(`${metric.metricId}=${metric.value.toFixed(3)} < summary_fail(${thresholds.fail})`);
+                continue;
+            }
+            if (thresholds.warn !== undefined && metric.value < thresholds.warn) {
+                warnings.push(`${metric.metricId}=${metric.value.toFixed(3)} < summary_warn(${thresholds.warn})`);
+            }
+            continue;
+        }
+        if (thresholds.fail !== undefined && metric.value < thresholds.fail) {
+            failures.push(`${metric.metricId}=${metric.value.toFixed(3)} < fail(${thresholds.fail})`);
+            continue;
+        }
+        if (thresholds.warn !== undefined && metric.value < thresholds.warn) {
+            warnings.push(`${metric.metricId}=${metric.value.toFixed(3)} < warn(${thresholds.warn})`);
+        }
+    }
+    if (isArchitecture) {
+        const partialMetrics = response.result.metrics
+            .filter((metric) => proxyOrPartialUnknowns(metric).length > 0)
+            .map((metric) => metric.metricId);
+        if (partialMetrics.length > 0) {
+            warnings.push(`architecture metrics include proxy/partial decision material: ${dedupe(partialMetrics).join(", ")}`);
+        }
+    }
+    const measurementQuality = response.meta?.measurementQuality;
+    if (measurementQuality) {
+        if (measurementQuality.unknownsCount > 0) {
+            warnings.push(`measurement quality includes ${measurementQuality.unknownsCount} unknown signal(s)`);
+        }
+        if (measurementQuality.proxyMetrics.length > 0) {
+            warnings.push(`measurement quality depends on proxy material in ${measurementQuality.proxyMetrics.join(", ")}`);
+        }
+    }
+    return {
+        status: failures.length > 0 ? "error" : warnings.length > 0 ? "warning" : "ok",
+        failures,
+        warnings,
+    };
+}

package/dist/src/core/report-shared-format.d.ts

@@ -0,0 +1,2 @@
+import type { MetricScore } from "./contracts.js";
+export declare function formatMetric(metric: MetricScore): string;

package/dist/src/core/report-shared-format.js

@@ -0,0 +1,6 @@
+export function formatMetric(metric) {
+    const components = Object.entries(metric.components)
+        .map(([key, value]) => `${key}=${value.toFixed(3)}`)
+        .join(", ");
+    return `- ${metric.metricId}: ${metric.value.toFixed(3)} [confidence=${metric.confidence.toFixed(3)}] (${components})`;
+}

package/dist/src/core/report-shared-guidance.d.ts

@@ -0,0 +1,2 @@
+import type { MetricScore } from "./contracts.js";
+export declare function renderMetricGuidanceSection(metrics: MetricScore[]): string[];

package/dist/src/core/report-shared-guidance.js

@@ -0,0 +1,98 @@
+const METRIC_GUIDANCE = {
+    DRF: {
+        ideal: "Major use cases, business rules, and invariants should be traceable to model elements.",
+        watch: "Low values often indicate weak modeling, ambiguous documents, or review disagreement.",
+        action: "List the core use cases and rules, then map them explicitly to model elements.",
+    },
+    ULI: {
+        ideal: "Canonical terms should stay stable inside each context and remain traceable across docs and code.",
+        watch: "Low values often indicate alias sprawl, term collision, or weak traceability.",
+        action: "Organize the glossary per context and align Published Language and DTO naming.",
+    },
+    BFS: {
+        ideal: "Boundaries should reflect both reasons to keep elements together and reasons to separate them.",
+        watch: "Low values often mean the split follows feature lists rather than ownership, security, or invariants.",
+        action: "Review attraction and separation signals and document the boundary rationale.",
+    },
+    AFS: {
+        ideal: "Strong invariants should close within a single aggregate and avoid multi-aggregate atomic writes.",
+        watch: "Low values often mean synchronous consistency responsibilities are spread across boundaries.",
+        action: "List strong invariants and revisit which aggregate owns each synchronous responsibility.",
+    },
+    MCCS: {
+        ideal: "Cross-context communication should go through public contracts without leaking internal types.",
+        watch: "Low values often indicate boundary leaks or direct use of internal models instead of contract DTOs.",
+        action: "Detect cross-context imports in CI and move integrations behind ACLs or contract DTOs.",
+    },
+    ELS: {
+        ideal: "Feature-level changes should stay inside a small number of contexts and co-change should remain local.",
+        watch: "Low values often indicate hidden dependencies or a mismatch between design boundaries and evolution units.",
+        action: "Inspect the highest co-change context pairs and consider contract separation or reintegration.",
+    },
+    QSF: {
+        ideal: "Important scenarios should have explicit priority, target, and worst-acceptable values backed by observations.",
+        watch: "Low values often mean the discussion is pattern-first instead of scenario-first.",
+        action: "Narrow to the top scenarios and normalize benchmark or incident data into scenario observations.",
+    },
+    DDS: {
+        ideal: "Dependency direction should align with the constraints model and forbidden edges should be observable.",
+        watch: "Low values often indicate layer bypasses or reversed dependency direction.",
+        action: "Strengthen static rules around the layers with the most direction violations.",
+    },
+    BPS: {
+        ideal: "Internal boundaries should stay free from framework contamination and shared internal components.",
+        watch: "Low values often indicate adapter leaks or growing internal sharing across boundaries.",
+        action: "Separate framework-heavy code and reduce shared internal components.",
+    },
+    IPS: {
+        ideal: "Public contracts should stay stable and keep breaking-change risk low.",
+        watch: "Low values often indicate risky exports, internal imports, or schema-language issues.",
+        action: "Make contract files explicit and move public APIs toward interfaces, types, and DTOs.",
+    },
+    TIS: {
+        ideal: "Failure isolation and runtime containment should be explainable in both topology and runtime evidence.",
+        watch: "Low values often indicate shared resources or sync dependencies that cross boundaries.",
+        action: "Add explicit isolation boundaries to the topology model and reduce shared dependencies.",
+    },
+    OAS: {
+        ideal: "Latency, error, saturation, and pattern-runtime signals should be observable by traffic band.",
+        watch: "Low values often mean runtime behavior does not deliver the promise of the selected pattern.",
+        action: "Normalize telemetry by traffic band and add the minimum pattern-runtime observation set.",
+    },
+    AELS: {
+        ideal: "Co-change should stay localized at the architecture-boundary level and propagation cost should remain low.",
+        watch: "Low values often mean the boundary map does not match the real evolution unit.",
+        action: "Define the boundary map explicitly and review the highest cross-boundary co-change pairs.",
+    },
+    EES: {
+        ideal: "Delivery and locality should both improve so that speed and change locality coexist.",
+        watch: "Low values often indicate either missing delivery evidence or wide coordinated changes hidden behind speed.",
+        action: "Read lead time and co-change together to decide whether delivery or locality is the real bottleneck.",
+    },
+    CTI: {
+        ideal: "Deployable, pipeline, schema, and on-call tax should stay proportional to the gain being claimed.",
+        watch: "High values often mean the design is overpaying distributed-systems or async complexity tax.",
+        action: "Start by measuring deployables per team and on-call surface, then reduce the most expensive tax sources.",
+    },
+    APSI: {
+        ideal: "Use APSI only as a summary after reading the supporting metrics.",
+        watch: "Using it alone makes it easy to misread proxy values, neutral fallbacks, and partial evidence.",
+        action: "Check QSF, PCS proxy, OAS, EES, and CTI before using APSI in a decision.",
+    },
+};
+function formatMetricGuidance(metric) {
+    const guidance = METRIC_GUIDANCE[metric.metricId];
+    if (!guidance) {
+        return null;
+    }
+    return `- ${metric.metricId}: ideal=${guidance.ideal} watch=${guidance.watch} next=${guidance.action}`;
+}
+export function renderMetricGuidanceSection(metrics) {
+    const guidanceLines = metrics
+        .map((metric) => formatMetricGuidance(metric))
+        .filter((line) => Boolean(line));
+    if (guidanceLines.length === 0) {
+        return [];
+    }
+    return ["", "## Metric Guidance", ...guidanceLines];
+}

package/dist/src/core/report-shared-predicates.d.ts

@@ -0,0 +1,17 @@
+import type { ArchitectureScenarioQualitySummary, CommandResponse, DomainDesignPilotAnalysis, LocalityWatchlistItem, MetricScore } from "./contracts.js";
+export type ReportResponse = CommandResponse<{
+    domainId: string;
+    metrics: MetricScore[];
+    leakFindings?: unknown[];
+    violations?: unknown[];
+    pilot?: DomainDesignPilotAnalysis;
+    scenarioQuality?: ArchitectureScenarioQualitySummary;
+    localityWatchlist?: LocalityWatchlistItem[];
+}>;
+export type GateResponse = CommandResponse<{
+    domainId: string;
+    metrics: MetricScore[];
+}>;
+export declare function isArchitectureDomain(response: ReportResponse | GateResponse): boolean;
+export declare function dedupe(values: string[]): string[];
+export declare function proxyOrPartialUnknowns(metric: MetricScore): string[];

package/dist/src/core/report-shared-predicates.js

@@ -0,0 +1,9 @@
+export function isArchitectureDomain(response) {
+    return response.result.domainId === "architecture_design";
+}
+export function dedupe(values) {
+    return Array.from(new Set(values));
+}
+export function proxyOrPartialUnknowns(metric) {
+    return metric.unknowns.filter((entry) => /(proxy|partial|bridge|neutral|unobserved|approx)/iu.test(entry));
+}

package/dist/src/core/report-shared.d.ts

@@ -0,0 +1,4 @@
+export { formatMetric } from "./report-shared-format.js";
+export { renderMetricGuidanceSection } from "./report-shared-guidance.js";
+export type { GateResponse, ReportResponse } from "./report-shared-predicates.js";
+export { dedupe, isArchitectureDomain, proxyOrPartialUnknowns } from "./report-shared-predicates.js";

package/dist/src/core/report-shared.js

@@ -0,0 +1,3 @@
+export { formatMetric } from "./report-shared-format.js";
+export { renderMetricGuidanceSection } from "./report-shared-guidance.js";
+export { dedupe, isArchitectureDomain, proxyOrPartialUnknowns } from "./report-shared-predicates.js";

package/dist/src/core/report.d.ts

@@ -0,0 +1,3 @@
+export { evaluateGate } from "./report-gate.js";
+import { type ReportResponse } from "./report-shared.js";
+export declare function renderMarkdownReport(response: ReportResponse, profileName?: string): string;

package/dist/src/core/report.js

@@ -0,0 +1,10 @@
+import { renderArchitectureMarkdownReport } from "./report-architecture.js";
+import { renderDomainMarkdownReport } from "./report-domain.js";
+export { evaluateGate } from "./report-gate.js";
+import { isArchitectureDomain } from "./report-shared.js";
+export function renderMarkdownReport(response, profileName) {
+    if (isArchitectureDomain(response)) {
+        return renderArchitectureMarkdownReport(response, profileName);
+    }
+    return renderDomainMarkdownReport(response);
+}

package/dist/src/core/response.d.ts

@@ -0,0 +1,8 @@
+import { type CommandResponse, type CommandStatus, type Evidence, type ProvenanceRef } from "./contracts.js";
+export declare function clampConfidence(value: number): number;
+export declare function createEvidenceId(seed: string): string;
+export declare function createResponse<T>(result: T, options?: Partial<Omit<CommandResponse<T>, "result" | "version">>): CommandResponse<T>;
+export declare function mergeStatus(...statuses: CommandStatus[]): CommandStatus;
+export declare function confidenceFromSignals(signals: number[]): number;
+export declare function toEvidence(statement: string, source: Record<string, unknown>, linkedEntities?: string[], confidence?: number): Evidence;
+export declare function toProvenance(path: string, note?: string, line?: number): ProvenanceRef;

package/dist/src/core/response.js

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+import { OUTPUT_VERSION, } from "./contracts.js";
+import { maybeBuildMeasurementQualitySummary } from "./measurement-metadata.js";
+export function clampConfidence(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function createEvidenceId(seed) {
+    return `EV-${createHash("sha256").update(seed).digest("hex").slice(0, 8)}`;
+}
+export function createResponse(result, options) {
+    const confidence = clampConfidence(options?.confidence ?? 1);
+    const unknowns = options?.unknowns ?? [];
+    const inferredMeasurementQuality = maybeBuildMeasurementQualitySummary(result, unknowns, confidence);
+    const meta = options?.meta || inferredMeasurementQuality
+        ? {
+            ...(options?.meta ?? {}),
+            ...(!options?.meta?.measurementQuality && inferredMeasurementQuality
+                ? { measurementQuality: inferredMeasurementQuality }
+                : {}),
+        }
+        : undefined;
+    return {
+        status: options?.status ?? "ok",
+        result,
+        evidence: options?.evidence ?? [],
+        confidence,
+        unknowns,
+        diagnostics: options?.diagnostics ?? [],
+        progress: options?.progress ?? [],
+        provenance: options?.provenance ?? [],
+        ...(meta ? { meta } : {}),
+        version: OUTPUT_VERSION,
+    };
+}
+export function mergeStatus(...statuses) {
+    if (statuses.includes("error")) {
+        return "error";
+    }
+    if (statuses.includes("warning")) {
+        return "warning";
+    }
+    return "ok";
+}
+export function confidenceFromSignals(signals) {
+    if (signals.length === 0) {
+        return 0;
+    }
+    const total = signals.reduce((sum, current) => sum + clampConfidence(current), 0);
+    return clampConfidence(total / signals.length);
+}
+export function toEvidence(statement, source, linkedEntities, confidence = 1) {
+    return {
+        evidenceId: createEvidenceId(`${statement}:${JSON.stringify(source)}`),
+        type: "derived",
+        statement,
+        confidence: clampConfidence(confidence),
+        ...(linkedEntities ? { linkedEntities } : {}),
+        source,
+    };
+}
+export function toProvenance(path, note, line) {
+    return {
+        path,
+        ...(note ? { note } : {}),
+        ...(line !== undefined ? { line } : {}),
+    };
+}

package/dist/src/core/review-items.d.ts

@@ -0,0 +1,2 @@
+import type { CommandResponse, ReviewItem } from "./contracts.js";
+export declare function listReviewItems(response: CommandResponse<unknown>): ReviewItem[];