shieldcortex 3.4.31 → 3.4.33

package/dist/cortex/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cortex CLI — shieldcortex cortex <subcommand>
+ * Pro tier feature: systematic mistake learning + pre-flight checks.
+ */
+export declare function handleCortexCommand(args: string[]): Promise<void>;

package/dist/cortex/cli.js

@@ -0,0 +1,190 @@
+/**
+ * Cortex CLI — shieldcortex cortex <subcommand>
+ * Pro tier feature: systematic mistake learning + pre-flight checks.
+ */
+import { requireFeature } from '../license/gate.js';
+import { capture, preflight, review, graduate, search, loadMistakes, } from './store.js';
+const SEVERITY_ICON = {
+    critical: '🔴',
+    high: '🟠',
+    medium: '🟡',
+    low: '🟢',
+};
+const VALID_CATEGORIES = [
+    'design', 'code', 'config', 'communication', 'judgement', 'process', 'data', 'security',
+];
+const VALID_SEVERITIES = ['critical', 'high', 'medium', 'low'];
+function printUsage() {
+    console.log(`
+  shieldcortex cortex <command> [options]
+
+  Commands:
+    capture     Log a mistake and extract a prevention rule
+    preflight   Pre-task check against past mistakes
+    review      Pattern analysis and weekly review
+    graduate    Archive learned rules (30+ days, no recurrence)
+    list        Browse mistake log
+    stats       Summary counts and trends
+    search      Full-text search across all entries
+
+  Examples:
+    shieldcortex cortex capture --category code --what "Guessed URLs" --why "Didn't use API" --rule "Always fetch handles from API"
+    shieldcortex cortex preflight --task "deploy to Fly.io"
+    shieldcortex cortex review
+    shieldcortex cortex stats
+  `);
+}
+function parseArgs(args) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--') && i + 1 < args.length) {
+            result[args[i].slice(2)] = args[i + 1];
+            i++;
+        }
+    }
+    return result;
+}
+export async function handleCortexCommand(args) {
+    requireFeature('cortex_learning');
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    const opts = parseArgs(subArgs);
+    switch (subcommand) {
+        case 'capture': {
+            if (!opts.category || !opts.what || !opts.why || !opts.rule) {
+                console.error('Required: --category, --what, --why, --rule');
+                console.error(`Categories: ${VALID_CATEGORIES.join(', ')}`);
+                process.exit(1);
+            }
+            if (!VALID_CATEGORIES.includes(opts.category)) {
+                console.error(`Invalid category. Valid: ${VALID_CATEGORIES.join(', ')}`);
+                process.exit(1);
+            }
+            const entry = capture({
+                category: opts.category,
+                severity: opts.severity || 'medium',
+                what: opts.what,
+                why: opts.why,
+                rule: opts.rule,
+                tags: opts.tags ? opts.tags.split(',').map(t => t.trim()) : [],
+                agent: opts.agent,
+                taskContext: opts.context,
+            });
+            console.log(`✅ Captured mistake #${entry.id}: ${entry.what.slice(0, 60)}...`);
+            console.log(`   Rule: ${entry.rule}`);
+            console.log(`   Category: ${entry.category} | Severity: ${entry.severity}`);
+            break;
+        }
+        case 'preflight': {
+            if (!opts.task) {
+                console.error('Required: --task "description of upcoming task"');
+                process.exit(1);
+            }
+            const matches = preflight(opts.task);
+            if (matches.length === 0) {
+                console.log('✅ Pre-flight clear — no matching past mistakes found.');
+                console.log(`   Task: ${opts.task.slice(0, 80)}`);
+            }
+            else {
+                console.log(`⚠️  PRE-FLIGHT CHECK — ${matches.length} relevant past mistake(s):\n`);
+                for (const { mistake: m } of matches) {
+                    const icon = SEVERITY_ICON[m.severity] || '⚪';
+                    console.log(`  ${icon} #${m.id} [${m.category}] ${m.rule}`);
+                    if (m.recurrences > 0) {
+                        console.log(`     ↳ Recurred ${m.recurrences}x — pay extra attention`);
+                    }
+                }
+                console.log(`\n  📋 Review these before proceeding with: ${opts.task.slice(0, 60)}`);
+            }
+            break;
+        }
+        case 'review': {
+            const stats = review();
+            if (stats.total === 0) {
+                console.log('No mistakes logged yet. Use `shieldcortex cortex capture` to start.');
+                return;
+            }
+            console.log('═══ CORTEX REVIEW ═══\n');
+            console.log(`Total: ${stats.total} (${stats.active} active, ${stats.graduated} graduated)\n`);
+            console.log('By category:');
+            for (const [cat, count] of Object.entries(stats.byCategory).sort((a, b) => b[1] - a[1])) {
+                console.log(`  ${cat.padEnd(15)} ${'█'.repeat(count)} ${count}`);
+            }
+            console.log('\nActive by severity:');
+            for (const sev of ['critical', 'high', 'medium', 'low']) {
+                if (stats.bySeverity[sev]) {
+                    console.log(`  ${SEVERITY_ICON[sev]} ${sev}: ${stats.bySeverity[sev]}`);
+                }
+            }
+            if (stats.repeatOffenders.length > 0) {
+                console.log('\n⚠️  Repeat offenders:');
+                for (const m of stats.repeatOffenders) {
+                    console.log(`  #${m.id} (${m.recurrences}x) ${m.rule.slice(0, 70)}`);
+                }
+            }
+            if (stats.readyToGraduate.length > 0) {
+                console.log(`\n✅ Ready to graduate (${stats.readyToGraduate.length} rules):`);
+                for (const m of stats.readyToGraduate) {
+                    console.log(`  #${m.id} [${m.category}] ${m.rule.slice(0, 70)}`);
+                }
+            }
+            break;
+        }
+        case 'graduate': {
+            const count = graduate();
+            console.log(`🎓 Graduated ${count} rule(s) — learned and archived.`);
+            break;
+        }
+        case 'list': {
+            let mistakes = loadMistakes();
+            if (opts.category)
+                mistakes = mistakes.filter(m => m.category === opts.category);
+            if (opts.severity)
+                mistakes = mistakes.filter(m => m.severity === opts.severity);
+            if (opts.active === 'true')
+                mistakes = mistakes.filter(m => m.status === 'active');
+            if (mistakes.length === 0) {
+                console.log('No matching mistakes.');
+                return;
+            }
+            for (const m of mistakes) {
+                const icon = SEVERITY_ICON[m.severity] || '⚪';
+                const status = m.status === 'graduated' ? '📗' : '📕';
+                console.log(`${status} #${m.id} ${icon} [${m.category}] ${m.what.slice(0, 50)}`);
+                console.log(`   Rule: ${m.rule}`);
+                if (m.tags.length)
+                    console.log(`   Tags: ${m.tags.join(', ')}`);
+                console.log();
+            }
+            break;
+        }
+        case 'stats': {
+            const stats = review();
+            console.log(`📊 Cortex Stats`);
+            console.log(`   Total: ${stats.total} | Active: ${stats.active} | Graduated: ${stats.graduated}`);
+            console.log(`   Last 7 days: ${stats.recentCount}`);
+            console.log(`   Repeat offenders: ${stats.repeatOffenders.length}`);
+            break;
+        }
+        case 'search': {
+            if (!opts.query) {
+                console.error('Required: --query "search terms"');
+                process.exit(1);
+            }
+            const results = search(opts.query);
+            if (results.length === 0) {
+                console.log(`No matches for '${opts.query}'`);
+            }
+            else {
+                console.log(`🔍 ${results.length} match(es) for '${opts.query}':\n`);
+                for (const m of results) {
+                    const icon = SEVERITY_ICON[m.severity] || '⚪';
+                    console.log(`  ${icon} #${m.id} [${m.category}] ${m.rule}`);
+                }
+            }
+            break;
+        }
+        default:
+            printUsage();
+    }
+}

