@karmaniverous/jeeves-meta 0.15.6 → 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.
@@ -10788,6 +10790,16 @@ function rankPhaseCandidates(metas, depthWeight) {
 function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
+/**
+ * Select all fully-fresh, non-disabled, non-locked metas sorted by staleness
+ * (descending — stalest first) for Tier 2 invalidation scanning.
+ */
+function selectAllTier2Candidates(metas) {
+    return metas
+        .filter((m) => !m.locked && !m.disabled && isFullyFresh(m.phaseState))
+        .sort((a, b) => b.actualStaleness - a.actualStaleness)
+        .map((m) => ({ node: m.node, meta: m.meta }));
+}
 
 /**
  * Shared error utilities.
@@ -11169,6 +11181,8 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
+        // 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
@@ -12212,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,
@@ -12224,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.
@@ -10339,6 +10341,16 @@ function rankPhaseCandidates(metas, depthWeight) {
 function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
+/**
+ * Select all fully-fresh, non-disabled, non-locked metas sorted by staleness
+ * (descending — stalest first) for Tier 2 invalidation scanning.
+ */
+function selectAllTier2Candidates(metas) {
+    return metas
+        .filter((m) => !m.locked && !m.disabled && isFullyFresh(m.phaseState))
+        .sort((a, b) => b.actualStaleness - a.actualStaleness)
+        .map((m) => ({ node: m.node, meta: m.meta }));
+}
 
 /**
  * Shared error utilities.
@@ -10720,6 +10732,8 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
+        // 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
@@ -11763,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,
@@ -11775,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, } 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

@@ -55,3 +55,22 @@ 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;
+/**
+ * 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.6",
+  "version": "0.15.8",
   "author": "Jason Williscroft",
   "description": "Fastify HTTP service for the Jeeves Meta synthesis engine",
   "license": "BSD-3-Clause",