@ornexus/neocortex 4.60.66 → 4.60.68

package/packages/client/dist/resilience/circuit-breaker.js

@@ -1 +1,170 @@
-import{readFile as l,writeFile as o,mkdir as h}from"node:fs/promises";import{dirname as u}from"node:path";import{homedir as c}from"node:os";import{join as f}from"node:path";const n={failureThreshold:3,failureWindowMs:6e4,halfOpenAfterMs:6e4,stateFilePath:f(c(),".neocortex",".circuit-state")},r={state:"CLOSED",failures:[],openedAt:null,lastProbeAt:null};class i{config;internalState;constructor(t,e){this.config={...n,...t},this.internalState=e?{...e}:{...r,failures:[]}}canCall(){switch(this.pruneExpiredFailures(),this.internalState.state){case"CLOSED":return!0;case"OPEN":{const t=Date.now(),e=this.internalState.openedAt??0;return t-e>=this.config.halfOpenAfterMs?(this.internalState.state="HALF_OPEN",this.internalState.lastProbeAt=t,!0):!1}case"HALF_OPEN":return!0;default:return!0}}async recordSuccess(){this.internalState.state="CLOSED",this.internalState.failures=[],this.internalState.openedAt=null,this.internalState.lastProbeAt=null,await this.saveToDisk()}async recordFailure(){const t=Date.now();this.internalState.failures.push({timestamp:t}),this.pruneExpiredFailures(),this.internalState.failures.length>=this.config.failureThreshold&&(this.internalState.state="OPEN",this.internalState.openedAt=t),this.internalState.state==="HALF_OPEN"&&(this.internalState.state="OPEN",this.internalState.openedAt=t),await this.saveToDisk()}getState(){return this.pruneExpiredFailures(),{state:this.internalState.state,failures:[...this.internalState.failures],openedAt:this.internalState.openedAt,lastProbeAt:this.internalState.lastProbeAt}}async reset(){this.internalState={...r,failures:[]},await this.saveToDisk()}static async loadFromDisk(t){const e=t??n.stateFilePath;try{const s=await l(e,"utf8"),a=JSON.parse(s);return!a.state||!Array.isArray(a.failures)?new i({stateFilePath:e}):new i({stateFilePath:e},a)}catch{return new i({stateFilePath:e})}}pruneExpiredFailures(){const t=Date.now()-this.config.failureWindowMs;this.internalState.failures=this.internalState.failures.filter(e=>e.timestamp>t)}async saveToDisk(){try{const t=u(this.config.stateFilePath);await h(t,{recursive:!0});const e=`${this.config.stateFilePath}.tmp`,s=JSON.stringify(this.internalState,null,2);await o(e,s,"utf8");const{rename:a}=await import("node:fs/promises");await a(e,this.config.stateFilePath)}catch{}}}export{i as ClientCircuitBreaker};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+/**
+ * @neocortex/client - Persistent Circuit Breaker
+ *
+ * Circuit breaker with file-based state persistence for the CLI client.
+ * Tracks server health using window-based failure counting and persists
+ * state between CLI invocations at ~/.neocortex/.circuit-state.
+ *
+ * States:
+ *   CLOSED    - Normal operation, requests pass through
+ *   OPEN      - Circuit tripped, requests fail immediately (use cache)
+ *   HALF_OPEN - Testing if server recovered (one probe request allowed)
+ *
+ * Story 42.9
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// ── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    failureThreshold: 3,
+    failureWindowMs: 60_000,
+    halfOpenAfterMs: 60_000,
+    stateFilePath: join(homedir(), '.neocortex', '.circuit-state'),
+};
+const INITIAL_STATE = {
+    state: 'CLOSED',
+    failures: [],
+    openedAt: null,
+    lastProbeAt: null,
+};
+// ── ClientCircuitBreaker ──────────────────────────────────────────────────
+export class ClientCircuitBreaker {
+    config;
+    internalState;
+    constructor(config, initialState) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.internalState = initialState ? { ...initialState } : { ...INITIAL_STATE, failures: [] };
+    }
+    /**
+     * Check if a request can be made to the server.
+     * Returns false if circuit is OPEN (fail-fast to cache).
+     */
+    canCall() {
+        this.pruneExpiredFailures();
+        switch (this.internalState.state) {
+            case 'CLOSED':
+                return true;
+            case 'OPEN': {
+                const now = Date.now();
+                const openedAt = this.internalState.openedAt ?? 0;
+                if (now - openedAt >= this.config.halfOpenAfterMs) {
+                    this.internalState.state = 'HALF_OPEN';
+                    this.internalState.lastProbeAt = now;
+                    return true;
+                }
+                return false;
+            }
+            case 'HALF_OPEN':
+                return true;
+            default:
+                return true;
+        }
+    }
+    /**
+     * Record a successful server response. Closes the circuit.
+     */
+    async recordSuccess() {
+        this.internalState.state = 'CLOSED';
+        this.internalState.failures = [];
+        this.internalState.openedAt = null;
+        this.internalState.lastProbeAt = null;
+        await this.saveToDisk();
+    }
+    /**
+     * Record a failed server response. Opens circuit after threshold failures in window.
+     */
+    async recordFailure() {
+        const now = Date.now();
+        this.internalState.failures.push({ timestamp: now });
+        this.pruneExpiredFailures();
+        if (this.internalState.failures.length >= this.config.failureThreshold) {
+            this.internalState.state = 'OPEN';
+            this.internalState.openedAt = now;
+        }
+        // If in HALF_OPEN and probe fails, go back to OPEN
+        if (this.internalState.state === 'HALF_OPEN') {
+            this.internalState.state = 'OPEN';
+            this.internalState.openedAt = now;
+        }
+        await this.saveToDisk();
+    }
+    /**
+     * Get current circuit breaker state (copy).
+     */
+    getState() {
+        this.pruneExpiredFailures();
+        return {
+            state: this.internalState.state,
+            failures: [...this.internalState.failures],
+            openedAt: this.internalState.openedAt,
+            lastProbeAt: this.internalState.lastProbeAt,
+        };
+    }
+    /**
+     * Reset circuit breaker to initial CLOSED state.
+     */
+    async reset() {
+        this.internalState = { ...INITIAL_STATE, failures: [] };
+        await this.saveToDisk();
+    }
+    /**
+     * Load circuit breaker state from disk.
+     */
+    static async loadFromDisk(path) {
+        const filePath = path ?? DEFAULT_CONFIG.stateFilePath;
+        try {
+            const raw = await readFile(filePath, 'utf8');
+            const data = JSON.parse(raw);
+            // Validate loaded state
+            if (!data.state || !Array.isArray(data.failures)) {
+                return new ClientCircuitBreaker({ stateFilePath: filePath });
+            }
+            return new ClientCircuitBreaker({ stateFilePath: filePath }, data);
+        }
+        catch {
+            // File doesn't exist or is corrupted - start fresh
+            return new ClientCircuitBreaker({ stateFilePath: filePath });
+        }
+    }
+    // ── Private ─────────────────────────────────────────────────────────
+    /**
+     * Remove failures outside the counting window.
+     */
+    pruneExpiredFailures() {
+        const cutoff = Date.now() - this.config.failureWindowMs;
+        this.internalState.failures = this.internalState.failures.filter((f) => f.timestamp > cutoff);
+    }
+    /**
+     * Persist state to disk with atomic write.
+     */
+    async saveToDisk() {
+        try {
+            const dir = dirname(this.config.stateFilePath);
+            await mkdir(dir, { recursive: true });
+            const tmpPath = `${this.config.stateFilePath}.tmp`;
+            const data = JSON.stringify(this.internalState, null, 2);
+            await writeFile(tmpPath, data, 'utf8');
+            // Atomic rename
+            const { rename } = await import('node:fs/promises');
+            await rename(tmpPath, this.config.stateFilePath);
+        }
+        catch {
+            // Persistence failures are non-critical - circuit breaker
+            // still works in-memory for current session
+        }
+    }
+}

