vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/direct-output-policy.js

@@ -0,0 +1,76 @@
+export function stripHiddenThoughtBlocks(text) {
+    if (!text)
+        return text;
+    return text
+        .replace(/<\|mask_start\|>[\s\S]*?<\|mask_end\|>/g, '')
+        .replace(/<think>[\s\S]*?<\/redacted_thinking>/gi, '')
+        .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+        .replace(/<\/redacted_thinking>/gi, '')
+        .replace(/<\/thinking>/gi, '')
+        .replace(/<\|(?:mask_start|mask_end)\|>/g, '')
+        .trim();
+}
+export function sanitizeDirectModeOutput(text) {
+    let cleaned = stripHiddenThoughtBlocks(text)
+        .replace(/<\|mask_start\|>[\s\S]*?<\|mask_end\|>/g, '')
+        .replace(/<think>[\s\S]*?<\/think>/gi, '')
+        .replace(/<\|(?:mask_start|mask_end)\|>/g, '');
+    cleaned = cleaned.replace(/Tool (?:read_file|grep|list_dir|glob|bash|write_file|edit_file|ssh_exec|task|multi_edit|codebase_search) (?:succeeded|FAILED)\.[\s\S]*?(?=\nTool |\n\n|$)/g, '');
+    const contaminationPatterns = [
+        /^\[Agent recovered from backend failure[^\]]*\]\s*/m,
+        /^Evidence gathered before backend failure:?\s*/m,
+        /^MANDATORY CROSS-FILE EVIDENCE[^\n]*\n?/m,
+        /^CONFIRMED CONFLICTING keys[^\n]*/m,
+        /^Keys found ONLY in [^\n]*/m,
+        /^CONSTRAINT: Your answer MUST[^\n]*/m,
+        /^GROUNDING CHECK:[^\n]*/m,
+        /^VERIFICATION PROTOCOL[^\n]*/m,
+        /^Quality gate:[^\n]*/m,
+        /^Evidence collected:[^\n]*/m,
+        /^Warning: \d+ search tool[^\n]*/m,
+        /^Tool results received for direct mode[^\n]*/m,
+        /^Step \d+ complete\. Task:[^\n]*/m,
+        /^Original user request:[^\n]*/m,
+        /^Project root boundary:[^\n]*/m,
+        /^Do not declare success[^\n]*/m,
+        /^Keep working from concrete[^\n]*/m,
+        /^Continue with tool calls if more[^\n]*/m,
+        /^IMPORTANT: Your response must be ONLY[^\n]*/m,
+        /^Because this is a debugging[^\n]*/m,
+        /^If a user is asking which file[^\n]*/m,
+        /^If the request is already[^\n]*/m,
+        /^If more work is required[^\n]*/m,
+        /^Do not ask follow-up[^\n]*/m,
+        /^CRITICAL GROUNDING RULE:[^\n]*/m,
+        /^CROSS-FILE ATTRIBUTION:[^\n]*/m,
+        /^EVIDENCE-GROUNDING RULE:[^\n]*/m,
+        /^CROSS-FILE RULE:[^\n]*/m,
+        /^OUTPUT DISCIPLINE:[^\n]*/m,
+        /^Vigthoria CLI agent operating contract\.[^\n]*/m,
+        /^You are operating inside the project root:[^\n]*/m,
+        /^CRITICAL: Begin working on the user's task[^\n]*/m,
+        /^File: \S+\s*$/m,
+        /^Search status: \S+\s*$/m,
+        /^Output:\s*$/m,
+        /^\[\.\.\. ?truncated\]\s*$/m,
+        /^---\s*$/m,
+    ];
+    for (const pattern of contaminationPatterns)
+        cleaned = cleaned.replace(pattern, '');
+    cleaned = cleaned.split(/\n\n+/).filter((paragraph) => {
+        const value = paragraph.trim();
+        if (!value || /^Tool (?:read_file|grep|list_dir|glob|bash|write_file) /i.test(value))
+            return false;
+        const lines = value.split('\n');
+        if (lines.length > 6) {
+            const codeLines = lines.filter((line) => /[{};=]|function |class |const |let |var |import |export |switch |case /.test(line));
+            if (codeLines.length / lines.length > 0.4)
+                return false;
+        }
+        return true;
+    }).join('\n\n');
+    return cleaned.replace(/\n{3,}/g, '\n\n').trim() || stripHiddenThoughtBlocks(text);
+}
+export function isDirectModeFollowUpQuestion(text) {
+    return /^(would you like me|do you want me|which aspect|what aspect|can you clarify|could you clarify|should i focus on|i will follow|i understand|i('ll| will) adhere|provide your|waiting for)/i.test(text.trim());
+}

package/dist/utils/durable-json.d.ts

@@ -0,0 +1,57 @@
+export interface DurableJsonEnvelope<T> {
+    schemaVersion: number;
+    revision: number;
+    updatedAt: string;
+    data: T;
+}
+export interface DurableJsonStoreOptions<T> {
+    filePath: string;
+    schemaVersion: number;
+    defaultValue: () => T;
+    validate: (value: unknown) => value is T;
+    migrate?: (value: unknown, fromVersion: number) => T;
+    mode?: number;
+    lockTimeoutMs?: number;
+    staleLockMs?: number;
+    now?: () => number;
+}
+export declare class DurableStateError extends Error {
+    readonly code: 'LOCK_TIMEOUT' | 'INVALID_STATE' | 'MIGRATION_FAILED' | 'WRITE_FAILED';
+    readonly filePath: string;
+    constructor(message: string, code: 'LOCK_TIMEOUT' | 'INVALID_STATE' | 'MIGRATION_FAILED' | 'WRITE_FAILED', filePath: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class DurableJsonStore<T> {
+    readonly filePath: string;
+    readonly backupPath: string;
+    readonly lockPath: string;
+    private readonly schemaVersion;
+    private readonly defaultValue;
+    private readonly validate;
+    private readonly migrate?;
+    private readonly mode;
+    private readonly lockTimeoutMs;
+    private readonly staleLockMs;
+    private readonly now;
+    constructor(options: DurableJsonStoreOptions<T>);
+    read(): T;
+    readEnvelope(): DurableJsonEnvelope<T>;
+    write(value: T): DurableJsonEnvelope<T>;
+    update(mutator: (current: T) => T): DurableJsonEnvelope<T>;
+    remove(): boolean;
+    private createEnvelope;
+    private readEnvelopeLocked;
+    private parseFile;
+    private decode;
+    private runMigration;
+    private preserveMigrationSource;
+    private tryRecoverFromBackup;
+    private writeEnvelopeLocked;
+    private writeBackupEnvelope;
+    private applyMode;
+    private syncDirectory;
+    private withLock;
+    private acquireLock;
+    private removeStaleLock;
+}

package/dist/utils/durable-json.js

@@ -0,0 +1,319 @@
+/**
+ * Durable, schema-versioned JSON persistence for CLI-owned state.
+ *
+ * The store deliberately stays synchronous because the existing CLI state APIs
+ * are synchronous. Every read that may migrate/recover and every write is
+ * serialized by an inter-process directory lock. Writes use a same-directory
+ * temporary file, fsync, and atomic rename; the last valid generation is kept
+ * as a recovery backup.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+export class DurableStateError extends Error {
+    code;
+    filePath;
+    constructor(message, code, filePath, options) {
+        super(message, options);
+        this.code = code;
+        this.filePath = filePath;
+        this.name = 'DurableStateError';
+    }
+}
+function sleepSync(milliseconds) {
+    const waitBuffer = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(waitBuffer, 0, 0, milliseconds);
+}
+function isEnvelope(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return Number.isInteger(candidate.schemaVersion)
+        && Number.isInteger(candidate.revision)
+        && typeof candidate.updatedAt === 'string'
+        && Object.prototype.hasOwnProperty.call(candidate, 'data');
+}
+export class DurableJsonStore {
+    filePath;
+    backupPath;
+    lockPath;
+    schemaVersion;
+    defaultValue;
+    validate;
+    migrate;
+    mode;
+    lockTimeoutMs;
+    staleLockMs;
+    now;
+    constructor(options) {
+        if (!Number.isInteger(options.schemaVersion) || options.schemaVersion < 1) {
+            throw new Error('Durable JSON schemaVersion must be a positive integer.');
+        }
+        this.filePath = path.resolve(options.filePath);
+        this.backupPath = `${this.filePath}.bak`;
+        this.lockPath = `${this.filePath}.lock`;
+        this.schemaVersion = options.schemaVersion;
+        this.defaultValue = options.defaultValue;
+        this.validate = options.validate;
+        this.migrate = options.migrate;
+        this.mode = options.mode ?? 0o600;
+        this.lockTimeoutMs = options.lockTimeoutMs ?? 5000;
+        this.staleLockMs = options.staleLockMs ?? 30_000;
+        this.now = options.now ?? Date.now;
+    }
+    read() {
+        return this.withLock(() => this.readEnvelopeLocked(true).data);
+    }
+    readEnvelope() {
+        return this.withLock(() => this.readEnvelopeLocked(true));
+    }
+    write(value) {
+        if (!this.validate(value)) {
+            throw new DurableStateError('Refusing to write invalid durable state.', 'INVALID_STATE', this.filePath);
+        }
+        return this.withLock(() => {
+            const current = this.readEnvelopeLocked(false);
+            const envelope = this.createEnvelope(value, current.revision + 1);
+            this.writeEnvelopeLocked(envelope);
+            return envelope;
+        });
+    }
+    update(mutator) {
+        return this.withLock(() => {
+            const current = this.readEnvelopeLocked(true);
+            const next = mutator(current.data);
+            if (!this.validate(next)) {
+                throw new DurableStateError('Durable state update produced an invalid value.', 'INVALID_STATE', this.filePath);
+            }
+            const envelope = this.createEnvelope(next, current.revision + 1);
+            this.writeEnvelopeLocked(envelope);
+            return envelope;
+        });
+    }
+    remove() {
+        return this.withLock(() => {
+            let removed = false;
+            for (const candidate of [this.filePath, this.backupPath]) {
+                try {
+                    fs.unlinkSync(candidate);
+                    removed = true;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+            this.syncDirectory();
+            return removed;
+        });
+    }
+    createEnvelope(data, revision) {
+        return {
+            schemaVersion: this.schemaVersion,
+            revision,
+            updatedAt: new Date(this.now()).toISOString(),
+            data,
+        };
+    }
+    readEnvelopeLocked(repair) {
+        if (!fs.existsSync(this.filePath)) {
+            return this.createEnvelope(this.defaultValue(), 0);
+        }
+        try {
+            const parsed = this.parseFile(this.filePath);
+            const decoded = this.decode(parsed);
+            if (decoded.requiresRewrite && repair) {
+                this.preserveMigrationSource();
+                this.writeEnvelopeLocked(decoded.envelope);
+            }
+            return decoded.envelope;
+        }
+        catch (primaryError) {
+            if (repair) {
+                const recovered = this.tryRecoverFromBackup(primaryError);
+                if (recovered)
+                    return recovered;
+            }
+            if (primaryError instanceof DurableStateError)
+                throw primaryError;
+            throw new DurableStateError('Durable state is unreadable and no valid recovery copy exists.', 'INVALID_STATE', this.filePath, { cause: primaryError });
+        }
+    }
+    parseFile(candidate) {
+        const text = fs.readFileSync(candidate, 'utf8');
+        if (!text.trim()) {
+            throw new Error('State file is empty.');
+        }
+        return JSON.parse(text);
+    }
+    decode(parsed) {
+        if (isEnvelope(parsed)) {
+            if (parsed.schemaVersion > this.schemaVersion) {
+                throw new DurableStateError(`State schema ${parsed.schemaVersion} is newer than supported schema ${this.schemaVersion}.`, 'INVALID_STATE', this.filePath);
+            }
+            if (parsed.schemaVersion === this.schemaVersion && this.validate(parsed.data)) {
+                return { envelope: parsed, requiresRewrite: false };
+            }
+            return {
+                envelope: this.createEnvelope(this.runMigration(parsed.data, parsed.schemaVersion), parsed.revision + 1),
+                requiresRewrite: true,
+            };
+        }
+        return {
+            envelope: this.createEnvelope(this.runMigration(parsed, 0), 1),
+            requiresRewrite: true,
+        };
+    }
+    runMigration(value, fromVersion) {
+        try {
+            const migrated = this.migrate ? this.migrate(value, fromVersion) : value;
+            if (!this.validate(migrated))
+                throw new Error('Migrated value failed schema validation.');
+            return migrated;
+        }
+        catch (error) {
+            throw new DurableStateError(`Could not migrate durable state from schema ${fromVersion} to ${this.schemaVersion}.`, 'MIGRATION_FAILED', this.filePath, { cause: error });
+        }
+    }
+    preserveMigrationSource() {
+        const migrationBackup = `${this.filePath}.pre-migration.bak`;
+        if (!fs.existsSync(migrationBackup)) {
+            fs.copyFileSync(this.filePath, migrationBackup, fs.constants.COPYFILE_EXCL);
+            this.applyMode(migrationBackup);
+        }
+    }
+    tryRecoverFromBackup(primaryError) {
+        if (!fs.existsSync(this.backupPath))
+            return null;
+        try {
+            const recovered = this.decode(this.parseFile(this.backupPath)).envelope;
+            const corruptPath = `${this.filePath}.corrupt-${this.now()}-${process.pid}`;
+            fs.renameSync(this.filePath, corruptPath);
+            this.applyMode(corruptPath);
+            this.writeEnvelopeLocked(recovered, false);
+            return recovered;
+        }
+        catch (backupError) {
+            throw new DurableStateError('Durable state and its recovery backup are both invalid.', 'INVALID_STATE', this.filePath, { cause: { primaryError, backupError } });
+        }
+    }
+    writeEnvelopeLocked(envelope, rotateBackup = true) {
+        const parent = path.dirname(this.filePath);
+        fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+        if (process.platform !== 'win32') {
+            try {
+                fs.chmodSync(parent, 0o700);
+            }
+            catch { /* filesystem may not support chmod */ }
+        }
+        const temporary = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let descriptor;
+        try {
+            descriptor = fs.openSync(temporary, 'wx', this.mode);
+            fs.writeFileSync(descriptor, `${JSON.stringify(envelope, null, 2)}\n`, 'utf8');
+            fs.fsyncSync(descriptor);
+            fs.closeSync(descriptor);
+            descriptor = undefined;
+            this.applyMode(temporary);
+            if (rotateBackup && fs.existsSync(this.filePath)) {
+                try {
+                    const current = this.decode(this.parseFile(this.filePath)).envelope;
+                    this.writeBackupEnvelope(current);
+                }
+                catch {
+                    // Never replace a known-good backup with a corrupt current file.
+                }
+            }
+            fs.renameSync(temporary, this.filePath);
+            this.applyMode(this.filePath);
+            this.syncDirectory();
+        }
+        catch (error) {
+            if (descriptor !== undefined) {
+                try {
+                    fs.closeSync(descriptor);
+                }
+                catch { /* already closed */ }
+            }
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { /* absent */ }
+            if (error instanceof DurableStateError)
+                throw error;
+            throw new DurableStateError('Atomic durable-state write failed.', 'WRITE_FAILED', this.filePath, { cause: error });
+        }
+    }
+    writeBackupEnvelope(envelope) {
+        const temporary = `${this.backupPath}.${process.pid}.${randomUUID()}.tmp`;
+        fs.writeFileSync(temporary, `${JSON.stringify(envelope, null, 2)}\n`, { encoding: 'utf8', mode: this.mode, flag: 'wx' });
+        this.applyMode(temporary);
+        fs.renameSync(temporary, this.backupPath);
+        this.applyMode(this.backupPath);
+    }
+    applyMode(candidate) {
+        if (process.platform === 'win32')
+            return;
+        try {
+            fs.chmodSync(candidate, this.mode);
+        }
+        catch { /* filesystem may not support chmod */ }
+    }
+    syncDirectory() {
+        if (process.platform === 'win32')
+            return;
+        let descriptor;
+        try {
+            descriptor = fs.openSync(path.dirname(this.filePath), 'r');
+            fs.fsyncSync(descriptor);
+        }
+        catch {
+            // Some filesystems do not allow directory fsync.
+        }
+        finally {
+            if (descriptor !== undefined)
+                fs.closeSync(descriptor);
+        }
+    }
+    withLock(operation) {
+        this.acquireLock();
+        try {
+            return operation();
+        }
+        finally {
+            try {
+                fs.rmdirSync(this.lockPath);
+            }
+            catch { /* stale lock cleanup handles leftovers */ }
+        }
+    }
+    acquireLock() {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true, mode: 0o700 });
+        const startedAt = this.now();
+        while (true) {
+            try {
+                fs.mkdirSync(this.lockPath, { mode: 0o700 });
+                return;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                this.removeStaleLock();
+                if (this.now() - startedAt >= this.lockTimeoutMs) {
+                    throw new DurableStateError('Timed out waiting for the durable-state writer lock.', 'LOCK_TIMEOUT', this.filePath);
+                }
+                sleepSync(10);
+            }
+        }
+    }
+    removeStaleLock() {
+        try {
+            const age = this.now() - fs.statSync(this.lockPath).mtimeMs;
+            if (age > this.staleLockMs)
+                fs.rmdirSync(this.lockPath);
+        }
+        catch {
+            // Another writer may have released the lock between stat and removal.
+        }
+    }
+}

