@tenphi/akno-core 0.13.1 → 0.13.3

package/dist/maintenance/dream.js

@@ -7,8 +7,9 @@ import { proseQualifications } from "../kb/prose.js";
 import { rebuildEvidenceGraph } from "../index/graph.js";
 import { mergeTopLevelStringArray, serializeYamlString, serializeYamlStringArray, } from "../kb/frontmatter.js";
 import { runObserveMission } from "./observe.js";
+import { assessObservationScope, } from "./observation-scope.js";
 import { planBrokenLinks } from "./link-repairs.js";
-import { claimKey, findCrossPageConflicts, ineligibleConflictClaims, verifyConflicts, } from "./conflicts.js";
+import { claimKey, conflictClaimIneligibility, findCrossPageConflicts, ineligibleConflictClaims, verifyConflicts, } from "./conflicts.js";
 import { planContradictions } from "./contradictions.js";
 import { housekeeping } from "./housekeeping.js";
 import { ModelClient } from "../models/client.js";
@@ -560,20 +561,28 @@ async function runPhase(ctx, phase, options, report, applied, budget, deferAutom
         case 'curate': {
             const policyMatrix = !options.dryRun;
             const policies = curationPolicies(ctx, options);
-            const managedItemResult = policies.managed_item === 'off'
+            const allowedKinds = new Set(['hygiene', 'synthesis', 'split', 'extract', 'merge'].filter((kind) => policies[kind] !== 'off'));
+            // Resolve persisted work before any candidate planner can call a model. In particular,
+            // managed-item routing is model-backed; running it first generated usable drafts and then
+            // discarded them whenever an older plan won queue selection.
+            const mode = policyMatrix ? highestPolicyMode(Object.values(policies)) : null;
+            let plan = mode ? findActiveMaintenancePlan(ctx, mode, 'curate') : null;
+            if (plan && policyMatrix && !planMatchesPolicies(plan, policies))
+                plan = null;
+            const managedItemResult = plan
                 ? { drafts: [], report: report.managedItems }
-                : await planManagedItems(ctx, {
-                    conflictClaims: ineligibleConflictClaims(report.conflicts),
-                });
+                : policies.managed_item === 'off'
+                    ? { drafts: [], report: report.managedItems }
+                    : await planManagedItems(ctx, {
+                        conflictClaims: ineligibleConflictClaims(report.conflicts),
+                    });
             report.managedItems = managedItemResult.report;
             if (managedItemResult.report.outcomes.held > 0) {
                 report.warnings.push(`${managedItemResult.report.outcomes.held} managed-item finding${managedItemResult.report.outcomes.held === 1 ? '' : 's'} require${managedItemResult.report.outcomes.held === 1 ? 's' : ''} inspection; surrounding page bytes were not changed`);
             }
-            const allowedKinds = new Set(['hygiene', 'synthesis', 'split', 'extract', 'merge'].filter((kind) => policies[kind] !== 'off'));
             // A configured mode is how a full scheduled run gets plan-backed curation without
             // turning the scheduler into a curate-only command. An explicit dry run keeps its
             // existing read-only path; creating a durable plan needs the service's write handle.
-            const mode = policyMatrix ? highestPolicyMode(Object.values(policies)) : null;
             if (policyMatrix && !mode)
                 return 'all curation policies are off';
             if (!ctx.models.derive.available && !mode) {
@@ -583,9 +592,6 @@ async function runPhase(ctx, phase, options, report, applied, budget, deferAutom
             if (mode) {
                 // Reuse every unfinished plan, not only autonomous ones. Re-running audit or review must
                 // not spend another model call to rediscover a decision already waiting in the queue.
-                let plan = findActiveMaintenancePlan(ctx, mode, 'curate');
-                if (plan && policyMatrix && !planMatchesPolicies(plan, policies))
-                    plan = null;
                 if (plan) {
                     report.curated = plan.items.filter(isGeneralCurationItem).map((item) => ({
                         slug: item.subject,
@@ -742,18 +748,25 @@ async function runPhase(ctx, phase, options, report, applied, budget, deferAutom
             const adoptPolicy = policyMode(effectiveTransformPolicy(ctx.config, 'adopt', options.mode));
             if (!adoptPolicy)
                 return 'adopt policy is off';
-            const result = await planOrphanAdoptions(ctx, {
-                limit: ctx.config.maintenance.adopt.maxPages,
-            });
-            report.adopted = result.adopted;
-            if (options.dryRun)
+            if (options.dryRun) {
+                const result = await planOrphanAdoptions(ctx, {
+                    limit: ctx.config.maintenance.adopt.maxPages,
+                });
+                report.adopted = result.adopted;
                 return null;
+            }
             const mode = adoptPolicy;
             let plan = findActiveMaintenancePlan(ctx, mode, 'adopt');
             if (plan && !planMatchesPolicies(plan, { adopt: adoptPolicy }))
                 plan = null;
-            if (!plan && result.drafts.length > 0) {
-                plan = createAdoptionPlan(ctx, mode, result.drafts, report.run.snapshot, adoptPolicy);
+            if (!plan) {
+                const result = await planOrphanAdoptions(ctx, {
+                    limit: ctx.config.maintenance.adopt.maxPages,
+                });
+                report.adopted = result.adopted;
+                if (result.drafts.length > 0) {
+                    plan = createAdoptionPlan(ctx, mode, result.drafts, report.run.snapshot, adoptPolicy);
+                }
             }
             if (!plan)
                 return null;
@@ -1151,12 +1164,16 @@ async function observePhase(ctx, options, report, applied, budget, deferAutomati
     if (plan && !planMatchesPolicies(plan, { observe: observePolicy }))
         plan = null;
     const previouslyRejected = [];
+    const scopeHeld = [];
     if (!plan) {
         const prepared = await collectPreparedObservations(ctx, report);
         const drafts = [];
         for (const entry of prepared) {
-            if (!entry.draft)
+            if (!entry.draft) {
+                if (entry.rejectionCode)
+                    scopeHeld.push({ ...entry.written, action: 'rejected' });
                 continue;
+            }
             if (inferenceWasRejected(ctx, 'observe', entry.draft)) {
                 previouslyRejected.push({ ...entry.written, action: 'rejected' });
             }
@@ -1167,7 +1184,7 @@ async function observePhase(ctx, options, report, applied, budget, deferAutomati
         plan = createObservationPlan(ctx, observePolicy, drafts, observePolicy);
     }
     if (!plan) {
-        report.observations.push(...previouslyRejected);
+        report.observations.push(...scopeHeld, ...previouslyRejected);
         return;
     }
     if (observePolicy === 'auto' && !deferAutomaticApply) {
@@ -1180,7 +1197,7 @@ async function observePhase(ctx, options, report, applied, budget, deferAutomati
             applied.push(...result.files.map((file) => asApplied('observe', file)));
         }
     }
-    report.observations.push(...plan.items.map(observationFromPlanItem), ...previouslyRejected);
+    report.observations.push(...plan.items.map(observationFromPlanItem), ...scopeHeld, ...previouslyRejected);
     const changeIds = plan.items
         .map((item) => item.changeId)
         .filter((changeId) => changeId !== null);
@@ -1214,7 +1231,11 @@ async function collectPreparedObservations(ctx, report) {
     const prepared = await staleObservationOutcomes(ctx);
     for (const entry of prepared) {
         if (entry.rejectionReason)
-            report.rejected.push({ pattern: entry.written.pattern, reason: entry.rejectionReason });
+            report.rejected.push({
+                pattern: entry.written.pattern,
+                reason: entry.rejectionReason,
+                ...(entry.rejectionCode ? { code: entry.rejectionCode } : {}),
+            });
     }
     if (groups.length === 0)
         return prepared;
@@ -1223,6 +1244,10 @@ async function collectPreparedObservations(ctx, report) {
     const knownFacts = liveFactClaims(ctx, report.conflicts);
     const observationsBySlug = indexedObservations(ctx);
     for (const group of groups) {
+        if (!group.scopeContextComplete) {
+            report.warnings.push(`observe (${group.subject}): scope_context_incomplete — complete current evidence exceeded the bounded assessment`);
+            continue;
+        }
         const result = await runObserveMission({
             // The display label comes from the canonical entity page. Group membership itself is the
             // exact resolved entity id below, never a folder or a model-generated subject string.
@@ -1248,21 +1273,76 @@ async function collectPreparedObservations(ctx, report) {
         }
         report.rejected.push(...result.rejected);
         for (const observation of result.observations) {
-            const outcome = await prepareCoLocatedObservation(ctx, group, observation);
+            const scopeCandidate = exactObservationCandidateForScope(ctx, observation);
+            const scope = await assessObservationScope({
+                store: ctx.store,
+                model: ctx.models.derive,
+                level: 'observation',
+                subject: group.subject,
+                candidate: scopeCandidate,
+                evidence: group.scopeFacts
+                    .map((fact) => ({
+                    ...fact,
+                    status: observation.evidence.includes(fact.id) ? 'selected_support' : fact.status,
+                }))
+                    .sort((a, b) => `${a.slug}\0${a.id}`.localeCompare(`${b.slug}\0${b.id}`)),
+                contextComplete: group.scopeContextComplete,
+            });
+            if (!scope.candidate || !scope.receipt) {
+                const held = {
+                    written: {
+                        slug: group.targetSlug,
+                        pattern: observation.pattern,
+                        evidence: [],
+                        action: 'rejected',
+                    },
+                    draft: null,
+                    rejectionReason: scope.hold?.reason ?? 'the evidence-scope assessment held the candidate',
+                    ...(scope.hold ? { rejectionCode: scope.hold.code } : {}),
+                };
+                prepared.push(held);
+                report.rejected.push({
+                    pattern: observation.pattern,
+                    reason: held.rejectionReason,
+                    ...(held.rejectionCode ? { code: held.rejectionCode } : {}),
+                });
+                continue;
+            }
+            const assessed = scope.candidate;
+            const outcome = await prepareCoLocatedObservation(ctx, group, assessed, scope.receipt);
             prepared.push(outcome);
             if (outcome.rejectionReason) {
-                report.rejected.push({ pattern: observation.pattern, reason: outcome.rejectionReason });
+                report.rejected.push({
+                    pattern: assessed.pattern,
+                    reason: outcome.rejectionReason,
+                    ...(outcome.rejectionCode ? { code: outcome.rejectionCode } : {}),
+                });
             }
             // So a later group in this same run sees it. Without this, cross-page duplicates are caught
             // only from the second night onwards — the night they are created, they both go through.
             observationsBySlug.set(group.targetSlug, [
                 ...(observationsBySlug.get(group.targetSlug) ?? []),
-                observation.pattern,
+                assessed.pattern,
             ]);
         }
     }
     return prepared;
 }
+function exactObservationCandidateForScope(ctx, candidate) {
+    if (candidate.outcome !== 'reinforce' || !candidate.targetId)
+        return candidate;
+    const row = ctx.store.db
+        .prepare(`SELECT payload FROM observation_entries
+        WHERE id = ? AND disposition = 'active' AND eligible = 1`)
+        .get(candidate.targetId);
+    if (!row)
+        return candidate;
+    const pattern = row.payload
+        .replace(/^- \*\*Observation:\*\*\s*/, '')
+        .replace(/\s+Evidence:\s+(?:\[\[[^\]]+\]\]\s*)+$/, '')
+        .trim();
+    return pattern ? { ...candidate, pattern } : candidate;
+}
 async function staleObservationOutcomes(ctx) {
     const rows = ctx.store.db
         .prepare(`SELECT oe.id, oe.source_slug, oe.payload, oe.payload_hash, oe.subject_entity,
@@ -1360,10 +1440,11 @@ async function staleObservationOutcomes(ctx) {
 }
 /** Live eligible level-one facts grouped only by exact resolved subject identity. */
 function subjectGroups(ctx, maxSubjects, conflicts) {
-    const ineligible = ineligibleConflictClaims(conflicts);
+    const conflictStatus = conflictClaimIneligibility(conflicts);
     const rows = ctx.store.db
         .prepare(`SELECT f.id, f.claim, f.line_start, f.source_line_hash, f.item_id,
               p.id AS page_id, p.slug, p.updated_at, g.subject_entity,
+              g.eligibility, g.traversable,
               e.canonical_page, cp.slug AS canonical_slug, cp.rel_path AS canonical_rel_path,
               cp.observe_management AS canonical_observe
          FROM facts f JOIN pages p ON p.id = f.page_id
@@ -1374,52 +1455,62 @@ function subjectGroups(ctx, maxSubjects, conflicts) {
           AND f.confidence >= 0.5
           AND p.role = 'knowledge'
           AND p.derived_hash = p.body_hash
-          AND g.eligibility = 'eligible'
-          AND g.traversable = 1
-        ORDER BY p.updated_at DESC`)
+        ORDER BY p.updated_at DESC, p.slug, f.line_start, f.id`)
         .all();
     const groups = new Map();
     for (const row of rows) {
-        if (ineligible.has(claimKey(row.slug, row.line_start)))
-            continue;
         const target = observationTarget(ctx, row);
         if (!target)
             continue;
         const proofs = [...proofGroupsForFact(ctx.store, row.id, row.page_id, row.item_id)].sort();
-        if (proofs.length === 0)
-            continue;
         const key = row.subject_entity;
-        const existing = groups.get(key);
-        if (existing) {
-            if (existing.targetSlug !== target.slug) {
+        const conflictReason = conflictStatus.get(claimKey(row.slug, row.line_start));
+        const canSupport = !conflictReason && row.eligibility === 'eligible' && row.traversable === 1 && proofs.length > 0;
+        let group = groups.get(key);
+        if (group) {
+            if (group.targetSlug !== target.slug) {
                 groups.delete(key);
                 continue;
             }
-            if (existing.facts.length < 30) {
-                existing.facts.push({
-                    id: row.id,
-                    claim: row.claim,
-                    slug: row.slug,
-                    sourceLineHash: row.source_line_hash,
-                    proofGroups: proofs,
-                });
-            }
         }
         else {
-            groups.set(key, {
+            group = {
                 subject: target.title,
                 subjectEntity: row.subject_entity,
                 targetSlug: target.slug,
                 targetRelPath: target.relPath,
-                facts: [
-                    {
-                        id: row.id,
-                        claim: row.claim,
-                        slug: row.slug,
-                        sourceLineHash: row.source_line_hash,
-                        proofGroups: proofs,
-                    },
-                ],
+                facts: [],
+                scopeFacts: [],
+                scopeContextComplete: true,
+                scopeCharacters: 0,
+            };
+            groups.set(key, group);
+        }
+        const scopeCharacters = row.id.length + row.claim.length + row.slug.length;
+        if (group.scopeFacts.length >= 80 || group.scopeCharacters + scopeCharacters > 80_000) {
+            group.scopeContextComplete = false;
+        }
+        else {
+            group.scopeFacts.push({
+                id: row.id,
+                claim: row.claim,
+                slug: row.slug,
+                status: conflictReason ? 'counterevidence' : canSupport ? 'eligible_context' : 'ineligible_context',
+                ...(!canSupport
+                    ? {
+                        statusReason: conflictReason ?? `graph_${row.eligibility}_${row.traversable ? 'linked' : 'held'}`,
+                    }
+                    : {}),
+            });
+            group.scopeCharacters += scopeCharacters;
+        }
+        if (canSupport && group.facts.length < 30) {
+            group.facts.push({
+                id: row.id,
+                claim: row.claim,
+                slug: row.slug,
+                sourceLineHash: row.source_line_hash,
+                proofGroups: proofs,
             });
         }
     }
@@ -1477,7 +1568,7 @@ function indexedObservationRecords(ctx, subject, slug) {
             .trim(),
     }));
 }
-async function prepareCoLocatedObservation(ctx, group, observation) {
+async function prepareCoLocatedObservation(ctx, group, observation, scopeReceipt) {
     let selected = observation.evidence.flatMap((id) => {
         const fact = group.facts.find((candidate) => candidate.id === id);
         return fact ? [fact] : [];
@@ -1572,6 +1663,7 @@ async function prepareCoLocatedObservation(ctx, group, observation) {
         disposition: 'active',
         evidence: locators,
         proofCount,
+        scopeAssessment: scopeReceipt.fingerprint,
     };
     const block = observationBlock(marker, finalPattern, selected.map((fact) => fact.slug));
     if (outcome === 'create' && observationMarkerIndexes(before.split(/\r?\n/), marker.id, true).length > 0) {
@@ -1636,6 +1728,12 @@ async function prepareCoLocatedObservation(ctx, group, observation) {
             observationDisposition: marker.disposition,
             observationProofCount: marker.proofCount,
             observationOutcome: outcome,
+            observationScopeAssessment: scopeReceipt.fingerprint,
+            observationScopeCandidateHash: scopeReceipt.candidateHash,
+            observationScopeContextHash: scopeReceipt.contextHash,
+            observationScopePromptVersion: scopeReceipt.promptVersion,
+            observationScopeModel: scopeReceipt.modelId,
+            observationScopeNarrowed: scopeReceipt.narrowed,
             ...(targetMarker ? { observationTargetId: targetMarker.id } : {}),
         },
     };
@@ -1852,12 +1950,16 @@ async function reflectPhase(ctx, options, report, applied, budget, deferAutomati
     if (plan && !planMatchesPolicies(plan, { reflect: reflectPolicy }))
         plan = null;
     const previouslyRejected = [];
+    const scopeHeld = [];
     if (!plan) {
         const prepared = await collectPreparedReflections(ctx, report);
         const drafts = [];
         for (const entry of prepared) {
-            if (!entry.draft)
+            if (!entry.draft) {
+                if (entry.rejectionCode)
+                    scopeHeld.push({ ...entry.written, action: 'rejected' });
                 continue;
+            }
             if (inferenceWasRejected(ctx, 'reflect', entry.draft)) {
                 previouslyRejected.push({ ...entry.written, action: 'rejected' });
             }
@@ -1868,7 +1970,7 @@ async function reflectPhase(ctx, options, report, applied, budget, deferAutomati
         plan = createReflectionPlan(ctx, reflectPolicy, drafts, reflectPolicy);
     }
     if (!plan) {
-        report.observations.push(...previouslyRejected);
+        report.observations.push(...scopeHeld, ...previouslyRejected);
         return;
     }
     if (reflectPolicy === 'auto' && !deferAutomaticApply) {
@@ -1881,7 +1983,7 @@ async function reflectPhase(ctx, options, report, applied, budget, deferAutomati
             applied.push(...result.files.map((file) => asApplied('reflect', file)));
         }
     }
-    report.observations.push(...plan.items.map(observationFromPlanItem), ...previouslyRejected);
+    report.observations.push(...plan.items.map(observationFromPlanItem), ...scopeHeld, ...previouslyRejected);
     const changeIds = plan.items
         .map((item) => item.changeId)
         .filter((changeId) => changeId !== null);
@@ -1903,15 +2005,25 @@ async function collectPreparedReflections(ctx, report) {
         .prepare(`SELECT oe.id, oe.source_slug AS slug, oe.payload, oe.payload_hash, p.rel_path
          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.marker_line DESC LIMIT 40`)
+        ORDER BY p.updated_at DESC, oe.source_slug, oe.marker_line DESC, oe.id LIMIT 41`)
         .all();
     if (rows.length < 2) {
         report.warnings.push('reflect had fewer than two observations to build on — nothing was written');
         return [];
     }
+    if (rows.length > 40) {
+        report.warnings.push('reflect: scope_context_incomplete — more than 40 eligible observations require a broader assessment');
+        return [];
+    }
+    const boundedRows = rows;
+    const scopeBase = reflectionScopeEvidence(ctx, boundedRows);
+    if (!scopeBase.complete) {
+        report.warnings.push('reflect: scope_context_incomplete — complete current leaf evidence exceeded the bounded assessment');
+        return [];
+    }
     const result = await runObserveMission({
         subject: 'decision principles',
-        facts: rows.map((row) => ({ id: row.id, claim: row.payload, slug: row.slug })),
+        facts: boundedRows.map((row) => ({ id: row.id, claim: row.payload, slug: row.slug })),
         model: ctx.models.derive,
         mission: ctx.config.maintenance.reflect.mission ??
             'State durable decision principles and long-term tendencies, not individual patterns.',
@@ -1934,10 +2046,49 @@ async function collectPreparedReflections(ctx, report) {
     report.rejected.push(...result.rejected);
     const prepared = [];
     for (const observation of result.observations) {
-        const outcome = await prepareIndexedReflection(ctx, observation, rows);
+        const scopeEvidence = scopeBase.evidence.map((entry) => ({
+            ...entry,
+            status: observation.evidence.includes(entry.id)
+                ? 'selected_support'
+                : 'eligible_context',
+        }));
+        const scope = await assessObservationScope({
+            store: ctx.store,
+            model: ctx.models.derive,
+            level: 'reflection',
+            subject: 'decision principles',
+            candidate: observation,
+            evidence: scopeEvidence.sort((a, b) => `${a.slug}\0${a.id}`.localeCompare(`${b.slug}\0${b.id}`)),
+            contextComplete: true,
+        });
+        if (!scope.candidate || !scope.receipt) {
+            const held = {
+                written: {
+                    slug: target,
+                    pattern: observation.pattern,
+                    evidence: [],
+                    action: 'rejected',
+                },
+                draft: null,
+                rejectionReason: scope.hold?.reason ?? 'the evidence-scope assessment held the principle',
+                ...(scope.hold ? { rejectionCode: scope.hold.code } : {}),
+            };
+            prepared.push(held);
+            report.rejected.push({
+                pattern: observation.pattern,
+                reason: held.rejectionReason,
+                ...(held.rejectionCode ? { code: held.rejectionCode } : {}),
+            });
+            continue;
+        }
+        const outcome = await prepareIndexedReflection(ctx, scope.candidate, boundedRows, scope.receipt);
         prepared.push(outcome);
         if (outcome.rejectionReason) {
-            report.rejected.push({ pattern: observation.pattern, reason: outcome.rejectionReason });
+            report.rejected.push({
+                pattern: scope.candidate.pattern,
+                reason: outcome.rejectionReason,
+                ...(outcome.rejectionCode ? { code: outcome.rejectionCode } : {}),
+            });
         }
     }
     return prepared;
@@ -1957,7 +2108,45 @@ async function recordedPrinciples(ctx) {
         .trim())
         .filter(Boolean);
 }
-async function prepareIndexedReflection(ctx, observation, rows) {
+function reflectionScopeEvidence(ctx, rows) {
+    const evidence = [];
+    let complete = true;
+    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);
+        if (leaves.length !== expected.count)
+            complete = false;
+        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 (leafCount + leaves.length > 120 || characters + nextCharacters > 80_000) {
+            complete = false;
+            continue;
+        }
+        evidence.push({
+            id: row.id,
+            claim: row.payload,
+            slug: row.slug,
+            status: 'eligible_context',
+            leaves,
+        });
+        leafCount += leaves.length;
+        characters += nextCharacters;
+    }
+    return { evidence, complete };
+}
+async function prepareIndexedReflection(ctx, observation, rows, scopeReceipt) {
     const selected = observation.evidence.flatMap((id) => {
         const row = rows.find((candidate) => candidate.id === id);
         return row ? [row] : [];
@@ -2020,8 +2209,25 @@ async function prepareIndexedReflection(ctx, observation, rows) {
         before: before === null ? null : sha256(before),
         pattern: observation.pattern,
         evidence,
+        scopeAssessment: scopeReceipt,
     }));
-    return { written, draft: { slug, relPath, inputHash, before, after, evidence } };
+    return {
+        written,
+        draft: {
+            slug,
+            relPath,
+            inputHash,
+            before,
+            after,
+            evidence,
+            observationScopeAssessment: scopeReceipt.fingerprint,
+            observationScopeCandidateHash: scopeReceipt.candidateHash,
+            observationScopeContextHash: scopeReceipt.contextHash,
+            observationScopePromptVersion: scopeReceipt.promptVersion,
+            observationScopeModel: scopeReceipt.modelId,
+            observationScopeNarrowed: scopeReceipt.narrowed,
+        },
+    };
 }
 /** A journal entry, as the log wants it: which phase, and what the write added. */
 function asApplied(phase, file) {