package/packages/client/dist/resilience/degradation-manager.js

@@ -1 +1,164 @@
-var r;(function(s){s[s.ONLINE=0]="ONLINE",s[s.HIGH_LATENCY=1]="HIGH_LATENCY",s[s.SERVER_DOWN=2]="SERVER_DOWN",s[s.STALE_CACHE=3]="STALE_CACHE",s[s.NO_CACHE=4]="NO_CACHE"})(r||(r={}));const i={staleThresholdMs:864e5,warningThresholdMs:432e5,latencyThresholdMs:2e3};class u{config;constructor(e){this.config={...i,...e}}evaluate(e){return e.forceOffline?this.buildCacheOnlyDecision(e,"[OFFLINE]"):e.circuitState==="OPEN"?this.buildServerDownDecision(e):e.circuitState==="HALF_OPEN"?{level:r.SERVER_DOWN,useCache:!0,useServer:!0,prefix:"[PROBING]",warning:null}:e.latencyMs!=null&&e.latencyMs>this.config.latencyThresholdMs?e.cacheAvailable?{level:r.HIGH_LATENCY,useCache:!0,useServer:!1,prefix:"[CACHED]",warning:null}:{level:r.HIGH_LATENCY,useCache:!1,useServer:!0,prefix:"",warning:"Server response is slow. Consider running `neocortex cache warmup`."}:{level:r.ONLINE,useCache:!1,useServer:!0,prefix:"",warning:null}}buildServerDownDecision(e){if(!e.cacheAvailable)return{level:r.NO_CACHE,useCache:!1,useServer:!1,prefix:"[ERROR]",warning:"Server unavailable and no cached data. Run `neocortex cache warmup` when online."};const a=e.cacheAgeMs??0;if(a>this.config.staleThresholdMs){const n=this.formatAge(a);return{level:r.STALE_CACHE,useCache:!0,useServer:!1,prefix:`[STALE CACHE - ${n}]`,warning:`Cache is stale (${n} old). Data may be outdated.`}}return{level:r.SERVER_DOWN,useCache:!0,useServer:!1,prefix:"[CACHED]",warning:a>this.config.warningThresholdMs?`Cache is ${this.formatAge(a)} old.`:null}}buildCacheOnlyDecision(e,a){if(!e.cacheAvailable)return{level:r.NO_CACHE,useCache:!1,useServer:!1,prefix:"[ERROR]",warning:"Offline mode active but no cached data available. Run `neocortex cache warmup` when online."};const n=e.cacheAgeMs??0;if(n>this.config.staleThresholdMs){const l=this.formatAge(n);return{level:r.STALE_CACHE,useCache:!0,useServer:!1,prefix:`[STALE CACHE - ${l}]`,warning:`Using stale cache (${l} old) in offline mode.`}}return{level:r.SERVER_DOWN,useCache:!0,useServer:!1,prefix:a,warning:null}}formatAge(e){const a=Math.floor(e/36e5);if(a>=48)return`${Math.floor(a/24)}d`;if(a>=1)return`${a}h`;const n=Math.floor(e/6e4);return n>=1?`${n}m`:"<1m"}}export{r as DegradationLevel,u as DegradationManager};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+// ── Types ─────────────────────────────────────────────────────────────────
+export var DegradationLevel;
+(function (DegradationLevel) {
+    /** Server available, fresh data, optimal performance */
+    DegradationLevel[DegradationLevel["ONLINE"] = 0] = "ONLINE";
+    /** Server slow (>2s), use cache when available */
+    DegradationLevel[DegradationLevel["HIGH_LATENCY"] = 1] = "HIGH_LATENCY";
+    /** Server down, use cache exclusively */
+    DegradationLevel[DegradationLevel["SERVER_DOWN"] = 2] = "SERVER_DOWN";
+    /** Cache expired (>24h), use with warning */
+    DegradationLevel[DegradationLevel["STALE_CACHE"] = 3] = "STALE_CACHE";
+    /** No cache and no server - error state */
+    DegradationLevel[DegradationLevel["NO_CACHE"] = 4] = "NO_CACHE";
+})(DegradationLevel || (DegradationLevel = {}));
+// ── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    staleThresholdMs: 86_400_000, // 24 hours
+    warningThresholdMs: 43_200_000, // 12 hours
+    latencyThresholdMs: 2_000, // 2 seconds
+};
+// ── DegradationManager ───────────────────────────────────────────────────
+export class DegradationManager {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Evaluate the current degradation level based on context.
+     */
+    evaluate(context) {
+        // Force-offline mode: always use cache
+        if (context.forceOffline) {
+            return this.buildCacheOnlyDecision(context, '[OFFLINE]');
+        }
+        // Circuit is OPEN: server known to be down
+        if (context.circuitState === 'OPEN') {
+            return this.buildServerDownDecision(context);
+        }
+        // Circuit is HALF_OPEN: probing server
+        if (context.circuitState === 'HALF_OPEN') {
+            // Allow server request (probe), but prepare cache fallback
+            return {
+                level: DegradationLevel.SERVER_DOWN,
+                useCache: true,
+                useServer: true,
+                prefix: '[PROBING]',
+                warning: null,
+            };
+        }
+        // Circuit is CLOSED: server available
+        if (context.latencyMs != null && context.latencyMs > this.config.latencyThresholdMs) {
+            // High latency: prefer cache if available
+            if (context.cacheAvailable) {
+                return {
+                    level: DegradationLevel.HIGH_LATENCY,
+                    useCache: true,
+                    useServer: false,
+                    prefix: '[CACHED]',
+                    warning: null,
+                };
+            }
+            // No cache available: still use server (slow is better than nothing)
+            return {
+                level: DegradationLevel.HIGH_LATENCY,
+                useCache: false,
+                useServer: true,
+                prefix: '',
+                warning: 'Server response is slow. Consider running `neocortex cache warmup`.',
+            };
+        }
+        // Normal operation
+        return {
+            level: DegradationLevel.ONLINE,
+            useCache: false,
+            useServer: true,
+            prefix: '',
+            warning: null,
+        };
+    }
+    // ── Private ─────────────────────────────────────────────────────────
+    buildServerDownDecision(context) {
+        if (!context.cacheAvailable) {
+            return {
+                level: DegradationLevel.NO_CACHE,
+                useCache: false,
+                useServer: false,
+                prefix: '[ERROR]',
+                warning: 'Server unavailable and no cached data. Run `neocortex cache warmup` when online.',
+            };
+        }
+        const cacheAgeMs = context.cacheAgeMs ?? 0;
+        if (cacheAgeMs > this.config.staleThresholdMs) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            return {
+                level: DegradationLevel.STALE_CACHE,
+                useCache: true,
+                useServer: false,
+                prefix: `[STALE CACHE - ${ageStr}]`,
+                warning: `Cache is stale (${ageStr} old). Data may be outdated.`,
+            };
+        }
+        return {
+            level: DegradationLevel.SERVER_DOWN,
+            useCache: true,
+            useServer: false,
+            prefix: '[CACHED]',
+            warning: cacheAgeMs > this.config.warningThresholdMs
+                ? `Cache is ${this.formatAge(cacheAgeMs)} old.`
+                : null,
+        };
+    }
+    buildCacheOnlyDecision(context, prefix) {
+        if (!context.cacheAvailable) {
+            return {
+                level: DegradationLevel.NO_CACHE,
+                useCache: false,
+                useServer: false,
+                prefix: '[ERROR]',
+                warning: 'Offline mode active but no cached data available. Run `neocortex cache warmup` when online.',
+            };
+        }
+        const cacheAgeMs = context.cacheAgeMs ?? 0;
+        if (cacheAgeMs > this.config.staleThresholdMs) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            return {
+                level: DegradationLevel.STALE_CACHE,
+                useCache: true,
+                useServer: false,
+                prefix: `[STALE CACHE - ${ageStr}]`,
+                warning: `Using stale cache (${ageStr} old) in offline mode.`,
+            };
+        }
+        return {
+            level: DegradationLevel.SERVER_DOWN,
+            useCache: true,
+            useServer: false,
+            prefix,
+            warning: null,
+        };
+    }
+    formatAge(ms) {
+        const hours = Math.floor(ms / 3_600_000);
+        if (hours >= 48)
+            return `${Math.floor(hours / 24)}d`;
+        if (hours >= 1)
+            return `${hours}h`;
+        const minutes = Math.floor(ms / 60_000);
+        if (minutes >= 1)
+            return `${minutes}m`;
+        return '<1m';
+    }
+}