package/dist/cortex/store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Cortex Store — persistent mistake/lesson storage.
+ * Uses the same SQLite database as ShieldCortex memory.
+ * Pro tier feature.
+ */
+export type MistakeCategory = 'design' | 'code' | 'config' | 'communication' | 'judgement' | 'process' | 'data' | 'security';
+export type MistakeSeverity = 'critical' | 'high' | 'medium' | 'low';
+export interface Mistake {
+    id: number;
+    timestamp: string;
+    category: MistakeCategory;
+    severity: MistakeSeverity;
+    what: string;
+    why: string;
+    rule: string;
+    tags: string[];
+    status: 'active' | 'graduated';
+    recurrences: number;
+    graduatedAt: string | null;
+    agent?: string;
+    taskContext?: string;
+}
+export interface PreflightMatch {
+    score: number;
+    mistake: Mistake;
+}
+export interface ReviewStats {
+    total: number;
+    active: number;
+    graduated: number;
+    byCategory: Record<string, number>;
+    bySeverity: Record<string, number>;
+    repeatOffenders: Mistake[];
+    readyToGraduate: Mistake[];
+    recentCount: number;
+}
+export declare function loadMistakes(): Mistake[];
+export declare function saveMistakes(mistakes: Mistake[]): void;
+export declare function capture(opts: {
+    category: MistakeCategory;
+    severity?: MistakeSeverity;
+    what: string;
+    why: string;
+    rule: string;
+    tags?: string[];
+    agent?: string;
+    taskContext?: string;
+}): Mistake;
+export declare function preflight(taskDescription: string): PreflightMatch[];
+export declare function review(): ReviewStats;
+export declare function graduate(): number;
+export declare function search(query: string): Mistake[];

