@karmaniverous/jeeves-meta 0.15.7 → 0.15.8

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

@@ -9356,6 +9356,8 @@ const serviceConfigSchema = metaConfigSchema.extend({
     watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
     /** Logging configuration. */
     logging: loggingSchema.default(() => loggingSchema.parse({})),
+    /** Max number of all-fresh candidates to scan per tick in Tier 2 invalidation. */
+    tier2ScanLimit: z.number().int().min(1).default(50),
     /**
      * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
      * Rules are evaluated in order; last match wins for steer/crossRefs.
@@ -10789,20 +10791,14 @@ 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.
+ * Select all fully-fresh, non-disabled, non-locked metas sorted by staleness
+ * (descending — stalest first) for Tier 2 invalidation scanning.
  */
-function selectTier2Candidate(metas) {
-    const eligible = metas
+function selectAllTier2Candidates(metas) {
+    return 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 };
+        .sort((a, b) => b.actualStaleness - a.actualStaleness)
+        .map((m) => ({ node: m.node, meta: m.meta }));
 }
 
 /**
@@ -11185,8 +11181,9 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
-        // ── Tier 2 fallback: deep invalidation on stalest all-fresh meta ──
-        return orchestrateTier2(candidates, config, executor, watcher, onProgress, logger);
+        // Tier 2 is now handled by the scheduler; orchestratePhase only handles
+        // targeted (override) paths and Tier 1 corpus-wide selection.
+        return { executed: false };
     }
     // Acquire lock
     if (!acquireLock(winner.node.metaPath)) {
@@ -11252,48 +11249,6 @@ 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.
  */
@@ -12271,7 +12226,7 @@ class Scheduler {
             const candidates = buildPhaseCandidates(result.entries, this.config.architectEvery);
             const winner = selectPhaseCandidate(candidates, this.config.depthWeight);
             if (!winner)
-                return null;
+                return await this.discoverTier2Phase(candidates);
             return {
                 path: winner.node.metaPath,
                 phase: winner.owedPhase,
@@ -12283,6 +12238,57 @@ class Scheduler {
             return null;
         }
     }
+    /**
+     * Tier 2 invalidation: iterate all-fresh candidates (stalest first),
+     * run computeInvalidation, and return the first that produces an owed phase.
+     */
+    async discoverTier2Phase(candidates) {
+        const allTier2 = selectAllTier2Candidates(candidates);
+        const limit = this.config.tier2ScanLimit;
+        const tier2Candidates = allTier2.slice(0, limit);
+        if (allTier2.length > limit) {
+            this.logger.debug({ total: allTier2.length, limit }, 'Tier 2 scan limit reached, scanning subset');
+        }
+        let dirty = false;
+        for (const t2 of tier2Candidates) {
+            if (!acquireLock(t2.node.metaPath))
+                continue;
+            try {
+                const currentMeta = await readMetaJson(t2.node.metaPath);
+                const { scopeFiles } = await getScopeFiles(t2.node, this.watcher);
+                const result = await computeInvalidation(currentMeta, scopeFiles, this.config, t2.node);
+                const owedPhase = getOwedPhase(result.phaseState);
+                if (owedPhase) {
+                    await persistPhaseState({
+                        metaPath: t2.node.metaPath,
+                        current: currentMeta,
+                        config: this.config,
+                        structureHash: result.structureHash,
+                    }, result.phaseState, {});
+                    this.cache.invalidate();
+                    return {
+                        path: t2.node.metaPath,
+                        phase: owedPhase,
+                        band: getPriorityBand(result.phaseState),
+                    };
+                }
+                // No invalidation — bump _generatedAt to delay re-checking
+                await persistPhaseState({
+                    metaPath: t2.node.metaPath,
+                    current: currentMeta,
+                    config: this.config,
+                    structureHash: result.structureHash,
+                }, result.phaseState, { _generatedAt: new Date().toISOString() });
+                dirty = true;
+            }
+            finally {
+                releaseLock(t2.node.metaPath);
+            }
+        }
+        if (dirty)
+            this.cache.invalidate();
+        return null;
+    }
 }
 
 /**

package/dist/index.js

@@ -9050,6 +9050,8 @@ const serviceConfigSchema = metaConfigSchema.extend({
     watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
     /** Logging configuration. */
     logging: loggingSchema.default(() => loggingSchema.parse({})),
+    /** Max number of all-fresh candidates to scan per tick in Tier 2 invalidation. */
+    tier2ScanLimit: z.number().int().min(1).default(50),
     /**
      * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
      * Rules are evaluated in order; last match wins for steer/crossRefs.
@@ -10340,20 +10342,14 @@ 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.
+ * Select all fully-fresh, non-disabled, non-locked metas sorted by staleness
+ * (descending — stalest first) for Tier 2 invalidation scanning.
  */
-function selectTier2Candidate(metas) {
-    const eligible = metas
+function selectAllTier2Candidates(metas) {
+    return 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 };
+        .sort((a, b) => b.actualStaleness - a.actualStaleness)
+        .map((m) => ({ node: m.node, meta: m.meta }));
 }
 
 /**
@@ -10736,8 +10732,9 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
-        // ── Tier 2 fallback: deep invalidation on stalest all-fresh meta ──
-        return orchestrateTier2(candidates, config, executor, watcher, onProgress, logger);
+        // Tier 2 is now handled by the scheduler; orchestratePhase only handles
+        // targeted (override) paths and Tier 1 corpus-wide selection.
+        return { executed: false };
     }
     // Acquire lock
     if (!acquireLock(winner.node.metaPath)) {
@@ -10803,48 +10800,6 @@ 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.
  */
@@ -11822,7 +11777,7 @@ class Scheduler {
             const candidates = buildPhaseCandidates(result.entries, this.config.architectEvery);
             const winner = selectPhaseCandidate(candidates, this.config.depthWeight);
             if (!winner)
-                return null;
+                return await this.discoverTier2Phase(candidates);
             return {
                 path: winner.node.metaPath,
                 phase: winner.owedPhase,
@@ -11834,6 +11789,57 @@ class Scheduler {
             return null;
         }
     }
+    /**
+     * Tier 2 invalidation: iterate all-fresh candidates (stalest first),
+     * run computeInvalidation, and return the first that produces an owed phase.
+     */
+    async discoverTier2Phase(candidates) {
+        const allTier2 = selectAllTier2Candidates(candidates);
+        const limit = this.config.tier2ScanLimit;
+        const tier2Candidates = allTier2.slice(0, limit);
+        if (allTier2.length > limit) {
+            this.logger.debug({ total: allTier2.length, limit }, 'Tier 2 scan limit reached, scanning subset');
+        }
+        let dirty = false;
+        for (const t2 of tier2Candidates) {
+            if (!acquireLock(t2.node.metaPath))
+                continue;
+            try {
+                const currentMeta = await readMetaJson(t2.node.metaPath);
+                const { scopeFiles } = await getScopeFiles(t2.node, this.watcher);
+                const result = await computeInvalidation(currentMeta, scopeFiles, this.config, t2.node);
+                const owedPhase = getOwedPhase(result.phaseState);
+                if (owedPhase) {
+                    await persistPhaseState({
+                        metaPath: t2.node.metaPath,
+                        current: currentMeta,
+                        config: this.config,
+                        structureHash: result.structureHash,
+                    }, result.phaseState, {});
+                    this.cache.invalidate();
+                    return {
+                        path: t2.node.metaPath,
+                        phase: owedPhase,
+                        band: getPriorityBand(result.phaseState),
+                    };
+                }
+                // No invalidation — bump _generatedAt to delay re-checking
+                await persistPhaseState({
+                    metaPath: t2.node.metaPath,
+                    current: currentMeta,
+                    config: this.config,
+                    structureHash: result.structureHash,
+                }, result.phaseState, { _generatedAt: new Date().toISOString() });
+                dirty = true;
+            }
+            finally {
+                releaseLock(t2.node.metaPath);
+            }
+        }
+        if (dirty)
+            this.cache.invalidate();
+        return null;
+    }
 }
 
 /**

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, selectTier2Candidate, type Tier2Candidate, } from './phaseScheduler.js';
+export { buildPhaseCandidates, type PhaseCandidate, type PhaseCandidateInput, rankPhaseCandidates, selectAllTier2Candidates, 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

@@ -69,3 +69,8 @@ export interface Tier2Candidate {
  * @returns The stalest all-fresh candidate, or null if none exist.
  */
 export declare function selectTier2Candidate(metas: PhaseCandidateInput[]): Tier2Candidate | null;
+/**
+ * Select all fully-fresh, non-disabled, non-locked metas sorted by staleness
+ * (descending — stalest first) for Tier 2 invalidation scanning.
+ */
+export declare function selectAllTier2Candidates(metas: PhaseCandidateInput[]): Tier2Candidate[];

package/dist/scheduler/index.d.ts

@@ -63,4 +63,9 @@ export declare class Scheduler {
      * with weighted staleness as tiebreaker within a band.
      */
     private discoverNextPhase;
+    /**
+     * Tier 2 invalidation: iterate all-fresh candidates (stalest first),
+     * run computeInvalidation, and return the first that produces an owed phase.
+     */
+    private discoverTier2Phase;
 }

package/dist/schema/config.d.ts

@@ -44,6 +44,7 @@ export declare const serviceConfigSchema: z.ZodObject<{
         level: z.ZodDefault<z.ZodString>;
         file: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    tier2ScanLimit: z.ZodDefault<z.ZodNumber>;
     autoSeed: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
         match: z.ZodString;
         steer: z.ZodOptional<z.ZodString>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-meta",
-  "version": "0.15.7",
+  "version": "0.15.8",
   "author": "Jason Williscroft",
   "description": "Fastify HTTP service for the Jeeves Meta synthesis engine",
   "license": "BSD-3-Clause",