package/packages/client/dist/resilience/freshness-indicator.js

@@ -1 +1,100 @@
-import{DegradationLevel as e}from"./degradation-manager.js";const l={staleThresholdMs:864e5,warningThresholdMs:432e5};class h{config;constructor(t){this.config={...l,...t}}formatAge(t){if(t<0)return"just now";const r=Math.floor(t/1e3),n=Math.floor(t/6e4),s=Math.floor(t/36e5),o=Math.floor(t/864e5);return o>=1?`${o}d ago`:s>=1?`${s}h ago`:n>=1?`${n}m ago`:r>=1?`${r}s ago`:"just now"}evaluate(t,r){const n=t>this.config.staleThresholdMs,s=t>this.config.warningThresholdMs;let o=null,i="[CACHED]";if(n){const a=this.formatAge(t);i=`[STALE CACHE - ${a}]`,o=`WARNING: STALE - cached ${a}`}else if(s){const a=this.formatAge(t);i="[CACHED]",o=`WARNING - cached ${a}`}return{cached:!0,cacheAgeMs:t,stale:n,warning:o,prefix:i}}formatPrefix(t,r){switch(t){case e.ONLINE:return"";case e.HIGH_LATENCY:return r!=null?`[CACHED] cached ${this.formatAge(r)}`:"[CACHED]";case e.SERVER_DOWN:return r!=null?`[CACHED] cached ${this.formatAge(r)}`:"[CACHED]";case e.STALE_CACHE:return r!=null?`[STALE CACHE - ${this.formatAge(r)}]`:"[STALE CACHE]";case e.NO_CACHE:return"[ERROR]";default:return""}}}export{h as FreshnessIndicator};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+/**
+ * @neocortex/client - Freshness Indicator
+ *
+ * Enriches cache responses with freshness metadata for user-facing display.
+ * Formats cache age as human-readable strings and generates appropriate
+ * warning prefixes based on degradation level.
+ *
+ * Story 42.9
+ */
+import { DegradationLevel } from './degradation-manager.js';
+// ── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    staleThresholdMs: 86_400_000, // 24 hours
+    warningThresholdMs: 43_200_000, // 12 hours
+};
+// ── FreshnessIndicator ──────────────────────────────────────────────────
+export class FreshnessIndicator {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Format a duration in ms as human-readable age string.
+     * Examples: "30m ago", "4h ago", "2d ago"
+     */
+    formatAge(ageMs) {
+        if (ageMs < 0)
+            return 'just now';
+        const seconds = Math.floor(ageMs / 1_000);
+        const minutes = Math.floor(ageMs / 60_000);
+        const hours = Math.floor(ageMs / 3_600_000);
+        const days = Math.floor(ageMs / 86_400_000);
+        if (days >= 1)
+            return `${days}d ago`;
+        if (hours >= 1)
+            return `${hours}h ago`;
+        if (minutes >= 1)
+            return `${minutes}m ago`;
+        if (seconds >= 1)
+            return `${seconds}s ago`;
+        return 'just now';
+    }
+    /**
+     * Evaluate freshness of a cache entry.
+     */
+    evaluate(cacheAgeMs, _ttlMs) {
+        const stale = cacheAgeMs > this.config.staleThresholdMs;
+        const aged = cacheAgeMs > this.config.warningThresholdMs;
+        let warning = null;
+        let prefix = '[CACHED]';
+        if (stale) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            prefix = `[STALE CACHE - ${ageStr}]`;
+            warning = `WARNING: STALE - cached ${ageStr}`;
+        }
+        else if (aged) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            prefix = `[CACHED]`;
+            warning = `WARNING - cached ${ageStr}`;
+        }
+        return {
+            cached: true,
+            cacheAgeMs,
+            stale,
+            warning,
+            prefix,
+        };
+    }
+    /**
+     * Format prefix string based on degradation level and optional age.
+     */
+    formatPrefix(level, ageMs) {
+        switch (level) {
+            case DegradationLevel.ONLINE:
+                return '';
+            case DegradationLevel.HIGH_LATENCY:
+                return ageMs != null ? `[CACHED] cached ${this.formatAge(ageMs)}` : '[CACHED]';
+            case DegradationLevel.SERVER_DOWN:
+                return ageMs != null ? `[CACHED] cached ${this.formatAge(ageMs)}` : '[CACHED]';
+            case DegradationLevel.STALE_CACHE:
+                return ageMs != null ? `[STALE CACHE - ${this.formatAge(ageMs)}]` : '[STALE CACHE]';
+            case DegradationLevel.NO_CACHE:
+                return '[ERROR]';
+            default:
+                return '';
+        }
+    }
+}