package/dist/cortex/store.js

@@ -0,0 +1,159 @@
+/**
+ * Cortex Store — persistent mistake/lesson storage.
+ * Uses the same SQLite database as ShieldCortex memory.
+ * Pro tier feature.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// ── Storage ──────────────────────────────────────────────
+function getDataDir() {
+    const dir = process.env.SHIELDCORTEX_CONFIG_DIR || join(homedir(), '.shieldcortex');
+    const cortexDir = join(dir, 'cortex');
+    if (!existsSync(cortexDir))
+        mkdirSync(cortexDir, { recursive: true });
+    return cortexDir;
+}
+function getMistakesFile() {
+    return join(getDataDir(), 'mistakes.json');
+}
+export function loadMistakes() {
+    const file = getMistakesFile();
+    if (!existsSync(file))
+        return [];
+    try {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+export function saveMistakes(mistakes) {
+    const file = getMistakesFile();
+    writeFileSync(file, JSON.stringify(mistakes, null, 2) + '\n', { mode: 0o600 });
+}
+// ── Capture ──────────────────────────────────────────────
+export function capture(opts) {
+    const mistakes = loadMistakes();
+    const entry = {
+        id: mistakes.length + 1,
+        timestamp: new Date().toISOString(),
+        category: opts.category,
+        severity: opts.severity || 'medium',
+        what: opts.what,
+        why: opts.why,
+        rule: opts.rule,
+        tags: opts.tags || [],
+        status: 'active',
+        recurrences: 0,
+        graduatedAt: null,
+        agent: opts.agent,
+        taskContext: opts.taskContext,
+    };
+    mistakes.push(entry);
+    saveMistakes(mistakes);
+    return entry;
+}
+// ── Preflight ────────────────────────────────────────────
+const CATEGORY_KEYWORDS = {
+    design: new Set(['design', 'css', 'html', 'pdf', 'layout', 'font', 'colour', 'color', 'brand', 'logo', 'image', 'slide', 'presentation', 'ui', 'ux', 'flyer', 'banner']),
+    code: new Set(['code', 'script', 'python', 'api', 'function', 'bug', 'error', 'import', 'module', 'typescript', 'node', 'build']),
+    config: new Set(['config', 'json', 'yaml', 'env', 'setting', 'port', 'path', 'token', 'key', 'dns', 'nginx', 'oauth', 'credential']),
+    communication: new Set(['email', 'send', 'reply', 'message', 'slack', 'telegram', 'whatsapp', 'draft', 'notify']),
+    judgement: new Set(['decision', 'priority', 'approve', 'confirm', 'check', 'permission', 'authorise', 'authorize']),
+    process: new Set(['deploy', 'git', 'push', 'merge', 'test', 'verify', 'backup', 'release', 'publish', 'cron']),
+    data: new Set(['data', 'database', 'query', 'xero', 'shopify', 'invoice', 'sync', 'migration', 'import', 'export']),
+    security: new Set(['security', 'injection', 'pii', 'firewall', 'scan', 'vulnerability', 'audit', 'breach', 'attack']),
+};
+export function preflight(taskDescription) {
+    const mistakes = loadMistakes();
+    const task = taskDescription.toLowerCase();
+    const taskWords = new Set(task.split(/\s+/));
+    const scored = [];
+    for (const m of mistakes) {
+        if (m.status !== 'active')
+            continue;
+        let score = 0;
+        // Category keyword matching
+        const catKeywords = CATEGORY_KEYWORDS[m.category];
+        if (catKeywords) {
+            for (const word of taskWords) {
+                if (catKeywords.has(word)) {
+                    score += 3;
+                    break;
+                }
+            }
+        }
+        // Tag matching
+        for (const tag of m.tags) {
+            if (task.includes(tag.toLowerCase()))
+                score += 2;
+        }
+        // Rule/what keyword overlap
+        const ruleWords = new Set(`${m.rule} ${m.what}`.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+        for (const word of taskWords) {
+            if (word.length > 3 && ruleWords.has(word))
+                score += 1;
+        }
+        // Severity boost
+        if (m.severity === 'critical')
+            score += 2;
+        else if (m.severity === 'high')
+            score += 1;
+        // Recurrence boost
+        if (m.recurrences > 0)
+            score += m.recurrences;
+        if (score > 0)
+            scored.push({ score, mistake: m });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, 10);
+}
+// ── Review ───────────────────────────────────────────────
+export function review() {
+    const mistakes = loadMistakes();
+    const active = mistakes.filter(m => m.status === 'active');
+    const graduated = mistakes.filter(m => m.status === 'graduated');
+    const byCategory = {};
+    const bySeverity = {};
+    for (const m of active) {
+        byCategory[m.category] = (byCategory[m.category] || 0) + 1;
+        bySeverity[m.severity] = (bySeverity[m.severity] || 0) + 1;
+    }
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 86400000).toISOString();
+    const sevenDaysAgo = new Date(Date.now() - 7 * 86400000).toISOString();
+    return {
+        total: mistakes.length,
+        active: active.length,
+        graduated: graduated.length,
+        byCategory,
+        bySeverity,
+        repeatOffenders: active.filter(m => m.recurrences > 0).sort((a, b) => b.recurrences - a.recurrences),
+        readyToGraduate: active.filter(m => m.timestamp < thirtyDaysAgo && m.recurrences === 0),
+        recentCount: mistakes.filter(m => m.timestamp > sevenDaysAgo).length,
+    };
+}
+// ── Graduate ─────────────────────────────────────────────
+export function graduate() {
+    const mistakes = loadMistakes();
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 86400000).toISOString();
+    let count = 0;
+    for (const m of mistakes) {
+        if (m.status === 'active' && m.timestamp < thirtyDaysAgo && m.recurrences === 0) {
+            m.status = 'graduated';
+            m.graduatedAt = new Date().toISOString();
+            count++;
+        }
+    }
+    saveMistakes(mistakes);
+    return count;
+}
+// ── Search ───────────────────────────────────────────────
+export function search(query) {
+    const mistakes = loadMistakes();
+    const q = query.toLowerCase();
+    return mistakes.filter(m => {
+        const text = `${m.what} ${m.why} ${m.rule} ${m.tags.join(' ')}`.toLowerCase();
+        return text.includes(q);
+    });
+}

package/dist/index.d.ts

@@ -43,6 +43,10 @@
  *   shieldcortex codex install           # Configure MCP server for Codex CLI + VS Code extension
  *   shieldcortex codex uninstall         # Remove Codex MCP configuration
  *   shieldcortex codex status            # Check Codex MCP configuration
+ *   shieldcortex cortex capture      # Log a mistake with rule extraction
+ *   shieldcortex cortex preflight    # Pre-flight check before a task
+ *   shieldcortex cortex review       # Weekly pattern review
+ *   shieldcortex cortex graduate     # Archive learned rules
  *   shieldcortex license activate <key>  # Activate a licence key
  *   shieldcortex license status          # Show current licence tier and features
  *   shieldcortex license deactivate      # Remove licence

package/dist/index.js

@@ -43,6 +43,10 @@
  *   shieldcortex codex install           # Configure MCP server for Codex CLI + VS Code extension
  *   shieldcortex codex uninstall         # Remove Codex MCP configuration
  *   shieldcortex codex status            # Check Codex MCP configuration
+ *   shieldcortex cortex capture      # Log a mistake with rule extraction
+ *   shieldcortex cortex preflight    # Pre-flight check before a task
+ *   shieldcortex cortex review       # Weekly pattern review
+ *   shieldcortex cortex graduate     # Archive learned rules
  *   shieldcortex license activate <key>  # Activate a licence key
  *   shieldcortex license status          # Show current licence tier and features
  *   shieldcortex license deactivate      # Remove licence
@@ -446,6 +450,7 @@ ${bold}COMMANDS${reset}
   ${cyan}quickstart${reset} [target]    Detect integrations and guide/install setup
   ${cyan}config${reset} [options]      Configure cloud sync and settings
   ${cyan}cloud${reset} sync --full     Backfill local memories + graph to ShieldCortex Cloud
+  ${cyan}cortex${reset} <command>       Mistake learning & pre-flight checks (Pro)
   ${cyan}license${reset} <action>      Manage licence key (activate, status, deactivate)
   ${cyan}iron-dome${reset} <action>    Manage behaviour protection layer
   ${cyan}audit${reset} [options]       Run a full security audit
@@ -468,6 +473,7 @@ ${bold}EXAMPLES${reset}
   shieldcortex scan-skill ~/.claude/skills/my-skill/SKILL.md
   shieldcortex dashboard
   shieldcortex worker
+  shieldcortex cortex preflight --task "deploy site"
   shieldcortex license activate sc_pro_...
   shieldcortex config --cloud-enable --cloud-api-key <key>
   shieldcortex cloud sync --full
@@ -743,12 +749,18 @@ ${bold}DOCS${reset}
         console.log(`\n${bold}Summary:${reset} ${filesToScan.length} scanned, ${threatCount} with threats\n`);
         process.exit(threatCount > 0 ? 1 : 0);
     }
+    // Handle "cortex" subcommand (Pro tier — mistake learning)
+    if (process.argv[2] === 'cortex') {
+        const { handleCortexCommand } = await import('./cortex/cli.js');
+        await handleCortexCommand(process.argv.slice(3));
+        process.exit(0);
+    }
     // Guard: if an unknown subcommand was given, show help instead of silently starting MCP
     const knownCommands = new Set([
         'doctor', 'quickstart', 'setup', 'install', 'migrate', 'uninstall', 'hook',
         'openclaw', 'clawdbot', 'copilot', 'codex', 'service', 'config', 'status',
         'graph', 'license', 'licence', 'audit', 'iron-dome', 'scan', 'cloud',
-        'scan-skill', 'scan-skills', 'dashboard', 'api', 'worker', 'stats',
+        'scan-skill', 'scan-skills', 'dashboard', 'api', 'worker', 'stats', 'cortex',
     ]);
     const arg = process.argv[2];
     if (arg && !arg.startsWith('-') && !knownCommands.has(arg)) {

package/dist/license/gate.d.ts

@@ -6,7 +6,7 @@
  *   isFeatureEnabled('cloud_sync');               // returns boolean (soft check)
  */
 import { type LicenseTier } from './keys.js';
