@tenphi/akno-core 0.13.1 → 0.13.3

package/dist/maintenance/plans.js

@@ -19,6 +19,7 @@ import { hasInlineMergeConflict, matchesConflictPath, quarantineReasonsForPath,
 import { activeDreamRuns, getDreamRun, latestDreamRun, latestFullDreamRun, listDreamRuns, } from "./runs.js";
 import { declaringRule, effectiveRule } from "../rules/compile.js";
 import { configuredMaintenanceAuthority } from "./profile.js";
+import { OBSERVATION_SCOPE_PROMPT_VERSION, observationScopeCandidateHash, observationScopeContextHash, } from "./observation-scope.js";
 import { createMaintenanceBudget, maintenanceBudgetReceipt, reserveMaintenanceBudget, } from "./budget.js";
 import { managedItemOperationsIssue, } from "./managed-items.js";
 import { rewritePageLinks, rewriteRelocatedPageReferences } from "./rule-drift.js";
@@ -164,6 +165,22 @@ function createInferencePlan(ctx, mode, kind, drafts, policy) {
             ...(draft.observationQualificationIssue
                 ? { observationQualificationIssue: draft.observationQualificationIssue }
                 : {}),
+            ...(draft.observationScopeAssessment
+                ? { observationScopeAssessment: draft.observationScopeAssessment }
+                : {}),
+            ...(draft.observationScopeCandidateHash
+                ? { observationScopeCandidateHash: draft.observationScopeCandidateHash }
+                : {}),
+            ...(draft.observationScopeContextHash
+                ? { observationScopeContextHash: draft.observationScopeContextHash }
+                : {}),
+            ...(draft.observationScopePromptVersion
+                ? { observationScopePromptVersion: draft.observationScopePromptVersion }
+                : {}),
+            ...(draft.observationScopeModel ? { observationScopeModel: draft.observationScopeModel } : {}),
+            ...(draft.observationScopeNarrowed !== undefined
+                ? { observationScopeNarrowed: draft.observationScopeNarrowed }
+                : {}),
             ...(entry.reflectionObservationId ? { reflectionObservationId: entry.reflectionObservationId } : {}),
             ...(entry.reflectionPayloadHash ? { reflectionPayloadHash: entry.reflectionPayloadHash } : {}),
         })),
@@ -175,6 +192,9 @@ function createInferencePlan(ctx, mode, kind, drafts, policy) {
                     : 'at least three distinct live observation sources',
                 status: 'passed',
             },
