@karmaniverous/jeeves-meta 0.15.5 → 0.15.7

package/dist/cli/jeeves-meta/index.js

@@ -10788,6 +10788,22 @@ function rankPhaseCandidates(metas, depthWeight) {
 function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
+/**
+ * Select the stalest all-fresh, non-disabled, non-locked meta for Tier 2
+ * invalidation. These are metas that Tier 1 considers fully fresh but may
+ * have structural or steer changes detectable only via I/O.
+ *
+ * @param metas - Phase candidate inputs (after Tier 1 filtering).
+ * @returns The stalest all-fresh candidate, or null if none exist.
+ */
+function selectTier2Candidate(metas) {
+    const eligible = metas
+        .filter((m) => !m.locked && !m.disabled && isFullyFresh(m.phaseState))
+        .sort((a, b) => b.actualStaleness - a.actualStaleness);
+    if (eligible.length === 0)
+        return null;
+    return { node: eligible[0].node, meta: eligible[0].meta };
+}
 
 /**
  * Shared error utilities.
@@ -11169,7 +11185,8 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
-        return { executed: false };
+        // ── Tier 2 fallback: deep invalidation on stalest all-fresh meta ──
+        return orchestrateTier2(candidates, config, executor, watcher, onProgress, logger);
     }
     // Acquire lock
     if (!acquireLock(winner.node.metaPath)) {
@@ -11235,6 +11252,48 @@ async function orchestrateTargeted(config, executor, watcher, targetPath, onProg
         releaseLock(node.metaPath);
     }
 }
+/**
+ * Tier 2 invalidation fallback: pick the stalest all-fresh meta,
+ * run computeInvalidation (structure hash, steer, cross-refs), and
+ * either execute the owed phase or bump _generatedAt.
+ */
+async function orchestrateTier2(candidates, config, executor, watcher, onProgress, logger) {
+    const tier2 = selectTier2Candidate(candidates);
+    if (!tier2)
+        return { executed: false };
+    if (!acquireLock(tier2.node.metaPath)) {
+        logger?.debug({ path: tier2.node.metaPath }, 'Tier 2 candidate is locked, skipping');
+        return { executed: false };
+    }
+    try {
+        const currentMeta = await readMetaJson(tier2.node.metaPath);
+        const { scopeFiles } = await getScopeFiles(tier2.node, watcher);
+        const { phaseState, structureHash } = await computeInvalidation(currentMeta, scopeFiles, config, tier2.node);
+        const owedPhase = getOwedPhase(phaseState);
+        if (owedPhase) {
+            // Something changed — persist invalidated state and execute owed phase
+            await persistPhaseState({
+                metaPath: tier2.node.metaPath,
+                current: currentMeta,
+                config,
+                structureHash,
+            }, phaseState, {});
+            return await executePhase(tier2.node, currentMeta, phaseState, owedPhase, config, executor, watcher, structureHash, onProgress, logger);
+        }
+        // Nothing changed — bump _generatedAt to delay re-checking
+        await persistPhaseState({
+            metaPath: tier2.node.metaPath,
+            current: currentMeta,
+            config,
+            structureHash,
+        }, phaseState, { _generatedAt: new Date().toISOString() });
+        logger?.debug({ path: tier2.node.ownerPath }, 'Tier 2: no invalidation detected, bumped _generatedAt');
+        return { executed: false };
+    }
+    finally {
+        releaseLock(tier2.node.metaPath);
+    }
+}
 /**
  * Execute exactly one phase on a meta.
  */

package/dist/index.js

@@ -10339,6 +10339,22 @@ function rankPhaseCandidates(metas, depthWeight) {
 function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
+/**
+ * Select the stalest all-fresh, non-disabled, non-locked meta for Tier 2
+ * invalidation. These are metas that Tier 1 considers fully fresh but may
+ * have structural or steer changes detectable only via I/O.
+ *
+ * @param metas - Phase candidate inputs (after Tier 1 filtering).
+ * @returns The stalest all-fresh candidate, or null if none exist.
+ */
+function selectTier2Candidate(metas) {
+    const eligible = metas
+        .filter((m) => !m.locked && !m.disabled && isFullyFresh(m.phaseState))
+        .sort((a, b) => b.actualStaleness - a.actualStaleness);
+    if (eligible.length === 0)
+        return null;
+    return { node: eligible[0].node, meta: eligible[0].meta };
+}
 
 /**
  * Shared error utilities.
@@ -10720,7 +10736,8 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
-        return { executed: false };
+        // ── Tier 2 fallback: deep invalidation on stalest all-fresh meta ──
+        return orchestrateTier2(candidates, config, executor, watcher, onProgress, logger);
     }
     // Acquire lock
     if (!acquireLock(winner.node.metaPath)) {
@@ -10786,6 +10803,48 @@ async function orchestrateTargeted(config, executor, watcher, targetPath, onProg
         releaseLock(node.metaPath);
     }
 }
+/**
+ * Tier 2 invalidation fallback: pick the stalest all-fresh meta,
+ * run computeInvalidation (structure hash, steer, cross-refs), and
+ * either execute the owed phase or bump _generatedAt.
+ */
+async function orchestrateTier2(candidates, config, executor, watcher, onProgress, logger) {
+    const tier2 = selectTier2Candidate(candidates);
+    if (!tier2)
+        return { executed: false };
+    if (!acquireLock(tier2.node.metaPath)) {
+        logger?.debug({ path: tier2.node.metaPath }, 'Tier 2 candidate is locked, skipping');
+        return { executed: false };
+    }
+    try {
+        const currentMeta = await readMetaJson(tier2.node.metaPath);
+        const { scopeFiles } = await getScopeFiles(tier2.node, watcher);
+        const { phaseState, structureHash } = await computeInvalidation(currentMeta, scopeFiles, config, tier2.node);
+        const owedPhase = getOwedPhase(phaseState);
+        if (owedPhase) {
+            // Something changed — persist invalidated state and execute owed phase
+            await persistPhaseState({
+                metaPath: tier2.node.metaPath,
+                current: currentMeta,
+                config,
+                structureHash,
+            }, phaseState, {});
+            return await executePhase(tier2.node, currentMeta, phaseState, owedPhase, config, executor, watcher, structureHash, onProgress, logger);
+        }
+        // Nothing changed — bump _generatedAt to delay re-checking
+        await persistPhaseState({
+            metaPath: tier2.node.metaPath,
+            current: currentMeta,
+            config,
+            structureHash,
+        }, phaseState, { _generatedAt: new Date().toISOString() });
+        logger?.debug({ path: tier2.node.ownerPath }, 'Tier 2: no invalidation detected, bumped _generatedAt');
+        return { executed: false };
+    }
+    finally {
+        releaseLock(tier2.node.metaPath);
+    }
+}
 /**
  * Execute exactly one phase on a meta.
  */

package/dist/phaseState/index.d.ts

@@ -5,5 +5,5 @@
  */
 export { type DerivationInputs, derivePhaseState } from './derivePhaseState.js';
 export { type ArchitectInvalidator, computeInvalidation, type InvalidationResult, type StalenessInputs, } from './invalidate.js';
-export { buildPhaseCandidates, type PhaseCandidate, type PhaseCandidateInput, rankPhaseCandidates, selectPhaseCandidate, } from './phaseScheduler.js';
+export { buildPhaseCandidates, type PhaseCandidate, type PhaseCandidateInput, rankPhaseCandidates, selectPhaseCandidate, selectTier2Candidate, type Tier2Candidate, } from './phaseScheduler.js';
 export { architectSuccess, builderSuccess, criticSuccess, enforceInvariant, freshPhaseState, getOwedPhase, getPriorityBand, initialPhaseState, invalidateArchitect, invalidateBuilder, isFullyFresh, phaseFailed, phaseRunning, retryAllFailed, retryPhase, } from './phaseTransitions.js';

package/dist/phaseState/phaseScheduler.d.ts

@@ -55,3 +55,17 @@ export declare function rankPhaseCandidates(metas: PhaseCandidateInput[], depthW
  * @returns The winning candidate, or null if no phase is ready.
  */
 export declare function selectPhaseCandidate(metas: PhaseCandidateInput[], depthWeight: number): PhaseCandidate | null;
+/** Result of Tier 2 candidate selection. */
+export interface Tier2Candidate {
+    node: MetaNode;
+    meta: MetaJson;
+}
+/**
+ * Select the stalest all-fresh, non-disabled, non-locked meta for Tier 2
+ * invalidation. These are metas that Tier 1 considers fully fresh but may
+ * have structural or steer changes detectable only via I/O.
+ *
+ * @param metas - Phase candidate inputs (after Tier 1 filtering).
+ * @returns The stalest all-fresh candidate, or null if none exist.
+ */
+export declare function selectTier2Candidate(metas: PhaseCandidateInput[]): Tier2Candidate | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-meta",
-  "version": "0.15.5",
+  "version": "0.15.7",
   "author": "Jason Williscroft",
   "description": "Fastify HTTP service for the Jeeves Meta synthesis engine",
   "license": "BSD-3-Clause",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@karmaniverous/jeeves": "^0.5.10",
-    "@karmaniverous/jeeves-meta-core": "^0.1.0",
+    "@karmaniverous/jeeves-meta-core": "^0.1.1",
     "commander": "^14",
     "croner": "^10",
     "fastify": "^5.8",