-export type GatedFeature = 'custom_injection_patterns' | 'custom_iron_dome_policies' | 'custom_firewall_rules' | 'audit_export' | 'skill_scanner_deep' | 'cloud_sync' | 'team_management' | 'shared_patterns';
+export type GatedFeature = 'custom_injection_patterns' | 'custom_iron_dome_policies' | 'custom_firewall_rules' | 'audit_export' | 'skill_scanner_deep' | 'cloud_sync' | 'team_management' | 'shared_patterns' | 'cortex_learning';
 export declare class FeatureGatedError extends Error {
     feature: GatedFeature;
     requiredTier: LicenseTier;

package/dist/license/gate.js

@@ -16,6 +16,7 @@ const FEATURE_TIERS = {
     cloud_sync: 'team',
     team_management: 'team',
     shared_patterns: 'team',
+    cortex_learning: 'pro',
 };
 const FEATURE_DESCRIPTIONS = {
     custom_injection_patterns: 'Define up to 50 custom regex patterns for detecting domain-specific threats.',
@@ -26,6 +27,7 @@ const FEATURE_DESCRIPTIONS = {
     cloud_sync: 'Sync audit data across devices for centralised team visibility.',
     team_management: 'Manage team members, invites, and shared security policies.',
     shared_patterns: 'Share custom injection patterns and policies across your team.',
+    cortex_learning: 'Systematic mistake learning with pre-flight checks, pattern detection, and rule graduation.',
 };
 // ── Error class ──────────────────────────────────────────
 export class FeatureGatedError extends Error {

package/dist/setup/openclaw.js

@@ -360,11 +360,30 @@ function findExtensionsDir() {
  * Copy the real-time plugin to ~/.openclaw/extensions/shieldcortex-realtime/
  * so OpenClaw discovers it via the global extensions directory.
  */
+function isPluginInLoadPaths() {
+    const configPath = openClawConfigPath();
+    if (!fs.existsSync(configPath))
+        return false;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const paths = config.plugins?.load?.paths ?? [];
+        return paths.some((p) => typeof p === 'string' && p.includes(PLUGIN_DIR_NAME));
+    }
+    catch {
+        return false;
+    }
+}
 function installPlugin() {
     const nativeInstall = tryNativeOpenClawPluginInstall();
     if (nativeInstall) {
         return nativeInstall;
     }
+    // Native install (--link) registers via load.paths — skip the extensions
+    // copy to avoid duplicate plugin ID warnings.
+    if (isPluginInLoadPaths()) {
+        console.log('Plugin already registered via load.paths, skipping extensions copy.');
+        return 'native-link';
+    }
     if (!fs.existsSync(PLUGIN_SOURCE)) {
         console.warn('  Warning: Plugin source not found, skipping plugin install');
         return 'skipped';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "3.4.31",
+  "version": "3.4.33",
   "description": "Trustworthy memory and security for AI agents. Recall debugging, review queue, OpenClaw session capture, and memory poisoning defence for Claude Code, Codex, OpenClaw, LangChain, and MCP agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dashboard/.next/standalone/dashboard/.next/BUILD_ID

@@ -1 +0,0 @@
-Wkh_Gp4JYc_-uQ8K2Ao5-

package/dashboard/.next/standalone/dashboard/.next/app-path-routes-manifest.json

@@ -1,5 +0,0 @@
-{
-  "/_global-error/page": "/_global-error",
-  "/_not-found/page": "/_not-found",
-  "/page": "/"
-}

package/dashboard/.next/standalone/dashboard/.next/build-manifest.json

@@ -1,19 +0,0 @@
-{
-  "pages": {
-    "/_app": []
-  },
-  "devFiles": [],
-  "polyfillFiles": [
-    "static/chunks/a6dad97d9634a72d.js"
-  ],
-  "lowPriorityFiles": [
-    "static/Wkh_Gp4JYc_-uQ8K2Ao5-/_ssgManifest.js",
-    "static/Wkh_Gp4JYc_-uQ8K2Ao5-/_buildManifest.js"
-  ],
-  "rootMainFiles": [
-    "static/chunks/6ba7a5c1a80a6791.js",
-    "static/chunks/7d08316952ccdcef.js",
-    "static/chunks/d3d8171bf50ef87e.js",
-    "static/chunks/turbopack-c2d84e7d37269ac1.js"
-  ]
-}

package/dashboard/.next/standalone/dashboard/.next/package.json

@@ -1 +0,0 @@
-{"type": "commonjs"}

package/dashboard/.next/standalone/dashboard/.next/prerender-manifest.json

@@ -1,85 +0,0 @@
-{
-  "version": 4,
-  "routes": {
-    "/_global-error": {
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/_global-error",
-      "dataRoute": "/_global-error.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    },
-    "/_not-found": {
-      "initialStatus": 404,
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/_not-found",
-      "dataRoute": "/_not-found.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    },
-    "/": {
-      "experimentalBypassFor": [
-        {
-          "type": "header",
-          "key": "next-action"
-        },
-        {
-          "type": "header",
-          "key": "content-type",
-          "value": "multipart/form-data;.*"
-        }
-      ],
-      "initialRevalidateSeconds": false,
-      "srcRoute": "/",
-      "dataRoute": "/index.rsc",
-      "allowHeader": [
-        "host",
-        "x-matched-path",
-        "x-prerender-revalidate",
-        "x-prerender-revalidate-if-generated",
-        "x-next-revalidated-tags",
-        "x-next-revalidate-tag-token"
-      ]
-    }
-  },
-  "dynamicRoutes": {},
-  "notFoundRoutes": [],
-  "preview": {
-    "previewModeId": "66564f741ed141c4115f7fbee6ba7dea",
-    "previewModeSigningKey": "6df433e624dc2c33de06b2af90e1b1950a72b2269a7482f5bab308124ebfa7ac",
-    "previewModeEncryptionKey": "6701e2f33bc54ae79a481bc87cecb47a70e2c6e78a24a4fc737d352669b3d0b3"
-  }
-}