noteconnection 1.8.0 → 1.9.0

package/dist/src/export/WorkspaceExportBundle.test.js

@@ -834,6 +834,49 @@ describe('WorkspaceExportBundle', () => {
                                 leakedInternalFragments: [],
                                 gates: [],
                             },
+                            graphAnswerPlan: {
+                                intent: 'definition',
+                                depth: 'standard',
+                                anchorAtomId: 'atom_reflection',
+                                leadClaimId: 'claim_reflection',
+                                requiredRoles: ['definition', 'mechanism'],
+                                omittedCandidates: [],
+                                answerTaskPlan: {
+                                    schemaVersion: '1',
+                                    primarySubject: 'Reflection',
+                                    requestedDepth: 'standard',
+                                    subtasks: [
+                                        { subtaskId: 'definition', kind: 'definition', subject: 'Reflection', required: true, expectedOutput: 'direct_answer' },
+                                        { subtaskId: 'learning_route', kind: 'learning_route', subject: 'Reflection', required: true, expectedOutput: 'ordered_nodes' },
+                                    ],
+                                    learningRoute: [
+                                        { nodeId: 'atom_foundation', title: 'Foundation', role: 'prerequisite', order: 1, orderingBasis: 'explicit_prerequisite', evidenceRefs: ['edge_1'], reason: 'foundation' },
+                                        { nodeId: 'atom_reflection', title: 'Reflection', role: 'core', order: 2, orderingBasis: 'explicit_prerequisite', evidenceRefs: ['claim_reflection'], reason: 'core' },
+                                        { nodeId: 'atom_measurement', title: 'Measurement', role: 'application', order: 3, orderingBasis: 'source_order', evidenceRefs: ['claim_measurement'], reason: 'application' },
+                                    ],
+                                },
+                                claims: [
+                                    { claimId: 'claim_reflection', required: true },
+                                    { claimId: 'claim_mechanism', required: true },
+                                ],
+                            },
+                            graphAnswerCoverage: {
+                                passed: true,
+                                applicable: true,
+                                requiredClaimIds: ['claim_reflection', 'claim_mechanism'],
+                                coveredClaimIds: ['claim_reflection', 'claim_mechanism'],
+                                missingRequiredClaimIds: [],
+                                coverageScore: 1,
+                            },
+                            answerTaskCoverage: {
+                                passed: true,
+                                applicable: true,
+                                coveredSubtaskIds: ['definition', 'learning_route'],
+                                missingRequiredSubtaskIds: [],
+                                subtaskCoverage: [],
+                                learningRouteNodeCount: 3,
+                                coverageScore: 1,
+                            },
                         },
                         graphContext: {
                             anchorAtomId: 'atom_reflection',
@@ -914,6 +957,24 @@ describe('WorkspaceExportBundle', () => {
                     temporalWarningCount: 0,
                     missingLookupCount: 0,
                 }),
+                graphAnswerPlan: {
+                    intent: 'definition',
+                    depth: 'standard',
+                    anchorAtomId: 'atom_reflection',
+                    claimCount: 2,
+                    requiredClaimCount: 2,
+                    requiredRoles: ['definition', 'mechanism'],
+                    coverageScore: 1,
+                    missingRequiredClaimIds: [],
+                },
+                answerTask: {
+                    primarySubject: 'Reflection',
+                    subtaskCount: 2,
+                    requiredSubtaskCount: 2,
+                    missingRequiredSubtaskIds: [],
+                    learningRouteNodeCount: 3,
+                    coverageScore: 1,
+                },
             }),
             expect.objectContaining({
                 artifactId: 'workflow_artifact_knowledge_run_2',

package/dist/src/foundation.release.evidence.contract.test.js

@@ -40,16 +40,51 @@ describe('foundation release evidence freshness contract', () => {
     const repoRoot = path.resolve(__dirname, '..');
     const packageJsonPath = path.join(repoRoot, 'package.json');
     const scriptPath = path.join(repoRoot, 'scripts', 'verify-foundation-release-evidence.js');
+    const provenance = require('../scripts/foundation-evidence-provenance');
+    const fingerprints = require('../scripts/sidecar-build-fingerprint');
+    let fixtureIdentity;
     function readJson(filePath) {
         const raw = fs.readFileSync(filePath, 'utf8');
         return JSON.parse(raw);
     }
     function createTempReportRoot() {
-        return fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-foundation-release-evidence-'));
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-foundation-release-evidence-'));
+        fs.mkdirSync(path.join(root, 'dist', 'src'), { recursive: true });
+        fs.mkdirSync(path.join(root, 'src-tauri', 'bin'), { recursive: true });
+        fs.writeFileSync(path.join(root, 'dist', 'src', 'server.js'), 'fixture runtime');
+        const sidecar = path.join(root, 'src-tauri', 'bin', 'fixture-sidecar');
+        fs.writeFileSync(sidecar, 'fixture packaged runtime');
+        fixtureIdentity = { ...provenance.readFoundationRuntimeIdentity(root, sidecar), sourceTreeHash: fingerprints.computeSidecarSourceFingerprint(repoRoot).digest };
+        return root;
     }
     function writeJson(filePath, value) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        const report = structuredClone(value);
+        if (report.profileRuns) {
+            report.host = { nodeVersion: process.version, ...report.host };
+            report.provenance = {
+                schemaVersion: 1, runId: `${report.host.evidenceHostId}-${report.verifiedAt}`,
+                sourceRevision: 'a'.repeat(40), ...fixtureIdentity, workloadHash: provenance.foundationWorkloadHash(report),
+            };
+            for (const profile of report.profileRuns)
+                for (const mode of profile.modes) {
+                    mode.runtime = { ...report.host };
+                    if (mode.soak) {
+                        const provided = new Map(mode.soak.gates.map((gate) => [gate.gateId, gate]));
+                        mode.soak.gates = ['startup_p95', 'startup_max', 'ingest_p95', 'ingest_max', 'readiness_p95', 'diagnostics_p95', 'query_p95', 'query_max'].map(gateId => ({
+                            observedMs: 100, maxAllowedMs: 2500, sampleCount: 8, passed: true, gateId, ...provided.get(gateId),
+                        }));
+                    }
+                    if (mode.releaseGates) {
+                        const provided = new Map(mode.releaseGates.gates.map((gate) => [gate.gateId, gate]));
+                        mode.releaseGates.gates = ['startup_p95', 'ingest_p95', 'diagnostics_p95', 'query_p95', 'query_max', 'expected_recall'].map(gateId => ({
+                            observed: gateId === 'expected_recall' ? 1 : 100, required: gateId === 'expected_recall' ? 1 : 2500,
+                            comparison: gateId === 'expected_recall' ? 'gte' : 'lte', sampleCount: 8, passed: true, gateId, ...provided.get(gateId),
+                        }));
+                    }
+                }
+        }
+        fs.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
     }
     function buildPassingSqliteReport(verifiedAt, host = { platform: 'win32', arch: 'x64', evidenceHostId: 'windows-ci-a' }) {
         return {
@@ -203,7 +238,7 @@ describe('foundation release evidence freshness contract', () => {
         try {
             writeJson(sqliteReportPath, buildPassingSqliteReport('2026-06-05T23:00:00.000Z'));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z'));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -233,7 +268,7 @@ describe('foundation release evidence freshness contract', () => {
         try {
             writeJson(sqliteReportPath, buildPassingSqliteReport('2026-06-01T00:00:00.000Z'));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z'));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -246,6 +281,89 @@ describe('foundation release evidence freshness contract', () => {
             fs.rmSync(tempRoot, { recursive: true, force: true });
         }
     });
+    test('a later matrix run does not hide a fresh dated SQLite soak', () => {
+        const verifier = require(scriptPath);
+        const tempRoot = createTempReportRoot();
+        const sqliteReportPath = path.join(tempRoot, 'foundation-sqlite-runtime-report-latest.json');
+        const annReportPath = path.join(tempRoot, 'foundation-ann-runtime-report-latest.json');
+        try {
+            writeJson(sqliteReportPath, { ...buildPassingSqliteReport('2026-06-05T23:30:00.000Z'), suiteKind: 'matrix' });
+            writeJson(path.join(tempRoot, 'foundation-sqlite-runtime-report-2026-06-05T23-00-00.json'), buildPassingSqliteReport('2026-06-05T23:00:00.000Z'));
+            writeJson(annReportPath, buildPassingAnnReport('2026-06-05T23:00:00.000Z'));
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot, sqliteReportPath, annReportPath, now: new Date('2026-06-06T00:00:00Z') });
+            expect(result.ok).toBe(true);
+            expect(result.summary.sqlite.reportPath).toContain('2026-06-05T23-00-00');
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('latest and dated copies of one run do not count as repeated evidence', () => {
+        const verifier = require(scriptPath);
+        const tempRoot = createTempReportRoot();
+        const sqliteReportPath = path.join(tempRoot, 'foundation-sqlite-runtime-report-latest.json');
+        const annReportPath = path.join(tempRoot, 'foundation-ann-runtime-report-latest.json');
+        try {
+            const sqlite = buildPassingSqliteReport('2026-06-05T23:00:00.000Z');
+            const ann = buildPassingAnnReport('2026-06-05T23:00:00.000Z');
+            writeJson(sqliteReportPath, sqlite);
+            writeJson(annReportPath, ann);
+            writeJson(path.join(tempRoot, 'foundation-sqlite-runtime-report-copy.json'), sqlite);
+            writeJson(path.join(tempRoot, 'foundation-ann-runtime-report-copy.json'), ann);
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot, sqliteReportPath, annReportPath, minReportCount: 2, now: new Date('2026-06-06T00:00:00Z') });
+            expect(result.ok).toBe(false);
+            expect(result.summary.sqlite.reportCount).toBe(1);
+            expect(result.summary.ann.reportCount).toBe(1);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test.each([
+        ['missing provenance', (report) => { delete report.provenance; }],
+        ['wrong source', (report) => { report.provenance.sourceTreeHash = 'f'.repeat(64); }],
+        ['wrong artifact', (report) => { report.provenance.artifacts.packaged_sidecar.sha256 = 'f'.repeat(64); }],
+        ['changed workload', (report) => { report.profileRuns[0].workloadProfile.documentCount++; }],
+        ['unsupported runtime', (report) => { report.profileRuns[0].modes[0].runtime.nodeVersion = 'v20.19.0'; }],
+        ['future report', (report) => { report.verifiedAt = '2026-06-07T00:00:00Z'; }],
+        ['missing gate', (report) => { report.profileRuns[0].modes[0].soak.gates.pop(); }],
+        ['unsubstantiated pass', (report) => { report.profileRuns[0].modes[0].soak.gates[0].observedMs = 999999; }],
+    ])('rejects %s even if the report declares passing gates', (_name, mutate) => {
+        const verifier = require(scriptPath);
+        const tempRoot = createTempReportRoot();
+        const sqliteReportPath = path.join(tempRoot, 'foundation-sqlite-runtime-report-latest.json');
+        const annReportPath = path.join(tempRoot, 'foundation-ann-runtime-report-latest.json');
+        try {
+            writeJson(sqliteReportPath, buildPassingSqliteReport('2026-06-05T23:00:00Z'));
+            writeJson(annReportPath, buildPassingAnnReport('2026-06-05T23:00:00Z'));
+            const report = readJson(sqliteReportPath);
+            mutate(report);
+            fs.writeFileSync(sqliteReportPath, JSON.stringify(report));
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot, sqliteReportPath, annReportPath, now: new Date('2026-06-06T00:00:00Z') });
+            expect(result.ok).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('an eligible recent failure is not masked by an older passing soak', () => {
+        const verifier = require(scriptPath);
+        const tempRoot = createTempReportRoot();
+        const sqliteReportPath = path.join(tempRoot, 'foundation-sqlite-runtime-report-latest.json');
+        const annReportPath = path.join(tempRoot, 'foundation-ann-runtime-report-latest.json');
+        try {
+            const failed = buildPassingSqliteReport('2026-06-05T23:30:00.000Z');
+            failed.profileRuns[0].modes[0].soak.pass = false;
+            writeJson(sqliteReportPath, failed);
+            writeJson(path.join(tempRoot, 'foundation-sqlite-runtime-report-earlier.json'), buildPassingSqliteReport('2026-06-05T23:00:00.000Z'));
+            writeJson(annReportPath, buildPassingAnnReport('2026-06-05T23:00:00.000Z'));
+            expect(verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot, sqliteReportPath, annReportPath, now: new Date('2026-06-06T00:00:00Z') }).ok).toBe(false);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
     test('accepts repeated sqlite and ANN release evidence when enough fresh history reports exist', () => {
         const verifier = require(scriptPath);
         const tempRoot = createTempReportRoot();
@@ -257,7 +375,7 @@ describe('foundation release evidence freshness contract', () => {
             writeJson(path.join(tempRoot, 'sqlite', 'foundation-sqlite-runtime-report-2026-06-05T22-30-00-000Z.json'), buildPassingSqliteReport('2026-06-05T22:30:00.000Z'));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z'));
             writeJson(path.join(tempRoot, 'ann', 'foundation-ann-runtime-report-2026-06-05T21-30-00-000Z.json'), buildPassingAnnReport('2026-06-05T21:30:00.000Z'));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -292,7 +410,7 @@ describe('foundation release evidence freshness contract', () => {
             writeJson(path.join(tempRoot, 'sqlite', 'foundation-sqlite-runtime-report-2026-06-05T22-30-00-000Z.json'), buildPassingSqliteReport('2026-06-05T22:30:00.000Z', linuxHost));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z', windowsHost));
             writeJson(path.join(tempRoot, 'ann', 'foundation-ann-runtime-report-2026-06-05T21-30-00-000Z.json'), buildPassingAnnReport('2026-06-05T21:30:00.000Z', linuxHost));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -331,7 +449,7 @@ describe('foundation release evidence freshness contract', () => {
             writeJson(path.join(tempRoot, 'sqlite', 'foundation-sqlite-runtime-report-2026-06-05T22-30-00-000Z.json'), buildPassingSqliteReport('2026-06-05T22:30:00.000Z', windowsHost));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z', windowsHost));
             writeJson(path.join(tempRoot, 'ann', 'foundation-ann-runtime-report-2026-06-05T21-30-00-000Z.json'), buildPassingAnnReport('2026-06-05T21:30:00.000Z', windowsHost));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -356,7 +474,7 @@ describe('foundation release evidence freshness contract', () => {
         try {
             writeJson(sqliteReportPath, buildPassingSqliteReport('2026-06-05T23:00:00.000Z'));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z'));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,
@@ -382,7 +500,7 @@ describe('foundation release evidence freshness contract', () => {
             writeJson(path.join(tempRoot, 'sqlite', 'foundation-sqlite-runtime-report-2026-05-30T00-00-00-000Z.json'), buildPassingSqliteReport('2026-05-30T00:00:00.000Z'));
             writeJson(annReportPath, buildPassingAnnReport('2026-06-05T22:00:00.000Z'));
             writeJson(path.join(tempRoot, 'ann', 'foundation-ann-runtime-report-2026-06-05T21-00-00-000Z.json'), buildNonReleaseAnnReport('2026-06-05T21:00:00.000Z'));
-            const result = verifier.verifyFoundationReleaseEvidence({
+            const result = verifier.verifyFoundationReleaseEvidence({ artifactRoot: tempRoot,
                 sqliteReportPath,
                 annReportPath,
                 now,

package/dist/src/foundation.sqlite.runtime.contract.test.js

@@ -68,6 +68,12 @@ describe('foundation sqlite runtime verification contract', () => {
         expect(source).toContain('/api/knowledge/query');
         expect(source).toContain("graphBackendSignalKind === 'embedded_graphdb'");
         expect(source).toContain("storageEngine === 'sqlite'");
+        expect(source).toContain("requestedProvider === 'sqlite'");
+        expect(source).toContain("resolvedProvider === 'sqlite'");
+        expect(source).toContain('fallbackReason');
+        expect(source).toContain("storageRequestedProvider === 'sqlite'");
+        expect(source).toContain("storageResolvedProvider === 'sqlite'");
+        expect(source).toContain('storageSupportsSqlite === true');
         expect(source).toContain("usingFallback !== true");
         expect(source).toContain("genericQuery: 'persist graph content restart sqlite proof'");
         expect(source).toContain('graphDbLastSnapshotMetadata');