+            ...(draft.observationScopeAssessment
+                ? [{ name: 'exact candidate passed separate evidence-scope assessment', status: 'passed' }]
+                : []),
             {
                 name: kind === 'observe' ? 'marker-owned observation block shape' : 'append-only derived principle shape',
                 status: 'passed',
@@ -1425,11 +1445,22 @@ function intersects(left, right) {
             return true;
     return false;
 }
-/** Oldest unfinished plan for restart recovery; fresh planning waits until it is resolved. */
+/**
+ * Oldest plan with work that can actually progress after restart.
+ *
+ * Older versions could leave a mixed plan as `partially_completed` after its only remaining
+ * items became blocked, stale, or verification-failed. Plan status alone therefore cannot decide
+ * whether a plan is resumable: selecting that residual forever would starve independent work.
+ */
 export function findActiveMaintenancePlan(ctx, mode, phase) {
     const row = ctx.store.db
         .prepare(`SELECT id FROM maintenance_plans WHERE mode = ? AND phase = ?
        AND status NOT IN ('completed', 'failed', 'superseded')
+       AND EXISTS (
+         SELECT 1 FROM maintenance_items item
+          WHERE item.plan_id = maintenance_plans.id
+            AND item.status IN ('proposed', 'approved', 'applying', 'verification_pending')
+       )
        ORDER BY rowid LIMIT 1`)
         .get(mode, phase);
     return row ? getMaintenancePlan(ctx, row.id) : null;
@@ -2746,10 +2777,24 @@ async function indexMaintenanceItem(ctx, item, documentState = 'after') {
     await Promise.all(paths.map((relPath) => safeOperationPath(ctx, relPath)));
     alignRelocatedPageRow(ctx, item, documentState);
     alignMovedDocumentRows(ctx, item.operations, documentState);
+    const preserveDerivedViews = item.kind === 'observe' &&
+        item.evidence.some((entry) => entry.source === item.subject) &&
+        observationOperationIssue(ctx, item, item.operations) === null
+        ? item.operations.flatMap((operation) => operation.type === 'replace'
+            ? [
+                {
+                    relPath: operation.relPath,
+                    fromBodyHash: parsePage(operation.relPath, documentState === 'after' ? operation.before : operation.after).bodyHash,
+                    toBodyHash: parsePage(operation.relPath, documentState === 'after' ? operation.after : operation.before).bodyHash,
+                },
+            ]
+            : [])
+        : [];
     await ctx.indexer.run({
         only: paths,
         modelPaths: [],
         ...(item.kind === 'adopt' ? { reindexUnchanged: true } : {}),
+        ...(preserveDerivedViews.length > 0 ? { preserveDerivedViews } : {}),
     });
 }
 /** Restore a maintenance-relocated page's derived identity before generic undo reindexes the tree. */
@@ -3085,6 +3130,24 @@ function observationOperationIssue(ctx, item, operations) {
         return 'a reflection item must write only the configured observations/principles page';
     }
     const sources = item.evidence.filter((entry) => entry.type === 'page');
+    const firstScope = sources[0];
+    if (item.kind === 'reflect' &&
+        (!firstScope?.observationScopeAssessment ||
+            !/^[a-f0-9]{64}$/.test(firstScope.observationScopeAssessment) ||
+            !firstScope.observationScopeCandidateHash ||
+            !/^[a-f0-9]{64}$/.test(firstScope.observationScopeCandidateHash) ||
+            !firstScope.observationScopeContextHash ||
+            !/^[a-f0-9]{64}$/.test(firstScope.observationScopeContextHash) ||
+            firstScope.observationScopePromptVersion !== OBSERVATION_SCOPE_PROMPT_VERSION ||
+            !firstScope.observationScopeModel ||
+            sources.some((entry) => entry.observationScopeAssessment !== firstScope.observationScopeAssessment ||
+                entry.observationScopeCandidateHash !== firstScope.observationScopeCandidateHash ||
+                entry.observationScopeContextHash !== firstScope.observationScopeContextHash ||
+                entry.observationScopePromptVersion !== firstScope.observationScopePromptVersion ||
+                entry.observationScopeModel !== firstScope.observationScopeModel ||
+                entry.observationScopeNarrowed !== firstScope.observationScopeNarrowed))) {
+        return 'a reflection requires one exact current evidence-scope assessment';
+    }
     const minEvidence = item.kind === 'reflect'
         ? Math.max(3, ctx.config.maintenance.observe.minEvidence)
         : ctx.config.maintenance.observe.minEvidence;
@@ -3121,6 +3184,10 @@ function observationOperationIssue(ctx, item, operations) {
     if (!match || match[2].trim().length === 0) {
         return 'the inference item must append one dated, cited conclusion line';
     }
+    if (item.kind === 'reflect' &&
+        observationScopeCandidateHash({ pattern: match[2].trim() }) !== firstScope?.observationScopeCandidateHash) {
+        return 'the reflected principle changed after its evidence-scope assessment';
+    }
     const citations = [...match[3].matchAll(/\[\[([^\]|#]+)(?:[#|][^\]]*)?\]\]/g)].map((entry) => entry[1]);
     if (!sameStringSet(citations, sourceSlugs)) {
         return 'the appended inference line must cite exactly its sealed evidence pages';
@@ -3198,6 +3265,23 @@ function coLocatedObservationOperationIssue(ctx, item, operations) {
         entry.observationProofCount !== first.observationProofCount)) {
         return 'observation evidence disagrees about marker identity';
     }
+    if (!closesInvalidLineage &&
+        (!first.observationScopeAssessment ||
+            !/^[a-f0-9]{64}$/.test(first.observationScopeAssessment) ||
+            !first.observationScopeCandidateHash ||
+            !/^[a-f0-9]{64}$/.test(first.observationScopeCandidateHash) ||
+            !first.observationScopeContextHash ||
+            !/^[a-f0-9]{64}$/.test(first.observationScopeContextHash) ||
+            first.observationScopePromptVersion !== OBSERVATION_SCOPE_PROMPT_VERSION ||
+            !first.observationScopeModel ||
+            sources.some((entry) => entry.observationScopeAssessment !== first.observationScopeAssessment ||
+                entry.observationScopeCandidateHash !== first.observationScopeCandidateHash ||
+                entry.observationScopeContextHash !== first.observationScopeContextHash ||
+                entry.observationScopePromptVersion !== first.observationScopePromptVersion ||
+                entry.observationScopeModel !== first.observationScopeModel ||
+                entry.observationScopeNarrowed !== first.observationScopeNarrowed))) {
+        return 'an observation requires one exact current evidence-scope assessment';
+    }
     const factIds = sources.map((entry) => entry.observationFactId);
     if (new Set(factIds).size !== factIds.length)
         return 'observation evidence contains a duplicate fact';
@@ -3214,7 +3298,11 @@ function coLocatedObservationOperationIssue(ctx, item, operations) {
         return 'the observation marker is missing from the proposed page';
     const marker = parseObservationMarker(afterPage.lines[markerIndex]);
     const payload = afterPage.lines[markerIndex + 1]?.trim() ?? '';
-    if (!marker || marker.subject !== first.observationSubject) {
+    if (!marker ||
+        marker.subject !== first.observationSubject ||
+        (!closesInvalidLineage &&
+            outcome !== 'split' &&
+            marker.scopeAssessment !== first.observationScopeAssessment)) {
         return 'the proposed observation marker does not match its sealed lineage';
     }
     if (closesInvalidLineage) {
@@ -3262,6 +3350,8 @@ function coLocatedObservationOperationIssue(ctx, item, operations) {
         const patterns = activePayloads.map((entry) => /^- \*\*Observation:\*\* (.+?) Evidence: /.exec(entry)?.[1]?.trim() ?? '');
         const activeIds = activeMarkers.map((entry) => entry.id);
         if (patterns.some((entry) => !entry) ||
+            observationScopeCandidateHash({ pattern: patterns[0], splitPattern: patterns[1] }) !==
+                first.observationScopeCandidateHash ||
             activePayloads.some((entry) => observationPayloadIssue(entry, evidenceSlugs) !== null) ||
             activeMarkers.some((entry) => renderObservationMarker(entry) !==
                 renderObservationMarker({
@@ -3270,6 +3360,7 @@ function coLocatedObservationOperationIssue(ctx, item, operations) {
                     disposition: 'active',
                     evidence: expectedEvidence,
                     proofCount: first.observationProofCount,
+                    scopeAssessment: first.observationScopeAssessment,
                 })) ||
             new Set(activeIds).size !== 2 ||
             activeIds.includes(targetId) ||
@@ -3293,6 +3384,9 @@ function coLocatedObservationOperationIssue(ctx, item, operations) {
     const pattern = /^- \*\*Observation:\*\* (.+?) Evidence: /.exec(payload)?.[1]?.trim();
     if (!pattern)
         return 'the proposed observation lacks visible derived wording';
+    if (observationScopeCandidateHash({ pattern }) !== first.observationScopeCandidateHash) {
+        return 'the observation wording changed after its evidence-scope assessment';
+    }
     const expectedMarker = {
         ...marker,
         evidence: sources.map((entry) => ({
@@ -3398,10 +3492,23 @@ async function observationEvidenceIssue(ctx, item, phase = 'before') {
             const bytes = await fsp
                 .readFile(path.join(ctx.config.aknoPath, fact.rel_path), 'utf8')
                 .catch(() => null);
-            if (bytes === null || sha256(bytes) !== entry.fingerprint) {
+            const coLocatedOperation = phase === 'after' && entry.source === item.subject
+                ? item.operations.find((operation) => operation.type === 'replace' &&
+                    operation.relPath === fact.rel_path &&
+                    sha256(operation.before) === entry.fingerprint)
+                : undefined;
+            if (bytes === null ||
+                (coLocatedOperation
+                    ? sha256(bytes) !== coLocatedOperation.afterHash
+                    : sha256(bytes) !== entry.fingerprint)) {
                 return `${entry.source} no longer matches its sealed observation evidence.`;
             }
         }
+        if (item.policy === 'review') {
+            const scopeIssue = currentObservationScopeIssue(ctx, item);
+            if (scopeIssue)
+                return scopeIssue;
+        }
         if (phase === 'after') {
             const operation = item.operations[0];
             if (!operation || operation.type !== 'replace')
@@ -3459,6 +3566,11 @@ async function observationEvidenceIssue(ctx, item, phase = 'before') {
                 return `${entry.source} no longer matches its sealed reflection evidence.`;
             }
         }
+        if (item.policy === 'review') {
+            const scopeIssue = currentObservationScopeIssue(ctx, item);
+            if (scopeIssue)
+                return scopeIssue;
+        }
         return null;
     }
     const expectedRole = item.kind === 'reflect' ? 'inference' : 'knowledge';
@@ -3487,6 +3599,114 @@ async function observationEvidenceIssue(ctx, item, phase = 'before') {
     }
     return null;
 }
+/** Rebuild the complete bounded assessment input so delayed review plans cannot outlive context changes. */
+function currentObservationScopeIssue(ctx, item) {
+    const expected = item.evidence[0]?.observationScopeContextHash;
+    if (!expected)
+        return 'the inference plan is missing its sealed complete evidence scope.';
+    const evidence = item.kind === 'observe'
+        ? currentLevelTwoScope(ctx, item)
+        : item.kind === 'reflect'
+            ? currentLevelThreeScope(ctx, item)
+            : null;
+    if (!evidence || observationScopeContextHash(evidence) !== expected) {
+        return 'the complete current evidence scope changed after its assessment was sealed.';
+    }
+    return null;
+}
+function currentLevelTwoScope(ctx, item) {
+    const subject = item.evidence[0]?.observationSubject;
+    if (!subject)
+        return null;
+    const selected = new Set(item.evidence.map((entry) => entry.observationFactId).filter(Boolean));
+    const rows = ctx.store.db
+        .prepare(`SELECT f.id, f.claim, f.item_id, p.id AS page_id, p.slug,
+              g.eligibility, g.traversable
+         FROM facts f JOIN pages p ON p.id = f.page_id
+         JOIN graph_fact_status g ON g.fact_id = f.id
+        WHERE f.valid_to IS NULL
+          AND f.confidence >= 0.5
+          AND p.role = 'knowledge'
+          AND p.derived_hash = p.body_hash
+          AND g.subject_entity = ?
+        ORDER BY p.slug, f.id`)
+        .all(subject);
+    const evidence = [];
+    let characters = 0;
+    for (const row of rows) {
+        const nextCharacters = row.id.length + row.claim.length + row.slug.length;
+        if (evidence.length >= 80 || characters + nextCharacters > 80_000)
+            return null;
+        const proofs = proofGroupsForFact(ctx.store, row.id, row.page_id, row.item_id);
+        const conflictReason = row.eligibility.startsWith('conflict_') ? row.eligibility : null;
+        const canSupport = !conflictReason && row.eligibility === 'eligible' && row.traversable === 1 && proofs.size > 0;
+        const isSelected = selected.has(row.id);
+        evidence.push({
+            id: row.id,
+            claim: row.claim,
+            slug: row.slug,
+            status: isSelected
+                ? 'selected_support'
+                : conflictReason
+                    ? 'counterevidence'
+                    : canSupport
+                        ? 'eligible_context'
+                        : 'ineligible_context',
+            ...(!isSelected && !canSupport
+                ? {
+                    statusReason: conflictReason ?? `graph_${row.eligibility}_${row.traversable ? 'linked' : 'held'}`,
+                }
+                : {}),
+        });
+        characters += nextCharacters;
+    }
+    return evidence.sort((a, b) => `${a.slug}\0${a.id}`.localeCompare(`${b.slug}\0${b.id}`));
+}
+function currentLevelThreeScope(ctx, item) {
+    const rows = ctx.store.db
+        .prepare(`SELECT oe.id, oe.source_slug AS slug, oe.payload
+         FROM observation_entries oe JOIN pages p ON p.id = oe.source_page
+        WHERE oe.eligible = 1 AND oe.disposition = 'active'
+        ORDER BY p.updated_at DESC, oe.source_slug, oe.marker_line DESC, oe.id LIMIT 41`)
+        .all();
+    if (rows.length > 40)
+        return null;
+    const selected = new Set(item.evidence.map((entry) => entry.reflectionObservationId).filter(Boolean));
+    const evidence = [];
+    let leafCount = 0;
+    let characters = 0;
+    for (const row of rows) {
+        const leaves = ctx.store.db
+            .prepare(`SELECT f.id, f.claim, p.slug
+           FROM observation_evidence oe JOIN facts f ON f.id = oe.fact_id
+           JOIN pages p ON p.id = f.page_id
+          WHERE oe.observation_id = ? AND f.valid_to IS NULL
+          ORDER BY oe.ordinal`)
+            .all(row.id);
+        const expected = ctx.store.db
+            .prepare('SELECT count(*) AS count FROM observation_evidence WHERE observation_id = ?')
+            .get(row.id);
+        const nextCharacters = row.id.length +
+            row.slug.length +
+            row.payload.length +
+            leaves.reduce((sum, leaf) => sum + leaf.id.length + leaf.slug.length + leaf.claim.length, 0);
+        if (leaves.length !== expected.count ||
+            leafCount + leaves.length > 120 ||
+            characters + nextCharacters > 80_000) {
+            return null;
+        }
+        evidence.push({
+            id: row.id,
+            claim: row.payload,
+            slug: row.slug,
+            status: selected.has(row.id) ? 'selected_support' : 'eligible_context',
+            leaves,
+        });
+        leafCount += leaves.length;
+        characters += nextCharacters;
+    }
+    return evidence.sort((a, b) => `${a.slug}\0${a.id}`.localeCompare(`${b.slug}\0${b.id}`));
+}
 async function curationPageEvidenceIssue(ctx, item) {
     for (const entry of item.evidence.filter((candidate) => candidate.type === 'page')) {
         if (!entry.fingerprint) {
@@ -4201,15 +4421,11 @@ export function maintenancePlanStatusAfterApply(plan) {
     }
     else if (statuses.includes('proposed'))
         return 'ready';
-    else if (plan.items.some((item) => ['dependency_conflict', 'dependency_unmet', 'snapshot_drift'].includes(item.statusCode ?? ''))) {
-        // These items need a new plan, unlike budget and verification deferrals. Keeping this plan
-        // active would make the next cycle resume a terminal item forever instead of replanning it.
-        return 'failed';
-    }
     else if (statuses.every((value) => value === 'applied' || value === 'rejected'))
         return 'completed';
-    else if (statuses.includes('applied'))
-        return 'partially_completed';
+    // Every status left here is terminal for this sealed item. That includes untyped `blocked` rows
+    // persisted before status codes existed: keeping a mixed applied/blocked plan nonterminal makes
+    // it look resumable even though apply has no legal next step.
     return 'failed';
 }
 function setPlanStatus(ctx, planId, status) {
@@ -4219,31 +4435,31 @@ function setPlanStatus(ctx, planId, status) {
 }
 export function finalizeRetryableMaintenancePlans(ctx) {
     requireWritable(ctx);
-    const result = ctx.store.db
-        .prepare(`UPDATE maintenance_plans AS plan
-          SET status = 'failed', updated_at = ?
-        WHERE plan.status = 'partially_completed'
-          AND EXISTS (
-            SELECT 1 FROM maintenance_items item
-             WHERE item.plan_id = plan.id
-               AND item.status_code IN ('dependency_conflict', 'dependency_unmet', 'snapshot_drift')
-          )
-          AND NOT EXISTS (
-            SELECT 1 FROM maintenance_items item
-             WHERE item.plan_id = plan.id
-               AND item.status IN ('proposed', 'approved', 'applying', 'verification_pending')
-          )
-          AND NOT EXISTS (
-            SELECT 1 FROM maintenance_items item
-             WHERE item.plan_id = plan.id
-               AND item.status IN ('blocked', 'stale', 'verification_failed')
-               AND NOT (
-                 (item.status = 'blocked' AND item.status_code IN ('dependency_conflict', 'dependency_unmet'))
-                 OR (item.status = 'stale' AND item.status_code = 'snapshot_drift')
-               )
-          )`)
-        .run(new Date().toISOString());
-    return result.changes;
+    const now = new Date().toISOString();
+    return ctx.store.transaction(() => {
+        const completed = ctx.store.db
+            .prepare(`UPDATE maintenance_plans AS plan
+            SET status = 'completed', updated_at = ?
+          WHERE plan.status NOT IN ('completed', 'failed', 'superseded')
+            AND EXISTS (SELECT 1 FROM maintenance_items item WHERE item.plan_id = plan.id)
+            AND NOT EXISTS (
+              SELECT 1 FROM maintenance_items item
+               WHERE item.plan_id = plan.id
+                 AND item.status NOT IN ('applied', 'rejected')
+            )`)
+            .run(now).changes;
+        const failed = ctx.store.db
+            .prepare(`UPDATE maintenance_plans AS plan
+            SET status = 'failed', updated_at = ?
+          WHERE plan.status NOT IN ('completed', 'failed', 'superseded')
+            AND NOT EXISTS (
+              SELECT 1 FROM maintenance_items item
+               WHERE item.plan_id = plan.id
+                 AND item.status IN ('proposed', 'approved', 'applying', 'verification_pending')
+            )`)
+            .run(now).changes;
+        return completed + failed;
+    });
 }
 /**
  * A dependency-deferred plan was sealed against the pre-apply snapshot. Once the same run starts