yarramate 0.4.0 → 0.6.0

package/dist/check-command.js

@@ -8,10 +8,23 @@ import { compileWorkspace } from './compiler.js';
 import { checkCoreContract, loadCoreContract, } from './core-contract.js';
 import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
 import { loadProjection } from './projection.js';
+import { reconcileEvidenceReports, } from './reconciliation.js';
 const Ajv2020 = Ajv2020Module.default;
+const strictFindingMessage = (finding) => {
+    const observed = finding.evidence.message === undefined
+        ? finding.evidence.uri
+        : `${finding.evidence.uri}: ${finding.evidence.message}`;
+    const assertion = finding.asserted === undefined
+        ? `Evidence contradicts ${finding.target.type} "${finding.target.id}"`
+        : `Evidence contradicts claim "${finding.target.id}": the model asserts ` +
+            `${finding.asserted.from} -> ${finding.asserted.to} (${finding.asserted.kind})`;
+    return (`${assertion}, but provider "${finding.provider}" observed otherwise ` +
+        `(${observed}); align the model or the evidence to pass --strict`);
+};
 export function runCheckCommand(options, cwd) {
     const json = options.includes('--json');
-    const paths = options.filter((option) => option !== '--json');
+    const strict = options.includes('--strict');
+    const paths = options.filter((option) => option !== '--json' && option !== '--strict');
     const unknownOption = paths.find((path) => path.startsWith('-'));
     if (unknownOption !== undefined || paths.length === 0) {
         return { exitCode: 2, stdout: '', stderr: usage };
@@ -171,6 +184,46 @@ export function runCheckCommand(options, cwd) {
         const diagnostics = result.ok
             ? optionalDiagnostics
             : result.diagnostics;
+        // Strict only tightens a passing check: base diagnostics already fail
+        // the gate, so contradictions are folded in only once everything else
+        // holds, and each one is anchored at the claim the model declares.
+        const strictEvaluation = strict && result.ok && ok
+            ? (() => {
+                const reports = evidenceEvaluation !== undefined && evidenceEvaluation.ok
+                    ? evidenceEvaluation.reports
+                    : [];
+                const graph = result.graph;
+                const contradicted = reconcileEvidenceReports('strict', reports, graph).findings.filter(({ result: outcome }) => outcome === 'contradicted');
+                return {
+                    observations: reports.reduce((total, report) => total + report.observations.length, 0),
+                    diagnostics: sortDiagnostics(contradicted.map((finding) => {
+                        const anchor = graph.claims.find(({ id }) => id === finding.target.id) ??
+                            graph.claims.find(({ subject, predicate }) => subject === finding.target.id &&
+                                predicate === 'yarramate/concept/kind') ??
+                            graph.claims.find(({ subject }) => subject === finding.target.id);
+                        return {
+                            severity: 'error',
+                            code: 'YM901',
+                            message: strictFindingMessage(finding),
+                            path: anchor?.source.path ?? finding.evidenceDocument,
+                            pointer: anchor?.source.pointer ?? '/',
+                            line: anchor?.source.line ?? 1,
+                            column: anchor?.source.column ?? 1,
+                        };
+                    })),
+                };
+            })()
+            : undefined;
+        const strictSummary = strictEvaluation === undefined
+            ? undefined
+            : {
+                observations: strictEvaluation.observations,
+                contradicted: strictEvaluation.diagnostics.length,
+            };
+        const strictOk = strictEvaluation === undefined
+            ? true
+            : strictEvaluation.diagnostics.length === 0;
+        const finalOk = ok && strictOk;
         const counted = result.ok
             ? (() => {
                 const states = new Set(result.graph.claims
@@ -186,8 +239,15 @@ export function runCheckCommand(options, cwd) {
             : undefined;
         if (json) {
             return {
-                exitCode: ok ? 0 : 1,
-                stdout: checkResultJson(ok, ok ? [] : diagnostics, ok ? counted : undefined),
+                exitCode: finalOk ? 0 : 1,
+                stdout: checkResultJson(finalOk, finalOk ? [] : ok ? strictEvaluation.diagnostics : diagnostics, finalOk ? counted : undefined, strictSummary),
+                stderr: '',
+            };
+        }
+        if (ok && !strictOk) {
+            return {
+                exitCode: 1,
+                stdout: humanDiagnostics(strictEvaluation.diagnostics),
                 stderr: '',
             };
         }
@@ -227,13 +287,19 @@ export function runCheckCommand(options, cwd) {
                     ]
                     : []),
             ].join(' and ');
+            const strictLine = strictSummary === undefined
+                ? ''
+                : strictSummary.observations === 0
+                    ? 'Strict: no evidence observations to evaluate\n'
+                    : `Strict: ${strictSummary.observations} ${strictSummary.observations === 1 ? 'observation' : 'observations'}, 0 contradicted\n`;
             return {
                 exitCode: 0,
                 stdout: `Checked ${checked} (` +
                     `${successfulCounts.concepts} ${successfulCounts.concepts === 1 ? 'concept' : 'concepts'}, ` +
                     `${successfulCounts.relationships} ${successfulCounts.relationships === 1 ? 'relationship' : 'relationships'}, ` +
                     `${successfulCounts.states} ${successfulCounts.states === 1 ? 'state' : 'states'}` +
-                    '): no errors\n',
+                    '): no errors\n' +
+                    strictLine,
                 stderr: '',
             };
         }

package/dist/cli-support.d.ts

@@ -5,13 +5,18 @@ export interface CliResult {
     readonly stderr: string;
 }
 export declare const isMainModule: (moduleUrl: string, entrypoint: string | undefined) => boolean;
-export declare const usage = "Usage:\n  yarramate init <directory>\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--description <text>] [--status <status>] [--mode <mode>] [--content <text>] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json]\n  yarramate new projection <projection.yaml> --id <id> [--version <v>] [--title <text>] [--description <text>] [--document <id> ...] [--subject <ref> ...] [--kind <qualified-kind> ...] [--relationships <mode>]\n  yarramate status <workspace.yaml> [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate context --subject <document-id>#<local-id> [--subject ...] <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n";
+export declare const packageVersion: string;
+export declare const versionResult: (binary: string) => CliResult;
+export declare const usage = "Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--description <text>] [--status <status>] [--mode <mode>] [--content <text>] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate new projection <projection.yaml> --id <id> [--version <v>] [--title <text>] [--description <text>] [--document <id> ...] [--subject <ref> ...] [--kind <qualified-kind> ...] [--relationships <mode>]\n  yarramate status <workspace.yaml> [--json]\n  yarramate next <projection.yaml> <workspace.yaml> [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate context --subject <document-id>#<local-id> [--subject ...] <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n";
 export declare const diagnosticJson: (diagnostics: unknown) => string;
 export declare const checkResultJson: (ok: boolean, diagnostics: unknown, counted?: {
     readonly documents: number;
     readonly concepts: number;
     readonly relationships: number;
     readonly states: number;
+}, strict?: {
+    readonly observations: number;
+    readonly contradicted: number;
 }) => string;
 export declare const humanDiagnostics: (diagnostics: readonly Pick<Diagnostic, "path" | "line" | "column" | "code" | "message">[]) => string;
 export declare const sortDiagnostics: <T extends Diagnostic>(diagnostics: readonly T[]) => T[];

package/dist/cli-support.js

@@ -3,6 +3,9 @@ import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseDocument } from 'yaml';
 import { loadWorkspaceManifest } from './workspace.js';
+import packageManifest from '../package.json' with {
+    type: 'json'
+};
 export const isMainModule = (moduleUrl, entrypoint) => {
     if (entrypoint === undefined)
         return false;
@@ -14,16 +17,23 @@ export const isMainModule = (moduleUrl, entrypoint) => {
         return false;
     }
 };
-export const usage = 'Usage:\n  yarramate init <directory>\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--description <text>] [--status <status>] [--mode <mode>] [--content <text>] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json]\n  yarramate new projection <projection.yaml> --id <id> [--version <v>] [--title <text>] [--description <text>] [--document <id> ...] [--subject <ref> ...] [--kind <qualified-kind> ...] [--relationships <mode>]\n  yarramate status <workspace.yaml> [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate context --subject <document-id>#<local-id> [--subject ...] <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n';
+export const packageVersion = packageManifest.version;
+export const versionResult = (binary) => ({
+    exitCode: 0,
+    stdout: `${binary} ${packageVersion}\n`,
+    stderr: '',
+});
+export const usage = 'Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--description <text>] [--status <status>] [--mode <mode>] [--content <text>] [--reference <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate new projection <projection.yaml> --id <id> [--version <v>] [--title <text>] [--description <text>] [--document <id> ...] [--subject <ref> ...] [--kind <qualified-kind> ...] [--relationships <mode>]\n  yarramate status <workspace.yaml> [--json]\n  yarramate next <projection.yaml> <workspace.yaml> [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate context --subject <document-id>#<local-id> [--subject ...] <source.yaml> [source.yaml ...] [--budget <tokens>]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n';
 export const diagnosticJson = (diagnostics) => `${JSON.stringify({
     format: 'yarramate/diagnostic-result/v1',
     diagnostics,
 }, null, 2)}\n`;
-export const checkResultJson = (ok, diagnostics, counted) => `${JSON.stringify({
+export const checkResultJson = (ok, diagnostics, counted, strict) => `${JSON.stringify({
     format: 'yarramate/check-result/v1',
     ok,
     diagnostics,
     ...(counted === undefined ? {} : { counted }),
+    ...(strict === undefined ? {} : { strict }),
 }, null, 2)}\n`;
 export const humanDiagnostics = (diagnostics) => diagnostics
     .map((diagnostic) => `${diagnostic.path}:${diagnostic.line}:${diagnostic.column} error ${diagnostic.code} ${diagnostic.message}\n`)

package/dist/cli.js

@@ -5,9 +5,10 @@ import { isSeq, parseDocument } from 'yaml';
 import { compileWorkspace, compileWorkspaceWithProfileContext, } from './compiler.js';
 import { compareArchitectureStates } from './architecture-state.js';
 import { serializeSemanticGraph } from './graph.js';
-import { diagnosticJson, humanDiagnostics, isMainModule, resolveCliWorkspaceSources, usage, } from './cli-support.js';
+import { diagnosticJson, humanDiagnostics, isMainModule, resolveCliWorkspaceSources, usage, versionResult, } from './cli-support.js';
 import { runCheckCommand } from './check-command.js';
 import { runNewCommand } from './new-command.js';
+import { runNextCommand } from './next-command.js';
 import { runStatusCommand } from './status-command.js';
 import { evaluateEvidence, evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
 import { reconcileEvidenceReports } from './reconciliation.js';
@@ -297,7 +298,7 @@ const runReconciliation = (options, cwd) => {
         }
         return {
             exitCode: 0,
-            stdout: `${JSON.stringify(reconcileEvidenceReports(loadedWorkspace.workspace.id, evaluation.reports), null, 2)}\n`,
+            stdout: `${JSON.stringify(reconcileEvidenceReports(loadedWorkspace.workspace.id, evaluation.reports, compilation.graph), null, 2)}\n`,
             stderr: '',
         };
     }
@@ -353,8 +354,10 @@ const runStateComparison = (options, cwd) => {
     }
 };
 const runInit = (options, cwd) => {
-    const target = options[0];
-    if (options.length !== 1 ||
+    const positional = options.filter((option) => option !== '--no-pointer');
+    const writePointer = positional.length === options.length;
+    const target = positional[0];
+    if (positional.length !== 1 ||
         target === undefined ||
         target.startsWith('-')) {
         return { exitCode: 2, stdout: '', stderr: usage };
@@ -389,10 +392,8 @@ const runInit = (options, cwd) => {
         'projections: []\n' +
         'adapterMappings: []\n' +
         'evidence: []\n', 'utf8');
-    const agentsPath = resolve(workspaceRoot, 'AGENTS.md');
-    const displayAgentsPath = relative(cwd, agentsPath);
-    const agentsMarker = '## YarraMate architecture';
-    const agentsBlock = `${agentsMarker}\n` +
+    const pointerMarker = '## YarraMate architecture';
+    const pointerBlock = `${pointerMarker}\n` +
         '\n' +
         'This repository declares its architecture as canonical, versioned\n' +
         'YarraMate documents in `.yarramate/`. When prose documentation and the\n' +
@@ -403,24 +404,34 @@ const runInit = (options, cwd) => {
         '- Bounded task context: `yarramate context <projection.yaml> .yarramate/workspace.yaml`\n' +
         '\n' +
         'Author native documents only; never edit generated output.\n';
-    let agentsNote;
-    if (!existsSync(agentsPath)) {
-        writeFileSync(agentsPath, agentsBlock, 'utf8');
-        agentsNote = `Created ${displayAgentsPath} with the YarraMate pointer\n`;
-    }
-    else {
-        const existingAgents = readFileSync(agentsPath, 'utf8');
-        if (existingAgents.includes(agentsMarker)) {
-            agentsNote = `${displayAgentsPath} already declares the YarraMate pointer\n`;
-        }
-        else {
-            writeFileSync(agentsPath, `${existingAgents.replace(/\n*$/, '\n\n')}${agentsBlock}`, 'utf8');
-            agentsNote = `Extended ${displayAgentsPath} with the YarraMate pointer\n`;
+    // Harnesses look in different files: AGENTS.md is the cross-harness
+    // convention, while Claude Code auto-loads CLAUDE.md only. Delivering to
+    // both is what makes the pointer reach an agent without instruction.
+    const pointerNotes = [];
+    if (writePointer) {
+        for (const pointerFile of ['AGENTS.md', 'CLAUDE.md']) {
+            const pointerPath = resolve(workspaceRoot, pointerFile);
+            const displayPointerPath = relative(cwd, pointerPath);
+            if (!existsSync(pointerPath)) {
+                writeFileSync(pointerPath, pointerBlock, 'utf8');
+                pointerNotes.push(`Created ${displayPointerPath} with the YarraMate pointer\n`);
+            }
+            else {
+                const existingPointer = readFileSync(pointerPath, 'utf8');
+                if (existingPointer.includes(pointerMarker)) {
+                    pointerNotes.push(`${displayPointerPath} already declares the YarraMate pointer\n`);
+                }
+                else {
+                    writeFileSync(pointerPath, `${existingPointer.replace(/\n*$/, '\n\n')}${pointerBlock}`, 'utf8');
+                    pointerNotes.push(`Extended ${displayPointerPath} with the YarraMate pointer\n`);
+                }
+            }
         }
     }
     return {
         exitCode: 0,
-        stdout: `Created ${displayPath} and ${displayManifestPath}\n` + agentsNote,
+        stdout: `Created ${displayPath} and ${displayManifestPath}\n` +
+            pointerNotes.join(''),
         stderr: '',
     };
 };
@@ -706,6 +717,9 @@ export function runCli(args, cwd = process.cwd()) {
     if (command === '--help' || command === '-h' || command === 'help') {
         return { exitCode: 0, stdout: usage, stderr: '' };
     }
+    if (command === '--version' || command === '-v') {
+        return versionResult('yarramate');
+    }
     if (command === 'init') {
         return runInit(options, cwd);
     }
@@ -744,6 +758,9 @@ export function runCli(args, cwd = process.cwd()) {
     if (command === 'new') {
         return runNewCommand(options, cwd);
     }
+    if (command === 'next') {
+        return runNextCommand(options, cwd);
+    }
     return { exitCode: 2, stdout: '', stderr: usage };
 }
 if (isMainModule(import.meta.url, process.argv[1])) {

package/dist/compiler.js

@@ -14,6 +14,23 @@ const validateDocument = new Ajv2020({ allErrors: true }).compile(documentSchema
 const validateProfile = new Ajv2020({ allErrors: true }).compile(profileSchema);
 const compareById = (left, right) => left.id.localeCompare(right.id);
 const presenceClaimId = (subject, state) => `${subject}~present-in-${Buffer.from(state, 'utf8').toString('hex')}`;
+const describeAspect = (aspect) => aspect.replace('-', ' ');
+// Candidate order is the policy-matrix declaration order: the resolved kind
+// map inserts core policies first, then extension kinds as declared.
+const candidateKindHint = (kinds, rejected, sourceAspect, targetAspect) => {
+    const candidates = [...kinds]
+        .filter(([id, kind]) => id !== rejected &&
+        (kind.sourceAspects?.includes(sourceAspect) ?? true) &&
+        (kind.targetAspects?.includes(targetAspect) ?? true))
+        .map(([id]) => id);
+    if (candidates.length === 0) {
+        return '';
+    }
+    const observed = sourceAspect === targetAspect
+        ? `both endpoints are ${describeAspect(sourceAspect)}`
+        : `source is ${describeAspect(sourceAspect)} and target is ${describeAspect(targetAspect)}`;
+    return `; ${observed}; valid candidates: ${candidates.join(', ')}`;
+};
 const diagnosticFailure = (diagnostics) => ({
     ok: false,
     diagnostics: [...diagnostics].sort((left, right) => left.path.localeCompare(right.path) ||
@@ -54,6 +71,7 @@ function compileWorkspaceResolved(sources) {
             lineage: [`${coreProfile}#${policy.id}`],
             sourceAspects: policy.sourceAspects,
             targetAspects: policy.targetAspects,
+            repair: policy.repair,
         };
         coreRelationshipKinds.set(policy.id, resolved);
         relationshipKindByIdentity.set(resolved.identity, resolved);
@@ -778,27 +796,35 @@ function compileWorkspaceResolved(sources) {
             }
             const policy = selectedProfile.relationshipKinds.get(relationship.kind);
             if (policy !== undefined) {
-                for (const endpoint of ['source', 'target']) {
-                    const reference = endpoint === 'source' ? relationship.from : relationship.to;
+                const aspectOf = (reference) => {
                     const resolvedConcept = conceptByQualifiedId.get(qualifyReference(value.id, reference));
-                    const kind = resolvedConcept === undefined
+                    return resolvedConcept === undefined
                         ? undefined
                         : profiles
                             .get(resolvedConcept.profile)
-                            ?.conceptKinds.get(resolvedConcept.concept.kind);
+                            ?.conceptKinds.get(resolvedConcept.concept.kind)?.aspect;
+                };
+                const sourceAspect = aspectOf(relationship.from);
+                const targetAspect = aspectOf(relationship.to);
+                const candidates = sourceAspect === undefined || targetAspect === undefined
+                    ? ''
+                    : candidateKindHint(selectedProfile.relationshipKinds, relationship.kind, sourceAspect, targetAspect);
+                for (const endpoint of ['source', 'target']) {
+                    const reference = endpoint === 'source' ? relationship.from : relationship.to;
+                    const aspect = endpoint === 'source' ? sourceAspect : targetAspect;
                     const allowed = endpoint === 'source'
                         ? policy.sourceAspects
                         : policy.targetAspects;
-                    if (kind !== undefined &&
+                    if (aspect !== undefined &&
                         allowed !== undefined &&
-                        !allowed.includes(kind.aspect)) {
+                        !allowed.includes(aspect)) {
                         const field = endpoint === 'source' ? 'from' : 'to';
                         const pointer = `/relationships/${index}/${field}`;
                         const source = location(['relationships', index, field], pointer);
                         diagnostics.push({
                             severity: 'error',
                             code: 'YM404',
-                            message: `Relationship "${relationship.kind}" requires a ${endpoint} with aspect ${allowed.map((aspect) => `"${aspect}"`).join(' or ')}; "${reference}" has aspect "${kind.aspect}"`,
+                            message: `Relationship "${relationship.kind}" requires a ${endpoint} with aspect ${allowed.map((entry) => `"${entry}"`).join(' or ')}; "${reference}" has aspect "${aspect}"${policy.repair === undefined ? '' : `; ${policy.repair}`}${candidates}`,
                             path: input.path,
                             pointer,
                             line: source.line,

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { checkCoreContract, loadCoreContract, type CoreContract, type CoreContra
 export { compareArchitectureStates, type StateComparison, type StateComparisonIssue, type StateComparisonResult, } from './architecture-state.js';
 export { loadWorkspaceManifest, type ResolvedWorkspace, type WorkspaceManifest, type WorkspaceManifestResult, } from './workspace.js';
 export { evaluateEvidence, evaluateEvidenceWorkspace, loadEvidence, type EvidenceDocument, type EvidenceEvaluationResult, type EvidenceLoadResult, type EvidenceLocator, type EvidenceObservation, type EvidenceReport, type EvidenceResult, type EvidenceWorkspaceEvaluationResult, } from './evidence.js';
-export { reconcileEvidenceReports, type ReconciliationFinding, type ReconciliationReport, } from './reconciliation.js';
+export { reconcileEvidenceReports, type AssertedRelationship, type ReconciliationFinding, type ReconciliationReport, } from './reconciliation.js';
 export type { CompilationResult, ContextualCompilationResult, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, type AdapterMapping, type AdapterMappingLoadResult, type AdapterMappingValidationResult, type AdapterMappingsValidationResult, type AdapterSubjectMapping, } from './adapter-mapping.js';

package/dist/next-command.d.ts

@@ -0,0 +1,25 @@
+import { type CliResult } from './cli-support.js';
+interface EvidenceCoverage {
+    readonly observations: number;
+    readonly confirmed: number;
+    readonly contradicted: number;
+    readonly unknown: number;
+    readonly notObserved: number;
+}
+export interface NextSubject {
+    readonly id: string;
+    readonly kind: string;
+    readonly name?: string;
+    readonly dependsOn: readonly string[];
+    readonly requiredBy: readonly string[];
+    readonly evidence: EvidenceCoverage;
+    readonly cycle?: true;
+}
+export interface NextResult {
+    readonly format: 'yarramate/next-result/v1';
+    readonly workspace: string;
+    readonly projection: string;
+    readonly subjects: readonly NextSubject[];
+}
+export declare function runNextCommand(options: readonly string[], cwd: string): CliResult;
+export {};