package/packages/client/dist/resilience/index.js

@@ -1 +1,8 @@
-import{ClientCircuitBreaker as o}from"./circuit-breaker.js";import{DegradationManager as a,DegradationLevel as i}from"./degradation-manager.js";import{FreshnessIndicator as c}from"./freshness-indicator.js";import{RecoveryDetector as m}from"./recovery-detector.js";export{o as ClientCircuitBreaker,i as DegradationLevel,a as DegradationManager,c as FreshnessIndicator,m as RecoveryDetector};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ */
+export { ClientCircuitBreaker } from './circuit-breaker.js';
+export { DegradationManager, DegradationLevel } from './degradation-manager.js';
+export { FreshnessIndicator } from './freshness-indicator.js';
+export { RecoveryDetector } from './recovery-detector.js';

package/packages/client/dist/resilience/recovery-detector.js

@@ -1 +1,74 @@
-class n{actions;constructor(e){this.actions=e}async onRecovery(){const e={circuitClosed:!1,jwtRefreshed:!1,cacheSynced:!1,telemetryFlushed:{sent:0,failed:0},notification:"[ONLINE] Server connection restored"};try{await this.actions.circuitBreaker.recordSuccess(),e.circuitClosed=!0}catch{}try{const t=await this.actions.licenseClient.getToken();e.jwtRefreshed=t!==null}catch{}try{e.cacheSynced=!0}catch{}try{const t=await this.actions.telemetryQueue.flush(async c=>(await fetch(`${this.actions.serverUrl}/api/v1/telemetry/batch`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({events:c})})).ok);e.telemetryFlushed=t}catch{}return e}}export{n as RecoveryDetector};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+// ── RecoveryDetector ─────────────────────────────────────────────────────
+export class RecoveryDetector {
+    actions;
+    constructor(actions) {
+        this.actions = actions;
+    }
+    /**
+     * Execute full recovery sequence.
+     * Each step is independent - failures are captured but don't block others.
+     */
+    async onRecovery() {
+        const result = {
+            circuitClosed: false,
+            jwtRefreshed: false,
+            cacheSynced: false,
+            telemetryFlushed: { sent: 0, failed: 0 },
+            notification: '[ONLINE] Server connection restored',
+        };
+        // Step 1: Close circuit breaker
+        try {
+            await this.actions.circuitBreaker.recordSuccess();
+            result.circuitClosed = true;
+        }
+        catch {
+            // Non-critical: breaker will close on next successful call
+        }
+        // Step 2: Re-validate JWT
+        try {
+            const token = await this.actions.licenseClient.getToken();
+            result.jwtRefreshed = token !== null;
+        }
+        catch {
+            // Non-critical: will be retried on next server call
+        }
+        // Step 3: Sync cache (background - just attempt, don't block)
+        try {
+            // We don't actually sync here - the next resolver call will
+            // update the cache automatically via fetchWithCacheFallback.
+            // We just mark as synced since the circuit is now closed.
+            result.cacheSynced = true;
+        }
+        catch {
+            // Non-critical
+        }
+        // Step 4: Flush telemetry queue
+        try {
+            const flushResult = await this.actions.telemetryQueue.flush(async (events) => {
+                const response = await fetch(`${this.actions.serverUrl}/api/v1/telemetry/batch`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ events }),
+                });
+                return response.ok;
+            });
+            result.telemetryFlushed = flushResult;
+        }
+        catch {
+            // Non-critical: queue will be flushed on next recovery
+        }
+        return result;
+    }
+}

package/packages/client/dist/resolvers/asset-resolver.js

@@ -0,0 +1,13 @@
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+export {};