shieldcortex 3.4.28 → 3.4.29

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;

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;

package/dist/license/trial.js

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const TRIAL_DURATION_DAYS = 14;
+// ── Cache ────────────────────────────────────────────────
+let cachedTrial = undefined; // undefined = not loaded yet
+function getConfigDir() {
+    return process.env.SHIELDCORTEX_CONFIG_DIR || join(homedir(), '.shieldcortex');
+}
+function getTrialFile() {
+    return join(getConfigDir(), 'trial.json');
+}
+/** Clear the in-memory trial cache (useful for testing). */
+export function clearTrialCache() {
+    cachedTrial = undefined;
+}
+// ── Helpers ──────────────────────────────────────────────
+function computeStatus(data, justCreated = false) {
+    const startMs = new Date(data.startedAt).getTime();
+    const expiryMs = startMs + data.durationDays * 24 * 60 * 60 * 1000;
+    const nowMs = Date.now();
+    const msRemaining = expiryMs - nowMs;
+    const daysRemaining = Math.max(0, Math.ceil(msRemaining / (24 * 60 * 60 * 1000)));
+    return {
+        active: nowMs < expiryMs,
+        daysRemaining,
+        startedAt: data.startedAt,
+        expiresAt: new Date(expiryMs).toISOString(),
+        justCreated,
+    };
+}
+// ── Public API ────────────────────────────────────────────
+/**
+ * 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 function getTrialStatus(licenseFileExists) {
+    // Skip trial if env var set (useful for tests and CI)
+    if (process.env.SHIELDCORTEX_SKIP_TRIAL === '1')
+        return null;
+    if (cachedTrial !== undefined)
+        return cachedTrial;
+    try {
+        const trialFile = getTrialFile();
+        if (existsSync(trialFile)) {
+            const data = JSON.parse(readFileSync(trialFile, 'utf-8'));
+            // Return full status whether active or expired — callers use status.active to distinguish.
+            // Only return null when no trial file exists at all.
+            const status = computeStatus(data, false);
+            cachedTrial = status;
+            return cachedTrial;
+        }
+        // No trial file — only create on first install (no license either)
+        if (licenseFileExists) {
+            cachedTrial = null;
+            return null;
+        }
+        // First run — create the trial file
+        mkdirSync(getConfigDir(), { recursive: true });
+        const now = new Date().toISOString();
+        const trialData = {
+            startedAt: now,
+            durationDays: TRIAL_DURATION_DAYS,
+            acknowledged: false,
+        };
+        writeFileSync(trialFile, JSON.stringify(trialData, null, 2) + '\n', { mode: 0o600 });
+        const status = computeStatus(trialData, true);
+        cachedTrial = status; // always active on creation
+        return cachedTrial;
+    }
+    catch {
+        cachedTrial = null;
+        return 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 function isTrialActive(licenseFileExists) {
+    return getTrialStatus(licenseFileExists)?.active === true;
+}
+/**
+ * Days remaining in the trial (0 if expired or no trial).
+ */
+export function getTrialDaysRemaining(licenseFileExists) {
+    return getTrialStatus(licenseFileExists)?.daysRemaining ?? 0;
+}
+/**
+ * Mark the welcome message as acknowledged (suppress on subsequent runs).
+ */
+export function acknowledgeTrialWelcome() {
+    try {
+        const trialFile = getTrialFile();
+        if (!existsSync(trialFile))
+            return;
+        const data = JSON.parse(readFileSync(trialFile, 'utf-8'));
+        if (!data.acknowledged) {
+            data.acknowledged = true;
+            writeFileSync(trialFile, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+        }
+        // Update cache
+        if (cachedTrial) {
+            cachedTrial = { ...cachedTrial, justCreated: false };
+        }
+    }
+    catch {
+        // Best effort
+    }
+}
+/** Exposed for tests — returns the full trial file path */
+export function getTrialFilePath() {
+    return getTrialFile();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "3.4.28",
+  "version": "3.4.29",
   "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",