package/dist/utils/fastAgentRouter.d.ts

@@ -1,8 +1,5 @@
-/**
- * Vigthoria v4 Assistant 9B — fast agent path classifier through the governed router.
- * Regex/trivial detection always wins; LLM router refines ambiguous build prompts only.
- */
-export type AgentRoutePath = 'template-instant' | 'v3-agent' | 'analysis-only';
+/** The CLI has one executable agent transport; specialized behavior is a server-side hint. */
+export type AgentRoutePath = 'v3-agent';
 export interface BalancedRouterJson {
     path?: string;
     task_kind?: string;
@@ -21,14 +18,16 @@ export interface BalancedRouterResult {
     endpoint?: string;
     error?: string;
 }
+export type InferenceFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 export declare function parseBalancedRouterJson(raw: string): BalancedRouterJson | null;
 /**
  * Inference bases for the V4 Assistant routing lane only.
  * Local developer machines must opt in (env) — avoids ~1.5s localhost probe on every Windows turn.
  */
 export declare function getInferenceRouterBaseUrls(selfHostedUrl: string | null): string[];
-export declare function isFastInferenceRouterAvailable(selfHostedUrl: string | null, timeoutMs?: number): Promise<boolean>;
+export declare function isFastInferenceRouterAvailable(selfHostedUrl: string | null, timeoutMs?: number, fetchImpl?: InferenceFetch): Promise<boolean>;
 export declare function routeWithBalanced4b(prompt: string, selfHostedUrl: string | null, options?: {
     timeoutMs?: number;
+    fetchImpl?: InferenceFetch;
 }): Promise<BalancedRouterResult>;
 export declare function shouldUseBalancedRouter(prompt: string, regexTaskKind?: string): boolean;

package/dist/utils/fastAgentRouter.js

@@ -2,6 +2,7 @@
  * Vigthoria v4 Assistant 9B — fast agent path classifier through the governed router.
  * Regex/trivial detection always wins; LLM router refines ambiguous build prompts only.
  */
+import { redactSensitiveText } from './secret-policy.js';
 const ROUTER_SYSTEM = `You are Vigthoria Agent Router. Reply with ONE JSON object only. No markdown, no HTML, no code fences.
 
 Paths:
@@ -16,19 +17,6 @@ Example: {"path":"template-instant","task_kind":"web-build","fast_path":"templat
 const INFERENCE_MODEL_IDS = [
     'Vigthoria-v4-Assistant-9B',
 ];
-function normalizePath(value) {
-    const p = String(value || '').trim().toLowerCase();
-    if (p === 'template-instant' || p === 'template' || p === 'html-template') {
-        return 'template-instant';
-    }
-    if (p === 'analysis-only' || p === 'analysis') {
-        return 'analysis-only';
-    }
-    if (p === 'v3-agent' || p === 'v3' || p === 'agent') {
-        return 'v3-agent';
-    }
-    return null;
-}
 export function parseBalancedRouterJson(raw) {
     const text = String(raw || '').trim();
     if (!text)
@@ -94,15 +82,15 @@ function modelIdsFromPayload(payload) {
     }).filter(Boolean);
 }
 function includesBalancedRouterModel(modelIds) {
-    const allowed = new Set(INFERENCE_MODEL_IDS);
+    const allowed = new Set(INFERENCE_MODEL_IDS.map((id) => id.toLowerCase()));
     return modelIds.some((id) => allowed.has(String(id).trim().toLowerCase().replace(/:latest$/, '')));
 }
-async function probeBalancedRouterBase(base, timeoutMs) {
+async function probeBalancedRouterBase(base, timeoutMs, fetchImpl) {
     const fetchJson = async (path) => {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         try {
-            const response = await fetch(`${base}${path}`, { signal: controller.signal });
+            const response = await fetchImpl(`${base}${path}`, { signal: controller.signal });
             const payload = await response.json().catch(() => null);
             return { ok: response.ok, payload };
         }
@@ -124,33 +112,37 @@ async function probeBalancedRouterBase(base, timeoutMs) {
     const catalog = await fetchJson('/v1/models');
     return catalog.ok && includesBalancedRouterModel(modelIdsFromPayload(catalog.payload));
 }
-async function compatibleInferenceRouterBases(selfHostedUrl, timeoutMs) {
+async function compatibleInferenceRouterBases(selfHostedUrl, timeoutMs, fetchImpl) {
     const bases = getInferenceRouterBaseUrls(selfHostedUrl);
     const key = bases.join('|');
     const now = Date.now();
-    if (inferenceHealthCache
+    if (fetchImpl === globalThis.fetch
+        &&
+            inferenceHealthCache
         && inferenceHealthCache.key === key
         && now - inferenceHealthCache.checkedAt < 60_000) {
         return inferenceHealthCache.compatibleBases;
     }
     const compatibleBases = [];
     for (const base of bases) {
-        if (await probeBalancedRouterBase(base, timeoutMs)) {
+        if (await probeBalancedRouterBase(base, timeoutMs, fetchImpl)) {
             compatibleBases.push(base);
         }
     }
-    inferenceHealthCache = { key, compatibleBases, checkedAt: now };
+    if (fetchImpl === globalThis.fetch) {
+        inferenceHealthCache = { key, compatibleBases, checkedAt: now };
+    }
     return compatibleBases;
 }
-export async function isFastInferenceRouterAvailable(selfHostedUrl, timeoutMs = 400) {
+export async function isFastInferenceRouterAvailable(selfHostedUrl, timeoutMs = 400, fetchImpl = globalThis.fetch) {
     if (process.env.VIGTHORIA_AGENT_LLM_ROUTER === '0') {
         return false;
     }
-    return (await compatibleInferenceRouterBases(selfHostedUrl, timeoutMs)).length > 0;
+    return (await compatibleInferenceRouterBases(selfHostedUrl, timeoutMs, fetchImpl)).length > 0;
 }
 export async function routeWithBalanced4b(prompt, selfHostedUrl, options = {}) {
     const timeoutMs = options.timeoutMs ?? Number.parseInt(process.env.VIGTHORIA_AGENT_ROUTER_TIMEOUT_MS || '8000', 10);
-    const bases = await compatibleInferenceRouterBases(selfHostedUrl, Math.min(timeoutMs, 1500));
+    const bases = await compatibleInferenceRouterBases(selfHostedUrl, Math.min(timeoutMs, 1500), options.fetchImpl || globalThis.fetch);
     let lastError = 'Inference router unreachable';
     if (bases.length === 0) {
         return { ok: false, error: 'No compatible Balanced 4B inference endpoint is available' };
@@ -161,14 +153,14 @@ export async function routeWithBalanced4b(prompt, selfHostedUrl, options = {}) {
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), timeoutMs);
             try {
-                const response = await fetch(`${base}/v1/chat/completions`, {
+                const response = await (options.fetchImpl || globalThis.fetch)(`${base}/v1/chat/completions`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({
                         model,
                         messages: [
                             { role: 'system', content: ROUTER_SYSTEM },
-                            { role: 'user', content: String(prompt || '').slice(0, 1200) },
+                            { role: 'user', content: redactSensitiveText(String(prompt || '')).slice(0, 1200) },
                         ],
                         max_tokens: 96,
                         temperature: 0,

package/dist/utils/files.js

@@ -4,6 +4,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { glob } from 'glob';
+import { assertContainedAbsolutePath, resolveWorkspacePath } from './workspace-boundary.js';
+import { containsHighConfidenceSecret, isSensitivePath } from './secret-policy.js';
 export class FileUtils {
     projectRoot;
     ignorePatterns;
@@ -21,22 +23,19 @@ export class FileUtils {
     // Read file with metadata
     readFile(filePath) {
         try {
-            let absolutePath = path.isAbsolute(filePath)
-                ? filePath
-                : path.join(this.projectRoot, filePath);
-            // Resolve symlinks for consistent path handling
-            try {
-                absolutePath = fs.realpathSync(absolutePath);
-            }
-            catch {
-                // Keep original path if realpath fails
-            }
+            if (isSensitivePath(filePath))
+                return null;
+            const absolutePath = path.isAbsolute(filePath)
+                ? assertContainedAbsolutePath(this.projectRoot, filePath)
+                : resolveWorkspacePath(this.projectRoot, filePath);
             // Check if it's a regular file (not a directory or special file)
             const stats = fs.statSync(absolutePath);
             if (!stats.isFile()) {
                 return null;
             }
             const content = fs.readFileSync(absolutePath, 'utf-8');
+            if (containsHighConfidenceSecret(content))
+                return null;
             const relativePath = path.relative(this.projectRoot, absolutePath);
             return {
                 path: absolutePath,
@@ -62,8 +61,8 @@ export class FileUtils {
     writeFile(filePath, content) {
         try {
             const absolutePath = path.isAbsolute(filePath)
-                ? filePath
-                : path.join(this.projectRoot, filePath);
+                ? assertContainedAbsolutePath(this.projectRoot, filePath, { allowMissing: true })
+                : resolveWorkspacePath(this.projectRoot, filePath, { allowMissing: true });
             // Create directory if needed
             const dir = path.dirname(absolutePath);
             if (!fs.existsSync(dir)) {
@@ -98,8 +97,17 @@ export class FileUtils {
                 cwd: this.projectRoot,
                 ignore: this.ignorePatterns,
                 nodir: true,
+                follow: false,
+            });
+            return files.filter((file) => {
+                try {
+                    resolveWorkspacePath(this.projectRoot, file);
+                    return !isSensitivePath(file);
+                }
+                catch {
+                    return false;
+                }
             });
-            return files;
         }
         catch (error) {
             // Return empty array on error (e.g., permission issues on Windows)