vigthoria-cli 1.10.47 → 1.10.49

package/dist/utils/logger.js

@@ -1,15 +1,8 @@
-"use strict";
 /**
  * Logger utility for Vigthoria CLI
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.CH = void 0;
-exports.createSpinner = createSpinner;
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
+import chalk from 'chalk';
+import ora from 'ora';
 /**
  * Platform-aware character map.
  *
@@ -21,7 +14,7 @@ const ora_1 = __importDefault(require("ora"));
  * monospace rendering can break.
  */
 const isWin = process.platform === 'win32';
-exports.CH = {
+export const CH = {
     info: 'ℹ',
     warn: '⚠',
     error: '✗',
@@ -64,67 +57,67 @@ exports.CH = {
  * Prefer: spinner.stop() then Logger.error(msg) — which writes to
  * stdout — instead of spinner.fail(msg).
  */
-function createSpinner(textOrOpts) {
+export function createSpinner(textOrOpts) {
     const opts = typeof textOrOpts === 'string' ? { text: textOrOpts } : textOrOpts;
     // Suppress spinner animation when stderr is not a TTY (piped output,
     // CI, non-interactive terminals).  The spinner object still works — its
     // .start()/.stop()/.succeed() methods are no-ops — so callers don't
     // need conditional logic.
     const isSilent = !process.stderr.isTTY;
-    return (0, ora_1.default)({ ...opts, stream: process.stderr, isSilent });
+    return ora({ ...opts, stream: process.stderr, isSilent });
 }
-class Logger {
+export class Logger {
     verbose = false;
     setVerbose(verbose) {
         this.verbose = verbose;
     }
     debug(...args) {
         if (this.verbose) {
-            console.log(chalk_1.default.gray('[DEBUG]'), ...args);
+            console.log(chalk.gray('[DEBUG]'), ...args);
         }
     }
     info(...args) {
-        console.log(chalk_1.default.blue(exports.CH.info), ...args);
+        console.log(chalk.blue(CH.info), ...args);
     }
     warn(...args) {
-        console.log(chalk_1.default.yellow(exports.CH.warn), ...args);
+        console.log(chalk.yellow(CH.warn), ...args);
     }
     error(...args) {
         // Write error messages to stdout (not stderr) to avoid triggering
         // PowerShell NativeCommandError styling.  The red ✗ prefix already
         // signals an error visually; stderr redirection is unnecessary.
-        console.log(chalk_1.default.red(exports.CH.error), ...args);
+        console.log(chalk.red(CH.error), ...args);
     }
     success(...args) {
-        console.log(chalk_1.default.green(exports.CH.success), ...args);
+        console.log(chalk.green(CH.success), ...args);
     }
     // AI response formatting
     ai(message) {
-        console.log(chalk_1.default.cyan(exports.CH.ai), message);
+        console.log(chalk.cyan(CH.ai), message);
     }
     // User input formatting
     user(message) {
-        console.log(chalk_1.default.white(exports.CH.user), message);
+        console.log(chalk.white(CH.user), message);
     }
     // Code block
     code(code, language) {
-        console.log(chalk_1.default.gray(exports.CH.hLine.repeat(60)));
-        console.log(chalk_1.default.yellow(code));
-        console.log(chalk_1.default.gray(exports.CH.hLine.repeat(60)));
+        console.log(chalk.gray(CH.hLine.repeat(60)));
+        console.log(chalk.yellow(code));
+        console.log(chalk.gray(CH.hLine.repeat(60)));
     }
     // Diff output - enhanced with syntax-highlighted unified diff
     diff(added, removed) {
-        removed.forEach(line => console.log(chalk_1.default.red(`- ${line}`)));
-        added.forEach(line => console.log(chalk_1.default.green(`+ ${line}`)));
+        removed.forEach(line => console.log(chalk.red(`- ${line}`)));
+        added.forEach(line => console.log(chalk.green(`+ ${line}`)));
     }
     // Unified diff display with file context
     unifiedDiff(filePath, oldText, newText) {
         const oldLines = oldText.split('\n');
         const newLines = newText.split('\n');
         const fileName = filePath.split('/').pop() || filePath;
-        console.log(chalk_1.default.bold.white(`\n  ${exports.CH.hLine.repeat(3)} ${fileName} ${exports.CH.hLine.repeat(Math.max(1, 50 - fileName.length))}`));
-        console.log(chalk_1.default.gray(`  --- a/${filePath}`));
-        console.log(chalk_1.default.gray(`  +++ b/${filePath}`));
+        console.log(chalk.bold.white(`\n  ${CH.hLine.repeat(3)} ${fileName} ${CH.hLine.repeat(Math.max(1, 50 - fileName.length))}`));
+        console.log(chalk.gray(`  --- a/${filePath}`));
+        console.log(chalk.gray(`  +++ b/${filePath}`));
         // Find diff ranges with context
         const contextLines = 3;
         let i = 0;
@@ -140,18 +133,18 @@ class Logger {
             const startNew = Math.max(0, j - contextLines);
             // Context before
             for (let c = startOld; c < i; c++) {
-                console.log(chalk_1.default.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
+                console.log(chalk.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
             }
             // Removed lines
             while (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
-                console.log(chalk_1.default.red(`  ${String(i + 1).padStart(4)} │-${oldLines[i]}`));
+                console.log(chalk.red(`  ${String(i + 1).padStart(4)} │-${oldLines[i]}`));
                 i++;
                 if (j < newLines.length && (i >= oldLines.length || oldLines[i] === newLines[j]))
                     break;
             }
             // Added lines
             while (j < newLines.length && (i >= oldLines.length || oldLines[i] !== newLines[j])) {
-                console.log(chalk_1.default.green(`  ${String(j + 1).padStart(4)} │+${newLines[j]}`));
+                console.log(chalk.green(`  ${String(j + 1).padStart(4)} │+${newLines[j]}`));
                 j++;
                 if (i < oldLines.length && oldLines[i] === newLines[j])
                     break;
@@ -159,23 +152,23 @@ class Logger {
             // Context after
             const endCtx = Math.min(oldLines.length, i + contextLines);
             for (let c = i; c < endCtx && c < oldLines.length && j < newLines.length && oldLines[c] === newLines[j]; c++) {
-                console.log(chalk_1.default.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
+                console.log(chalk.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
                 i = c + 1;
                 j++;
             }
-            console.log(chalk_1.default.gray(`  ${exports.CH.hLine.repeat(55)}`));
+            console.log(chalk.gray(`  ${CH.hLine.repeat(55)}`));
         }
         console.log();
     }
     // Section header
     section(title) {
         console.log();
-        console.log(chalk_1.default.bold.cyan(`${exports.CH.hDouble.repeat(3)} ${title} ${exports.CH.hDouble.repeat(3)}`));
+        console.log(chalk.bold.cyan(`${CH.hDouble.repeat(3)} ${title} ${CH.hDouble.repeat(3)}`));
         console.log();
     }
     // Progress
     progress(message) {
-        process.stdout.write(chalk_1.default.gray(`${message}\r`));
+        process.stdout.write(chalk.gray(`${message}\r`));
     }
     // Clear line
     clearLine() {
@@ -188,18 +181,18 @@ class Logger {
         const stripAnsi = (str) => str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
         const maxLen = Math.max(...lines.map(l => stripAnsi(l).length), title?.length || 0);
         const width = maxLen + 4;
-        console.log(chalk_1.default.cyan(exports.CH.tl + exports.CH.hLine.repeat(width - 2) + exports.CH.tr));
+        console.log(chalk.cyan(CH.tl + CH.hLine.repeat(width - 2) + CH.tr));
         if (title) {
-            console.log(chalk_1.default.cyan(exports.CH.vLine + ' ') + chalk_1.default.bold.white(title.padEnd(width - 4)) + chalk_1.default.cyan(' ' + exports.CH.vLine));
-            console.log(chalk_1.default.cyan(exports.CH.teeR + exports.CH.hLine.repeat(width - 2) + exports.CH.teeL));
+            console.log(chalk.cyan(CH.vLine + ' ') + chalk.bold.white(title.padEnd(width - 4)) + chalk.cyan(' ' + CH.vLine));
+            console.log(chalk.cyan(CH.teeR + CH.hLine.repeat(width - 2) + CH.teeL));
         }
         lines.forEach(line => {
             // Calculate visible length and pad accordingly
             const visibleLen = stripAnsi(line).length;
             const padding = ' '.repeat(Math.max(0, width - 4 - visibleLen));
-            console.log(chalk_1.default.cyan(exports.CH.vLine + ' ') + line + padding + chalk_1.default.cyan(' ' + exports.CH.vLine));
+            console.log(chalk.cyan(CH.vLine + ' ') + line + padding + chalk.cyan(' ' + CH.vLine));
         });
-        console.log(chalk_1.default.cyan(exports.CH.bl + exports.CH.hLine.repeat(width - 2) + exports.CH.br));
+        console.log(chalk.cyan(CH.bl + CH.hLine.repeat(width - 2) + CH.br));
     }
     // Table output
     table(headers, rows) {
@@ -208,19 +201,18 @@ class Logger {
             return Math.max(h.length, maxData);
         });
         // Header
-        console.log(chalk_1.default.gray(exports.CH.vLine + ' ') +
-            headers.map((h, i) => chalk_1.default.bold(h.padEnd(colWidths[i]))).join(chalk_1.default.gray(' ' + exports.CH.vLine + ' ')) +
-            chalk_1.default.gray(' ' + exports.CH.vLine));
+        console.log(chalk.gray(CH.vLine + ' ') +
+            headers.map((h, i) => chalk.bold(h.padEnd(colWidths[i]))).join(chalk.gray(' ' + CH.vLine + ' ')) +
+            chalk.gray(' ' + CH.vLine));
         // Separator
-        console.log(chalk_1.default.gray(exports.CH.teeR + exports.CH.hLine) +
-            colWidths.map(w => exports.CH.hLine.repeat(w)).join(chalk_1.default.gray(exports.CH.hLine + exports.CH.cross + exports.CH.hLine)) +
-            chalk_1.default.gray(exports.CH.hLine + exports.CH.teeL));
+        console.log(chalk.gray(CH.teeR + CH.hLine) +
+            colWidths.map(w => CH.hLine.repeat(w)).join(chalk.gray(CH.hLine + CH.cross + CH.hLine)) +
+            chalk.gray(CH.hLine + CH.teeL));
         // Rows
         rows.forEach(row => {
-            console.log(chalk_1.default.gray(exports.CH.vLine + ' ') +
-                row.map((cell, i) => (cell || '').padEnd(colWidths[i])).join(chalk_1.default.gray(' ' + exports.CH.vLine + ' ')) +
-                chalk_1.default.gray(' ' + exports.CH.vLine));
+            console.log(chalk.gray(CH.vLine + ' ') +
+                row.map((cell, i) => (cell || '').padEnd(colWidths[i])).join(chalk.gray(' ' + CH.vLine + ' ')) +
+                chalk.gray(' ' + CH.vLine));
         });
     }
 }
-exports.Logger = Logger;

package/dist/utils/persona.js

@@ -1,8 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePersonaMode = normalizePersonaMode;
-exports.isToneDownPrompt = isToneDownPrompt;
-exports.buildPersonaOverlay = buildPersonaOverlay;
 const WIENER_GRANT_PROMPT = [
     'Optional persona overlay: Wiener Grantler mode.',
     'You remain Vigthoria: technically precise, helpful, safe, and comprehensive.',
@@ -18,7 +13,7 @@ const TONE_DOWN_PROMPT = [
     'Tone-down rule active: this request appears safety-sensitive, destructive, auth/billing-related, security-related, legal/medical/financial, or production-critical.',
     'Use only a very light flavor line if appropriate, then prioritize plain clarity, caution, and exact steps.',
 ].join('\n');
-function normalizePersonaMode(value) {
+export function normalizePersonaMode(value) {
     const normalized = String(value || '').trim().toLowerCase().replace(/_/g, '-');
     if (!normalized || normalized === 'default' || normalized === 'off' || normalized === 'none')
         return 'default';
@@ -26,10 +21,10 @@ function normalizePersonaMode(value) {
         return 'wiener_grant';
     return null;
 }
-function isToneDownPrompt(prompt) {
+export function isToneDownPrompt(prompt) {
     return /\b(delete|drop|destroy|wipe|rm\s+-rf|format|credential|secret|token|auth|login|billing|payment|wallet|security|vulnerability|exploit|incident|production|prod|deploy|legal|medical|financial|bank|tax)\b/i.test(prompt);
 }
-function buildPersonaOverlay(mode, prompt = '') {
+export function buildPersonaOverlay(mode, prompt = '') {
     if (mode !== 'wiener_grant')
         return '';
     const parts = [WIENER_GRANT_PROMPT];

package/dist/utils/post-write-validator.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Vigthoria CLI — Post-Write Validator / Self-Healing Layer
  *
@@ -9,18 +8,12 @@
  *
  * Used by runSelfHealingCycle in api.ts to send targeted correction prompts.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPostWriteValidation = runPostWriteValidation;
-exports.formatValidationErrors = formatValidationErrors;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 function commandExists(cmd, args = ['--version']) {
     try {
-        (0, node_child_process_1.execFileSync)(cmd, args, { stdio: 'pipe', timeout: 4000, windowsHide: true });
+        execFileSync(cmd, args, { stdio: 'pipe', timeout: 4000, windowsHide: true });
         return true;
     }
     catch {
@@ -28,34 +21,34 @@ function commandExists(cmd, args = ['--version']) {
     }
 }
 function hasTsConfig(dir) {
-    return node_fs_1.default.existsSync(node_path_1.default.join(dir, 'tsconfig.json'));
+    return fs.existsSync(path.join(dir, 'tsconfig.json'));
 }
 /**
  * Resolve the best available tsc binary for the project.
  * Prefers local node_modules/.bin/tsc over npx to avoid network fetches.
  */
 function resolveTscBin(workspacePath) {
-    const localTsc = node_path_1.default.join(workspacePath, 'node_modules', '.bin', 'tsc');
-    if (node_fs_1.default.existsSync(localTsc))
+    const localTsc = path.join(workspacePath, 'node_modules', '.bin', 'tsc');
+    if (fs.existsSync(localTsc))
         return { cmd: localTsc, args: ["--noEmit", "--skipLibCheck"] };
     try {
-        (0, node_child_process_1.execFileSync)("npx", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
-        return { cmd: "npx", args: ["tsc", "--noEmit", "--skipLibCheck"] };
-    }
-    catch { /* npx not available */ }
-    try {
-        (0, node_child_process_1.execFileSync)("tsc", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        execFileSync("tsc", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
         return { cmd: "tsc", args: ["--noEmit", "--skipLibCheck"] };
     }
     catch { /* tsc not available */ }
+    try {
+        execFileSync("npx", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        return { cmd: "npx", args: ["--yes", "tsc", "--noEmit", "--skipLibCheck"] };
+    }
+    catch { /* npx not available */ }
     return null;
 }
 function hasRealTestScript(dir) {
     try {
-        const pkgPath = node_path_1.default.join(dir, 'package.json');
-        if (!node_fs_1.default.existsSync(pkgPath))
+        const pkgPath = path.join(dir, 'package.json');
+        if (!fs.existsSync(pkgPath))
             return false;
-        const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
         const script = pkg.scripts?.test ?? '';
         return typeof script === 'string' && script.length > 0
             && !script.startsWith('echo "Error: no test specified"');
@@ -68,8 +61,8 @@ function hasRealTestScript(dir) {
  * Run post-write validation in the project directory.
  * Each check is time-bounded to avoid blocking the CLI.
  */
-async function runPostWriteValidation(workspacePath) {
-    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath))
+export async function runPostWriteValidation(workspacePath) {
+    if (!workspacePath || !fs.existsSync(workspacePath))
         return [];
     const results = [];
     const opts = { cwd: workspacePath, stdio: 'pipe', windowsHide: true };
@@ -77,7 +70,7 @@ async function runPostWriteValidation(workspacePath) {
     const tscBin = hasTsConfig(workspacePath) ? resolveTscBin(workspacePath) : null;
     if (tscBin) {
         try {
-            (0, node_child_process_1.execFileSync)(tscBin.cmd, tscBin.args, { ...opts, timeout: 45_000 });
+            execFileSync(tscBin.cmd, tscBin.args, { ...opts, timeout: 45_000 });
             results.push({ ran: true, tool: 'tsc', passed: true, output: '' });
         }
         catch (err) {
@@ -88,7 +81,7 @@ async function runPostWriteValidation(workspacePath) {
     // 2. npm test
     if (hasRealTestScript(workspacePath) && commandExists('npm')) {
         try {
-            (0, node_child_process_1.execFileSync)('npm', ['test', '--', '--passWithNoTests'], { ...opts, timeout: 90_000 });
+            execFileSync('npm', ['test', '--', '--passWithNoTests'], { ...opts, timeout: 90_000 });
             results.push({ ran: true, tool: 'npm test', passed: true, output: '' });
         }
         catch (err) {
@@ -97,13 +90,13 @@ async function runPostWriteValidation(workspacePath) {
         }
     }
     // 3. Python syntax check
-    const hasPy = node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'requirements.txt'))
-        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'setup.py'))
-        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'pyproject.toml'));
+    const hasPy = fs.existsSync(path.join(workspacePath, 'requirements.txt'))
+        || fs.existsSync(path.join(workspacePath, 'setup.py'))
+        || fs.existsSync(path.join(workspacePath, 'pyproject.toml'));
     if (hasPy && commandExists('python3', ['-c', 'import ast'])) {
         const pyFiles = [];
         try {
-            const entries = node_fs_1.default.readdirSync(workspacePath, { withFileTypes: true });
+            const entries = fs.readdirSync(workspacePath, { withFileTypes: true });
             for (const e of entries) {
                 if (e.isFile() && e.name.endsWith('.py'))
                     pyFiles.push(e.name);
@@ -114,7 +107,7 @@ async function runPostWriteValidation(workspacePath) {
         let pyOut = '';
         for (const pyFile of pyFiles.slice(0, 20)) {
             try {
-                (0, node_child_process_1.execFileSync)('python3', ['-m', 'py_compile', pyFile], { ...opts, timeout: 10_000 });
+                execFileSync('python3', ['-m', 'py_compile', pyFile], { ...opts, timeout: 10_000 });
             }
             catch (err) {
                 pyPassed = false;
@@ -130,7 +123,7 @@ async function runPostWriteValidation(workspacePath) {
 /**
  * Build a clear error summary string from failed validation results.
  */
-function formatValidationErrors(results) {
+export function formatValidationErrors(results) {
     return results
         .filter((r) => r.ran && !r.passed)
         .map((r) => `[${r.tool}]\n${r.output.trim()}`)

package/dist/utils/project-memory.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Vigthoria Project Memory Service
  *
@@ -6,14 +5,9 @@
  * compact facts that can be retrieved for follow-up prompts without replaying
  * full chat history or noisy tool traces.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectMemoryService = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_crypto_1 = require("node:crypto");
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
 const MAX_ITEMS = 240;
 const MAX_TEXT_LENGTH = 320;
 const MAX_CONTEXT_ITEMS = 14;
@@ -35,7 +29,7 @@ function clampText(value, max = MAX_TEXT_LENGTH) {
     return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
 }
 function slugHash(value) {
-    return (0, node_crypto_1.createHash)('sha1').update(value).digest('hex').slice(0, 12);
+    return createHash('sha1').update(value).digest('hex').slice(0, 12);
 }
 function tokenize(value) {
     return Array.from(new Set(String(value || '')
@@ -65,22 +59,22 @@ function inferTags(text) {
         tags.add('validation');
     return Array.from(tags).slice(0, 8);
 }
-class ProjectMemoryService {
+export class ProjectMemoryService {
     workspacePath;
     memoryDir;
     brainPath;
     constructor(workspacePath = process.cwd()) {
-        this.workspacePath = node_path_1.default.resolve(workspacePath || process.cwd());
-        this.memoryDir = node_path_1.default.join(this.workspacePath, '.vigthoria', 'memory');
-        this.brainPath = node_path_1.default.join(this.memoryDir, 'brain.json');
+        this.workspacePath = path.resolve(workspacePath || process.cwd());
+        this.memoryDir = path.join(this.workspacePath, '.vigthoria', 'memory');
+        this.brainPath = path.join(this.memoryDir, 'brain.json');
     }
     getMemoryDir() {
         return this.memoryDir;
     }
     loadBrain() {
         try {
-            if (node_fs_1.default.existsSync(this.brainPath)) {
-                const parsed = JSON.parse(node_fs_1.default.readFileSync(this.brainPath, 'utf8'));
+            if (fs.existsSync(this.brainPath)) {
+                const parsed = JSON.parse(fs.readFileSync(this.brainPath, 'utf8'));
                 if (parsed && parsed.version === 1 && Array.isArray(parsed.items)) {
                     return parsed;
                 }
@@ -91,21 +85,21 @@ class ProjectMemoryService {
         }
         return {
             version: 1,
-            workspaceName: node_path_1.default.basename(this.workspacePath),
+            workspaceName: path.basename(this.workspacePath),
             updatedAt: nowIso(),
             items: [],
         };
     }
     saveBrain(brain) {
         try {
-            node_fs_1.default.mkdirSync(this.memoryDir, { recursive: true });
+            fs.mkdirSync(this.memoryDir, { recursive: true });
             const normalized = {
                 ...brain,
-                workspaceName: brain.workspaceName || node_path_1.default.basename(this.workspacePath),
+                workspaceName: brain.workspaceName || path.basename(this.workspacePath),
                 updatedAt: nowIso(),
                 items: this.dedupeAndTrim(brain.items || []),
             };
-            node_fs_1.default.writeFileSync(this.brainPath, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
+            fs.writeFileSync(this.brainPath, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
             this.writeMarkdownViews(normalized);
         }
         catch {
@@ -276,10 +270,10 @@ class ProjectMemoryService {
                 continue;
             const heading = this.headingForType(type);
             const lines = [`# ${heading}`, '', ...items.map((item) => `- ${item.text}`)];
-            node_fs_1.default.writeFileSync(node_path_1.default.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n', 'utf8');
+            fs.writeFileSync(path.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n', 'utf8');
             allLines.push(`## ${heading}`, '', ...items.slice(-40).map((item) => `- ${item.text}`), '');
         }
-        node_fs_1.default.writeFileSync(node_path_1.default.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n', 'utf8');
+        fs.writeFileSync(path.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n', 'utf8');
     }
     headingForType(type) {
         switch (type) {
@@ -293,4 +287,3 @@ class ProjectMemoryService {
         }
     }
 }
-exports.ProjectMemoryService = ProjectMemoryService;

package/dist/utils/session.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Session Manager - Persist and resume conversations
+ * Similar to Vigthoria's session persistence
+ */
+import { ChatMessage } from './api.js';
+export type AuthState = {
+    token: string | null;
+    expiresAt: number | null;
+    isValid: boolean;
+};
+export type CliError = {
+    code: string;
+    message: string;
+    details?: any;
+    isCritical: boolean;
+};
+/**
+ * Validate persisted authentication state without assuming any field is present.
+ *
+ * Production hygiene: by default this helper is SILENT.  Earlier revisions
+ * wrote ``console.warn`` for every missing-token branch, which polluted
+ * stderr on PowerShell (NativeCommandError styling) and surfaced as noise
+ * on first-run installs.  Pass ``{ silent: false }`` only when the caller
+ * actually wants the warning visible.
+ */
+export declare function validateSession(session: AuthState, options?: {
+    silent?: boolean;
+}): boolean;
+/**
+ * Load persisted authentication state and normalize nullable token fields safely.
+ *
+ * Production behaviour: first-run users (no session file yet) get a clean
+ * ``{ token: null, expiresAt: null, isValid: false }`` instead of an
+ * exception.  Callers that need a hard failure can inspect ``isValid``.
+ */
+export declare function loadSession(): Promise<AuthState>;
+export interface Session {
+    id: string;
+    name: string;
+    project: string;
+    model: string;
+    messages: ChatMessage[];
+    memorySummary?: string;
+    compactedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    agentMode: boolean;
+    operatorMode?: boolean;
+}
+export declare class SessionManager {
+    private sessionsDir;
+    private readonly compactThreshold;
+    private readonly retainRecentMessages;
+    /** Keep at most this many session files on disk per CLI install. */
+    private readonly maxRetainedSessions;
+    /** Sessions older than this are pruned (90 days). */
+    private readonly retentionWindowMs;
+    /** Avoid running prune on every save — at most once per CLI process. */
+    private prunedThisProcess;
+    constructor();
+    private ensureDir;
+    /**
+     * Prune sessions older than the retention window AND cap the number of
+     * retained files.  This is best-effort: any unreadable file is treated
+     * as stale and removed.  Pruning is bounded to once per process.
+     */
+    private pruneIfNeeded;
+    /**
+     * Generate unique session ID
+     */
+    private generateId;
+    /**
+     * Create a new session
+     */
+    create(project: string, model: string, agentMode?: boolean, operatorMode?: boolean): Session;
+    /**
+     * Save session to disk — atomic + 0600 mode so transcripts cannot be
+     * read by other local users on a shared POSIX host.
+     */
+    save(session: Session): void;
+    /**
+     * Load session by ID
+     */
+    load(id: string): Session | null;
+    /**
+     * Get the most recent session for a project
+     */
+    getLatest(project: string): Session | null;
+    /**
+     * List all sessions (metadata only) — corrupt or unreadable files are
+     * skipped silently unless VIGTHORIA_DEBUG=1.
+     */
+    list(): Omit<Session, 'messages'>[];
+    /**
+     * Delete a session
+     */
+    delete(id: string): boolean;
+    /**
+     * Clear all sessions
+     */
+    clearAll(): number;
+    /**
+     * Add message to session
+     */
+    addMessage(session: Session, message: ChatMessage): void;
+    compactInMemory(session: Session): Session;
+    buildMemoryContext(session: Session | null): string;
+    private compactSession;
+    private isPersistentSystemMessage;
+    private mergePersistentAndRecent;
+    private mergeSummaries;
+    private summarizeMessages;
+    private normalizeMessageContent;
+    /**
+     * Get session summary for display
+     */
+    getSummary(session: Session): string;
+}