shieldcortex 3.4.27 → 3.4.29

package/dist/api/routes/memories.js

@@ -10,6 +10,30 @@ import { detectContradictions, getContradictionsFor } from '../../memory/contrad
 import { emitConsolidation } from '../events.js';
 export function registerMemoryRoutes(app, deps) {
     const { requireNotLocked, requireIronDomeAction } = deps;
+    function deriveLocalOpenClawSessionId(memory) {
+        if (typeof memory.metadata?.sessionId === 'string' && memory.metadata.sessionId.length > 0) {
+            return memory.metadata.sessionId;
+        }
+        if (memory.source?.startsWith('agent:openclaw-plugin:')) {
+            return memory.source.slice('agent:openclaw-plugin:'.length);
+        }
+        const tagSet = new Set(memory.tags.map((tag) => tag.toLowerCase()));
+        const looksOpenClaw = memory.sourceKind === 'hook'
+            || memory.sourceKind === 'plugin'
+            || memory.source?.includes('openclaw') === true
+            || tagSet.has('session-end')
+            || tagSet.has('session-stop')
+            || tagSet.has('keyword-trigger')
+            || tagSet.has('openclaw-hook')
+            || tagSet.has('llm-output')
+            || tagSet.has('realtime-plugin')
+            || memory.project === 'openclaw';
+        if (!looksOpenClaw)
+            return null;
+        const createdAt = memory.createdAt.toISOString().slice(0, 10);
+        const projectBucket = memory.project?.trim() ? memory.project.trim() : 'unscoped';
+        return `legacy-openclaw:${projectBucket}:${createdAt}`;
+    }
     app.get('/api/capture/openclaw/sessions', requireNotLocked, (req, res) => {
         try {
             const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
@@ -52,11 +76,7 @@ export function registerMemoryRoutes(app, deps) {
                 return session;
             };
             for (const memory of openClawMemories) {
-                const sessionId = typeof memory.metadata?.sessionId === 'string'
-                    ? memory.metadata.sessionId
-                    : memory.source?.startsWith('agent:openclaw-plugin:')
-                        ? memory.source.slice('agent:openclaw-plugin:'.length)
-                        : null;
+                const sessionId = deriveLocalOpenClawSessionId(memory);
                 if (!sessionId)
                     continue;
                 const session = getSession(sessionId);

package/dist/api/routes/system.js

@@ -3,10 +3,38 @@ import { getCloudConfig, getCloudSyncControls, getDeviceId, getDeviceName, getDe
 import { getQueueStats } from '../../cloud/sync-queue.js';
 import { getDatabase } from '../../database/init.js';
 import { getRequiredTier, isFeatureEnabled } from '../../license/gate.js';
+import { getLicense } from '../../license/store.js';
+import { getTrialStatus } from '../../license/trial.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 import { getControlStatus, isKillSwitchActive, pause, resume } from '../control.js';
 import { checkForUpdates, getCurrentVersion, getRunningVersion, performUpdate, scheduleRestart, } from '../version.js';
 export function registerSystemRoutes(app, deps) {
     const { broadcast, clients, requireIronDomeAction } = deps;
+    app.get('/api/system/status', (_req, res) => {
+        try {
+            const licenseFile = join(homedir(), '.shieldcortex', 'license.json');
+            const licenseFileExists = existsSync(licenseFile);
+            const license = getLicense();
+            const trial = getTrialStatus(licenseFileExists);
+            const trialInfo = trial
+                ? {
+                    active: trial.active,
+                    daysRemaining: trial.daysRemaining,
+                    expiresAt: trial.expiresAt.slice(0, 10), // YYYY-MM-DD
+                }
+                : null;
+            res.json({
+                tier: license.valid ? license.tier : (trial?.active ? 'pro' : 'free'),
+                licenseValid: license.valid,
+                trial: trialInfo,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     app.get('/api/control/status', (_req, res) => {
         try {
             res.json(getControlStatus());

package/dist/database/init.js

@@ -266,12 +266,12 @@ function attemptDumpRecovery(dbPath) {
             return null;
         // Back up the corrupt file
         const backupPath = backupCorruptDatabase(dbPath);
-        console.log(`[database] Backed up corrupt database to: ${backupPath}`);
+        console.error(`[database] Backed up corrupt database to: ${backupPath}`);
         // Create fresh database and import the dump
         const freshDb = new Database(dbPath);
         try {
             freshDb.exec(dumpOutput);
-            console.log('[database] Successfully recovered data via dump/reimport.');
+            console.error('[database] Successfully recovered data via dump/reimport.');
             return freshDb;
         }
         catch {
@@ -330,7 +330,7 @@ function attemptFtsRecovery(database) {
         database.exec(`INSERT INTO memories_fts(memories_fts) VALUES('rebuild')`);
         const postRepairIntegrity = runIntegrityCheck(database);
         if (postRepairIntegrity === 'ok') {
-            console.log('[database] Successfully rebuilt memories_fts after integrity failure.');
+            console.error('[database] Successfully rebuilt memories_fts after integrity failure.');
             return true;
         }
         console.warn(`[database] FTS rebuild did not fully repair integrity: ${postRepairIntegrity}`);
@@ -374,7 +374,7 @@ export function initDatabase(dbPath) {
     // Store path for size monitoring
     currentDbPath = expandedPath;
     acquireStartupLock(expandedPath);
-    console.log(`[database] Startup runtime=${resolveRuntimeInfo().kind} db=${expandedPath} wal=${existsSync(expandedPath + '-wal')} shm=${existsSync(expandedPath + '-shm')}`);
+    console.error(`[database] Startup runtime=${resolveRuntimeInfo().kind} db=${expandedPath} wal=${existsSync(expandedPath + '-wal')} shm=${existsSync(expandedPath + '-shm')}`);
     const healthyBackups = listHealthyBackups(expandedPath);
     // Wrap the initial open in try/catch to handle corrupt files gracefully
     let database;
@@ -558,8 +558,49 @@ function runMigrations(database) {
         database.exec('UPDATE memories SET updated_at = COALESCE(updated_at, created_at, CURRENT_TIMESTAMP) WHERE updated_at IS NULL');
         database.exec("UPDATE memories SET status = COALESCE(status, 'active') WHERE status IS NULL OR status = ''");
         database.exec('UPDATE memories SET pinned = COALESCE(pinned, 0) WHERE pinned IS NULL');
+        database.exec(`
+      UPDATE memories
+      SET source = CASE
+        WHEN source = 'user:direct' AND tags LIKE '%session-end%' THEN 'hook:openclaw-session-end'
+        WHEN source = 'user:direct' AND tags LIKE '%session-stop%' THEN 'hook:openclaw-session-stop'
+        WHEN source = 'user:direct' AND tags LIKE '%keyword-trigger%' THEN 'hook:openclaw-keyword'
+        WHEN source IS NULL AND tags LIKE '%llm-output%' THEN 'agent:openclaw-plugin'
+        ELSE source
+      END
+      WHERE
+        (source = 'user:direct' OR source IS NULL)
+        AND (
+          tags LIKE '%session-end%'
+          OR tags LIKE '%session-stop%'
+          OR tags LIKE '%keyword-trigger%'
+          OR tags LIKE '%llm-output%'
+          OR tags LIKE '%realtime-plugin%'
+          OR tags LIKE '%openclaw-hook%'
+        )
+    `);
         database.exec("UPDATE memories SET source_kind = CASE WHEN source LIKE 'hook:%' THEN 'hook' WHEN source LIKE 'api:%' THEN 'api' WHEN source LIKE 'agent:%' THEN 'agent' WHEN source LIKE 'cli:%' THEN 'cli' ELSE COALESCE(source_kind, 'user') END WHERE source_kind IS NULL OR source_kind = ''");
         database.exec("UPDATE memories SET capture_method = CASE WHEN tags LIKE '%auto-extracted%' THEN 'auto' WHEN source_kind = 'hook' THEN 'hook' WHEN source_kind = 'api' THEN 'api' WHEN source_kind = 'agent' THEN 'plugin' WHEN source_kind = 'cli' THEN 'manual' ELSE COALESCE(capture_method, 'manual') END WHERE capture_method IS NULL OR capture_method = ''");
+        database.exec(`
+      UPDATE memories
+      SET source_kind = CASE
+        WHEN tags LIKE '%session-end%' OR tags LIKE '%session-stop%' OR tags LIKE '%keyword-trigger%' OR tags LIKE '%openclaw-hook%' THEN 'hook'
+        WHEN tags LIKE '%llm-output%' OR tags LIKE '%realtime-plugin%' THEN 'agent'
+        ELSE source_kind
+      END,
+      capture_method = CASE
+        WHEN tags LIKE '%session-end%' OR tags LIKE '%session-stop%' OR tags LIKE '%openclaw-hook%' THEN 'auto'
+        WHEN tags LIKE '%keyword-trigger%' THEN 'hook'
+        WHEN tags LIKE '%llm-output%' OR tags LIKE '%realtime-plugin%' THEN 'auto'
+        ELSE capture_method
+      END
+      WHERE
+        tags LIKE '%session-end%'
+        OR tags LIKE '%session-stop%'
+        OR tags LIKE '%keyword-trigger%'
+        OR tags LIKE '%openclaw-hook%'
+        OR tags LIKE '%llm-output%'
+        OR tags LIKE '%realtime-plugin%'
+    `);
         database.exec('UPDATE memories SET cloud_excluded = COALESCE(cloud_excluded, 0) WHERE cloud_excluded IS NULL');
         database.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_uuid ON memories(uuid)');
         database.exec('CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at DESC)');

package/dist/index.js

@@ -363,6 +363,59 @@ async function isLocalDashboardRunning() {
 async function main() {
     // Warn if npx is serving a stale cached version
     checkVersionStaleness();
+    const parsedArgs = parseArgs();
+    // ── Trial welcome / expiry warning ──────────────────────
+    // Only show for interactive CLI commands (not MCP server mode — stdout must stay clean for JSON-RPC)
+    if (process.argv[2] && parsedArgs.mode !== 'mcp') {
+        try {
+            const { existsSync } = await import('fs');
+            const { join } = await import('path');
+            const { homedir } = await import('os');
+            const { getTrialStatus } = await import('./license/trial.js');
+            const { acknowledgeTrialWelcome } = await import('./license/trial.js');
+            const { getLicense } = await import('./license/store.js');
+            const licenseFile = join(homedir(), '.shieldcortex', 'license.json');
+            const licenseFileExists = existsSync(licenseFile);
+            const activeLicense = getLicense();
+            // Only show trial messages when no paid license is active
+            if (!activeLicense.valid) {
+                const trial = getTrialStatus(licenseFileExists);
+                if (trial?.justCreated) {
+                    // First ever run — show welcome message
+                    const expiryDate = new Date(trial.expiresAt).toLocaleDateString();
+                    const bold = '\x1b[1m';
+                    const reset = '\x1b[0m';
+                    const green = '\x1b[32m';
+                    const cyan = '\x1b[36m';
+                    const yellow = '\x1b[33m';
+                    console.log(`\n${bold}🎁 Welcome to ShieldCortex!${reset}\n`);
+                    console.log(`You have a ${yellow}14-day Pro trial${reset} — all Pro features are unlocked.\n`);
+                    console.log(`  ${green}✓${reset} Custom injection patterns (up to 50)`);
+                    console.log(`  ${green}✓${reset} Custom Iron Dome policies`);
+                    console.log(`  ${green}✓${reset} Custom firewall rules`);
+                    console.log(`  ${green}✓${reset} Audit export (JSON/CSV)`);
+                    console.log(`  ${green}✓${reset} Skill scanner deep mode`);
+                    console.log(`\nYour trial expires on ${bold}${expiryDate}${reset}. Upgrade anytime at:`);
+                    console.log(`  ${cyan}https://shieldcortex.ai/pricing${reset}`);
+                    console.log(`\nRun: shieldcortex license status\n`);
+                    acknowledgeTrialWelcome();
+                }
+                else if (trial?.active && trial.daysRemaining <= 3) {
+                    // Trial expiring soon — show warning
+                    const yellow = '\x1b[33m';
+                    const cyan = '\x1b[36m';
+                    const reset = '\x1b[0m';
+                    const days = trial.daysRemaining;
+                    console.error(`${yellow}⚠️  Pro trial expires in ${days} day${days !== 1 ? 's' : ''}. Upgrade to keep Pro features:${reset}`);
+                    console.error(`    shieldcortex license activate <key>`);
+                    console.error(`    ${cyan}https://shieldcortex.ai/pricing${reset}\n`);
+                }
+            }
+        }
+        catch {
+            // Best effort — never let trial messaging crash the CLI
+        }
+    }
     // Handle --help / -h / help / unknown args
     if (process.argv[2] === '--help' || process.argv[2] === '-h' || process.argv[2] === 'help') {
         const bold = '\x1b[1m';
@@ -689,7 +742,7 @@ ${bold}DOCS${reset}
         console.error(`Run 'shieldcortex --help' for a list of commands.`);
         process.exit(1);
     }
-    const { dbPath, mode } = parseArgs();
+    const { dbPath, mode } = parsedArgs;
     let dashboardProcess = null;
     if (mode === 'api') {
         // API mode only - for dashboard visualization

package/dist/license/cli.js

@@ -5,9 +5,15 @@
  * shieldcortex license status
  * shieldcortex license deactivate
  */
-import { activateLicense, deactivateLicense, getLicense, getLicenseFile } from './store.js';
+import { activateLicense, deactivateLicense, getLicense, getLicenseFile, getTrialStatus } from './store.js';
 import { listFeatures } from './gate.js';
 import { validateOnceNow } from './validate.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+function getLicenseFilePath() {
+    return join(process.env.SHIELDCORTEX_CONFIG_DIR || join(homedir(), '.shieldcortex'), 'license.json');
+}
 const bold = '\x1b[1m';
 const reset = '\x1b[0m';
 const green = '\x1b[32m';
@@ -72,31 +78,53 @@ async function handleActivate(key) {
 function handleStatus() {
     const info = getLicense();
     const file = getLicenseFile();
+    const licenseFileExists = existsSync(getLicenseFilePath());
+    const trial = getTrialStatus(licenseFileExists);
     console.log(`\n${bold}ShieldCortex Licence${reset}`);
     console.log('═'.repeat(40));
-    console.log(`  Tier:       ${tierBadge(info.tier)}`);
-    if (info.tier === 'free') {
-        console.log(`\n  No licence activated.`);
-        console.log(`  Upgrade at ${cyan}https://shieldcortex.ai/pricing${reset}`);
-        console.log(`  Activate:  shieldcortex license activate <key>\n`);
-        return;
-    }
-    console.log(`  Email:      ${info.email}`);
-    if (info.expiresAt) {
-        const daysStr = info.daysUntilExpiry !== null && info.daysUntilExpiry > 0
-            ? `(${info.daysUntilExpiry} days remaining)`
-            : info.daysUntilExpiry !== null && info.daysUntilExpiry <= 0
-                ? `${red}(expired)${reset}`
-                : '';
-        console.log(`  Expires:    ${info.expiresAt.toLocaleDateString()} ${daysStr}`);
+    if (info.valid) {
+        // Paid license active — show full license info, no trial messaging
+        console.log(`  Tier:       ${tierBadge(info.tier)}`);
+        console.log(`  Email:      ${info.email}`);
+        if (info.expiresAt) {
+            const daysStr = info.daysUntilExpiry !== null && info.daysUntilExpiry > 0
+                ? `(${info.daysUntilExpiry} days remaining)`
+                : info.daysUntilExpiry !== null && info.daysUntilExpiry <= 0
+                    ? `${red}(expired)${reset}`
+                    : '';
+            console.log(`  Expires:    ${info.expiresAt.toLocaleDateString()} ${daysStr}`);
+        }
+        if (file?.lastValidatedAt) {
+            console.log(`  Validated:  ${new Date(file.lastValidatedAt).toLocaleString()}`);
+        }
+        if (file?.validationStatus) {
+            const statusColor = file.validationStatus === 'valid' ? green :
+                file.validationStatus === 'revoked' ? red : yellow;
+            console.log(`  Status:     ${statusColor}${file.validationStatus}${reset}`);
+        }
     }
-    if (file?.lastValidatedAt) {
-        console.log(`  Validated:  ${new Date(file.lastValidatedAt).toLocaleString()}`);
+    else if (trial?.active) {
+        // Trial active — no paid license
+        const expiryDate = new Date(trial.expiresAt).toLocaleDateString();
+        console.log(`  Tier:       ${tierBadge('pro')} ${dim}(trial)${reset}`);
+        console.log(`  🎁 Pro Trial: ${yellow}${trial.daysRemaining} day${trial.daysRemaining !== 1 ? 's' : ''} remaining${reset} (expires ${expiryDate})`);
+        console.log(`\n  Upgrade to keep Pro features after the trial:`);
+        console.log(`  ${cyan}https://shieldcortex.ai/pricing${reset}`);
+        console.log(`  shieldcortex license activate <key>`);
     }
-    if (file?.validationStatus) {
-        const statusColor = file.validationStatus === 'valid' ? green :
-            file.validationStatus === 'revoked' ? red : yellow;
-        console.log(`  Status:     ${statusColor}${file.validationStatus}${reset}`);
+    else {
+        // No license and no active trial
+        console.log(`  Tier:       ${tierBadge('free')}`);
+        if (trial && !trial.active) {
+            // Trial existed but expired
+            console.log(`\n  ${yellow}Pro trial expired.${reset} Upgrade at ${cyan}https://shieldcortex.ai/pricing${reset}`);
+        }
+        else {
+            console.log(`\n  No licence activated.`);
+            console.log(`  Upgrade at ${cyan}https://shieldcortex.ai/pricing${reset}`);
+        }
+        console.log(`  Activate:  shieldcortex license activate <key>\n`);
+        return;
     }
     console.log(`\n${bold}Features:${reset}`);
     const features = listFeatures();

package/dist/license/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * License module — re-exports for public API and internal use.
  */
-export { getLicense, getLicenseTier, getLicenseFile, clearLicenseCache } from './store.js';
+export { getLicense, getLicenseTier, getLicenseFile, clearLicenseCache, getTrialStatus, isTrialActive, getTrialDaysRemaining } from './store.js';
 export { verifyLicenseKey, parseLicensePayload } from './verify.js';
 export { isFeatureEnabled, requireFeature, getRequiredTier, listFeatures, FeatureGatedError, } from './gate.js';
 export { scheduleOnlineValidation } from './validate.js';

package/dist/license/index.js

@@ -2,7 +2,7 @@
  * License module — re-exports for public API and internal use.
  */
 // ── Public API (exported from lib.ts) ────────────────────
-export { getLicense, getLicenseTier, getLicenseFile, clearLicenseCache } from './store.js';
+export { getLicense, getLicenseTier, getLicenseFile, clearLicenseCache, getTrialStatus, isTrialActive, getTrialDaysRemaining } from './store.js';
 export { verifyLicenseKey, parseLicensePayload } from './verify.js';
 export { isFeatureEnabled, requireFeature, getRequiredTier, listFeatures, FeatureGatedError, } from './gate.js';
 export { scheduleOnlineValidation } from './validate.js';

package/dist/license/store.d.ts

@@ -10,6 +10,8 @@
  * License is cached in memory after first read.
  */
 import type { LicenseTier, LicenseInfo, LicenseFile } from './keys.js';
+import { getTrialStatus, isTrialActive, getTrialDaysRemaining } from './trial.js';
+export { isTrialActive, getTrialDaysRemaining, getTrialStatus };
 /** Clear the in-memory cache (useful for testing or after activation). */
 export declare function clearLicenseCache(): void;
 /**
@@ -19,7 +21,8 @@ export declare function clearLicenseCache(): void;
 export declare function getLicense(): LicenseInfo;
 /**
  * Quick accessor for the current licence tier.
- * Returns 'free' if no valid licence exists.
+ * Returns 'pro' during an active trial (if no paid license is active).
+ * Returns 'free' otherwise.
  */
 export declare function getLicenseTier(): LicenseTier;
 /**

package/dist/license/store.js

@@ -13,13 +13,20 @@ import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from '
 import { join } from 'path';
 import { homedir } from 'os';
 import { verifyLicenseKey } from './verify.js';
-const CONFIG_DIR = join(homedir(), '.shieldcortex');
-const LICENSE_FILE = join(CONFIG_DIR, 'license.json');
+import { getTrialStatus, isTrialActive, getTrialDaysRemaining, clearTrialCache, } from './trial.js';
+export { isTrialActive, getTrialDaysRemaining, getTrialStatus };
+function getConfigDir() {
+    return process.env.SHIELDCORTEX_CONFIG_DIR || join(homedir(), '.shieldcortex');
+}
+function getLicenseFilePath() {
+    return join(getConfigDir(), 'license.json');
+}
 // ── Cache ────────────────────────────────────────────────
 let cachedLicense = null;
 /** Clear the in-memory cache (useful for testing or after activation). */
 export function clearLicenseCache() {
     cachedLicense = null;
+    clearTrialCache();
 }
 // ── Read ─────────────────────────────────────────────────
 /**
@@ -39,11 +46,12 @@ export function getLicense() {
         subscriptionId: null,
     };
     try {
-        if (!existsSync(LICENSE_FILE)) {
+        const licenseFile = getLicenseFilePath();
+        if (!existsSync(licenseFile)) {
             cachedLicense = FREE;
             return FREE;
         }
-        const raw = JSON.parse(readFileSync(LICENSE_FILE, 'utf-8'));
+        const raw = JSON.parse(readFileSync(licenseFile, 'utf-8'));
         if (!raw.key) {
             cachedLicense = FREE;
             return FREE;
@@ -68,10 +76,19 @@ export function getLicense() {
 }
 /**
  * Quick accessor for the current licence tier.
- * Returns 'free' if no valid licence exists.
+ * Returns 'pro' during an active trial (if no paid license is active).
+ * Returns 'free' otherwise.
  */
 export function getLicenseTier() {
-    return getLicense().tier;
+    const license = getLicense();
+    // Paid license takes priority — trial is irrelevant
+    if (license.valid)
+        return license.tier;
+    // No paid license: check if trial is active
+    const licenseFileExists = existsSync(getLicenseFilePath());
+    if (isTrialActive(licenseFileExists))
+        return 'pro';
+    return license.tier; // 'free'
 }
 /**
  * Read the raw license file data (for status display).
@@ -79,9 +96,10 @@ export function getLicenseTier() {
  */
 export function getLicenseFile() {
     try {
-        if (!existsSync(LICENSE_FILE))
+        const licenseFile = getLicenseFilePath();
+        if (!existsSync(licenseFile))
             return null;
-        return JSON.parse(readFileSync(LICENSE_FILE, 'utf-8'));
+        return JSON.parse(readFileSync(licenseFile, 'utf-8'));
     }
     catch {
         return null;
@@ -104,8 +122,10 @@ export function activateLicense(key) {
         lastValidatedAt: null,
         validationStatus: 'unvalidated',
     };
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(LICENSE_FILE, JSON.stringify(file, null, 2) + '\n', { mode: 0o600 });
+    const configDir = getConfigDir();
+    const licenseFile = getLicenseFilePath();
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(licenseFile, JSON.stringify(file, null, 2) + '\n', { mode: 0o600 });
     // Invalidate cache
     cachedLicense = info;
     return info;
@@ -115,14 +135,16 @@ export function activateLicense(key) {
  */
 export function deactivateLicense() {
     try {
-        if (existsSync(LICENSE_FILE)) {
-            unlinkSync(LICENSE_FILE);
+        const licenseFile = getLicenseFilePath();
+        if (existsSync(licenseFile)) {
+            unlinkSync(licenseFile);
         }
     }
     catch {
         // Best effort
     }
     cachedLicense = null;
+    clearTrialCache();
 }
 /**
  * Update the validation status and timestamp in the license file.
@@ -130,12 +152,13 @@ export function deactivateLicense() {
  */
 export function updateValidationStatus(status) {
     try {
-        if (!existsSync(LICENSE_FILE))
+        const licenseFile = getLicenseFilePath();
+        if (!existsSync(licenseFile))
             return;
-        const raw = JSON.parse(readFileSync(LICENSE_FILE, 'utf-8'));
+        const raw = JSON.parse(readFileSync(licenseFile, 'utf-8'));
         raw.validationStatus = status;
         raw.lastValidatedAt = new Date().toISOString();
-        writeFileSync(LICENSE_FILE, JSON.stringify(raw, null, 2) + '\n', { mode: 0o600 });
+        writeFileSync(licenseFile, JSON.stringify(raw, null, 2) + '\n', { mode: 0o600 });
         // If revoked or expired, invalidate cache so next getLicense() re-verifies
         if (status === 'revoked' || status === 'expired') {
             cachedLicense = null;

package/dist/license/trial.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 14-day Pro trial — auto-granted on first install, no signup required.
+ *
+ * Trial state is stored in ~/.shieldcortex/trial.json.
+ * It is NEVER reset on reinstall (file persists across npm updates).
+ * An active paid license always takes priority over the trial.
+ */
+export interface TrialFile {
+    startedAt: string;
+    durationDays: number;
+    acknowledged: boolean;
+}
+export interface TrialStatus {
+    active: boolean;
+    daysRemaining: number;
+    startedAt: string;
+    expiresAt: string;
+    justCreated: boolean;
+}
+/** Clear the in-memory trial cache (useful for testing). */
+export declare function clearTrialCache(): void;
+/**
+ * Read (and lazily create) the trial state.
+ *
+ * - If `trial.json` already exists: read and return its status.
+ * - If `trial.json` does NOT exist AND `license.json` does NOT exist: create it now (first install).
+ * - If `trial.json` does NOT exist AND `license.json` DOES exist: don't create — user already has a paid license.
+ * - Returns null if no trial applies.
+ *
+ * Pass `licenseFileExists` to avoid a second disk read inside store.ts.
+ */
+export declare function getTrialStatus(licenseFileExists: boolean): TrialStatus | null;
+/**
+ * Whether a trial is currently active (Pro features unlocked by trial).
+ * Only returns true when no paid license is in effect — callers should
+ * check the license first and only fall back to this.
+ */
+export declare function isTrialActive(licenseFileExists: boolean): boolean;
+/**
+ * Days remaining in the trial (0 if expired or no trial).
+ */
+export declare function getTrialDaysRemaining(licenseFileExists: boolean): number;
+/**
+ * Mark the welcome message as acknowledged (suppress on subsequent runs).
+ */
+export declare function acknowledgeTrialWelcome(): void;
+/** Exposed for tests — returns the full trial file path */
+export declare function getTrialFilePath(): string;