careervivid 2.1.21 → 2.1.22

package/dist/commands/agent/engineResolver.js

@@ -50,6 +50,6 @@ export function printBanner(options, selectedProvider, selectedModel, _thinkingB
     else {
         console.log(chalk.dim(`  Provider: ${selectedProvider}  ·  Model: ${selectedModel}  [0 credits]`));
     }
-    const modeLabel = options.jobs ? "Jobs & Applications" : options.resume ? "Resume" : "General";
+    const modeLabel = options.resume ? "Resume" : options.coding ? "Coding" : "Jobs & Applications";
     console.log(chalk.dim(`  Mode: ${modeLabel}  ·  Type 'exit' to quit  ·  /help for commands.\n`));
 }

package/dist/commands/agent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QA6IpD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAmJpD"}

package/dist/commands/agent/index.js

@@ -13,7 +13,7 @@ export function registerAgentCommand(program) {
         .description("Start an interactive autonomous AI agent in your terminal.")
         .option("--coding", "Enable full coding tool suite (file I/O, shell, search).")
         .option("--resume", "Add resume tools — load and discuss your CareerVivid resume.")
-        .option("--jobs", "Add job-hunting tools — search jobs, save to tracker, update statuses.")
+        .option("--jobs", "Add job-hunting tools (default — enabled automatically).")
         .option("--flash", "Use gemini-3-flash-preview — latest flash model (fast, 1 credit/turn).")
         .option("--pro", "Use gemini-3.1-pro-preview with thinking mode (recommended for complex tasks).")
         .option("--think <budget>", "Enable Gemini thinking mode with the given token budget (e.g. 8192).", parseInt)
@@ -24,6 +24,11 @@ export function registerAgentCommand(program) {
         .option("--api-key <key>", "BYO API key for this session (not saved).")
         .option("--base-url <url>", "Custom OpenAI-compatible base URL.")
         .action(async (options) => {
+        // Jobs mode is the primary entry point — always enabled unless an explicit
+        // alternate mode flag (--resume, --coding) was passed.
+        if (!options.resume && !options.coding) {
+            options.jobs = true;
+        }
         const cvApiKey = getApiKey();
         const project = options.project ?? process.env.GOOGLE_CLOUD_PROJECT;
         const wantsCareerVividCloud = !options.provider || options.provider === "careervivid";
@@ -114,8 +119,8 @@ export function registerAgentCommand(program) {
         }
         const engine = buildEngine(selectedProvider, selectedModel, systemInstruction, tools, thinkingBudget, includeThoughts, cvApiKey, geminiApiKey, project);
         printBanner(options, selectedProvider, selectedModel, thinkingBudget);
-        // ── Record session context for memory ────────────────────────────────────────────────
-        const agentMode = options.jobs ? "jobs" : options.resume ? "resume" : "coding";
+        // agentMode: jobs is now always the default
+        const agentMode = options.resume ? "resume" : options.coding ? "coding" : "jobs";
         initSessionContext(agentMode, selectedModel);
         await askLoop(engine, options, selectedProvider, selectedModel, cvApiKey, systemInstruction, tools);
     });

package/dist/commands/agent/repl/engineLoop.d.ts

@@ -0,0 +1,35 @@
+/**
+ * repl/engineLoop.ts
+ *
+ * Runs the AI response loop for both engine types:
+ *   - CareerVividProxyEngine  (cv_live_ API key → cloud proxy)
+ *   - BYO providers           (OpenAI, Anthropic, OpenRouter, custom)
+ *
+ * Returns the full accumulated text response for TTS / audit.
+ */
+import { CareerVividProxyEngine } from "../../../agent/CareerVividProxyEngine.js";
+import { QueryEngine } from "../../../agent/QueryEngine.js";
+import { type LLMProvider } from "../../../config.js";
+import { ToolHandlerState } from "./toolHandlers.js";
+export interface EngineRunOptions {
+    engine: QueryEngine | CareerVividProxyEngine | null;
+    userInput: string;
+    selectedProvider: LLMProvider;
+    selectedModel: string;
+    currentModel: string;
+    byoHistory: any[];
+    tools: any[];
+    systemInstruction: string;
+    verbose: boolean;
+    sessionTurns: number;
+    apiKey: string | undefined;
+    baseUrl: string | undefined;
+    handleSigInt: () => void;
+    toolState: ToolHandlerState;
+    onCreditInfo: (remaining: number | null, limit: number | null) => void;
+}
+/**
+ * Run one full agent turn. Returns the accumulated text response.
+ */
+export declare function runEngineLoop(opts: EngineRunOptions): Promise<string>;
+//# sourceMappingURL=engineLoop.d.ts.map

package/dist/commands/agent/repl/engineLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineLoop.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/repl/engineLoop.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAElF,OAAO,EAA4B,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAc/E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,WAAW,GAAG,sBAAsB,GAAG,IAAI,CAAC;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,WAAW,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,GAAG,EAAE,CAAC;IAClB,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACxE;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CA6K3E"}

package/dist/commands/agent/repl/engineLoop.js

@@ -0,0 +1,168 @@
+/**
+ * repl/engineLoop.ts
+ *
+ * Runs the AI response loop for both engine types:
+ *   - CareerVividProxyEngine  (cv_live_ API key → cloud proxy)
+ *   - BYO providers           (OpenAI, Anthropic, OpenRouter, custom)
+ *
+ * Returns the full accumulated text response for TTS / audit.
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { CareerVividProxyEngine } from "../../../agent/CareerVividProxyEngine.js";
+import { QueryEngine } from "../../../agent/QueryEngine.js";
+import { loadConfig, getProviderKey } from "../../../config.js";
+import { printCreditStatus } from "../repl.js";
+import { onToolCall, onToolResult } from "./toolHandlers.js";
+/** Timeout wrapper */
+function withTimeout(p, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms / 1000}s. Press Ctrl+C if stuck.`)), ms);
+        p.then(v => { clearTimeout(timer); resolve(v); })
+            .catch(e => { clearTimeout(timer); reject(e); });
+    });
+}
+/**
+ * Run one full agent turn. Returns the accumulated text response.
+ */
+export async function runEngineLoop(opts) {
+    const { engine, userInput, selectedProvider, currentModel, byoHistory, tools, systemInstruction, verbose, apiKey, baseUrl, handleSigInt, toolState, } = opts;
+    let responseAccumulator = "";
+    let firstChunk = true;
+    const thinkingSpinner = ora({
+        text: chalk.dim("Vivid is thinking…"),
+        color: "cyan",
+        spinner: "dots",
+    }).start();
+    const onChunk = (text) => {
+        if (firstChunk) {
+            thinkingSpinner.stop();
+            process.stdout.write("\n" + chalk.hex("#6366f1")("✦ "));
+            firstChunk = false;
+        }
+        process.stdout.write(text);
+        responseAccumulator += text;
+    };
+    const onThinking = (thought) => {
+        if (verbose) {
+            console.log(chalk.dim(`\n[thinking] ${thought.substring(0, 200)}...`));
+        }
+    };
+    const onError = (error) => {
+        thinkingSpinner.stop();
+        if (toolState.currentSpinner) {
+            toolState.currentSpinner.fail("Tool error");
+            toolState.currentSpinner = null;
+        }
+        console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    };
+    const onCompacting = () => {
+        console.log(chalk.dim("\n📦 Compacting context window...\n"));
+    };
+    const boundOnToolCall = (name, args) => onToolCall(name, args, thinkingSpinner, toolState);
+    const boundOnToolResult = (name, result) => onToolResult(name, result, toolState);
+    // ── CareerVivid Cloud engine ──────────────────────────────────────────────
+    if (engine instanceof CareerVividProxyEngine) {
+        await engine.runLoopStreaming(userInput, {
+            onChunk,
+            onThinking,
+            onToolCall: boundOnToolCall,
+            onToolResult: boundOnToolResult,
+            onCompacting,
+            onError,
+            onResponse: async (creditInfo) => {
+                opts.onCreditInfo(creditInfo.creditsRemaining, creditInfo.monthlyLimit);
+                printCreditStatus(creditInfo.creditsRemaining, creditInfo.monthlyLimit);
+            },
+            onCreditLimitReached: (remaining) => {
+                console.log(chalk.red(`\n\n⚠️  Credit limit reached (${remaining} remaining).\n` +
+                    chalk.dim("   Upgrade or top up at ") +
+                    chalk.underline.blue("careervivid.app/developer")));
+            },
+        });
+        // ── QueryEngine (direct Gemini) ───────────────────────────────────────────
+    }
+    else if (engine instanceof QueryEngine) {
+        await engine.runLoopStreaming(userInput, {
+            onChunk,
+            onThinking,
+            onToolCall: boundOnToolCall,
+            onToolResult: boundOnToolResult,
+            onCompacting,
+            onError,
+        });
+        // ── BYO Provider (OpenAI / Anthropic / OpenRouter / custom) ──────────────
+    }
+    else {
+        const { createOpenAICompatibleProvider } = await import("../../../agent/providers/OpenAIProvider.js");
+        const { AnthropicProvider } = await import("../../../agent/providers/AnthropicProvider.js");
+        const byoApiKey = apiKey || getProviderKey(selectedProvider) || loadConfig().llmApiKey || "";
+        const resolvedBaseUrl = baseUrl || loadConfig().llmBaseUrl;
+        let provider;
+        if (selectedProvider === "anthropic") {
+            provider = new AnthropicProvider({ apiKey: byoApiKey });
+        }
+        else {
+            const sub = selectedProvider === "openrouter" ? "openrouter" :
+                selectedProvider === "custom" ? "custom" : "openai";
+            provider = createOpenAICompatibleProvider(sub, byoApiKey, resolvedBaseUrl);
+        }
+        let userTurn = { role: "user", parts: [{ text: userInput }] };
+        let round = 0;
+        while (round < 10) {
+            const result = await withTimeout(provider.generate({ model: currentModel, history: byoHistory, userTurn, tools, systemInstruction }), 45_000, "LLM generate()");
+            if (round === 0) {
+                thinkingSpinner.stop();
+                process.stdout.write("\n" + chalk.hex("#6366f1")("✦ "));
+                firstChunk = false;
+            }
+            if (result.text) {
+                process.stdout.write(result.text);
+                responseAccumulator += result.text;
+            }
+            byoHistory.push(userTurn);
+            byoHistory.push({ role: "model", parts: result.rawParts || [{ text: result.text }] });
+            if (!result.functionCalls?.length)
+                break;
+            const fnResponses = [];
+            for (const fc of result.functionCalls) {
+                const allow = await boundOnToolCall(fc.name, fc.args);
+                if (!allow) {
+                    fnResponses.push({
+                        functionResponse: { id: fc.id, name: fc.name, response: { error: "User denied execution." } },
+                    });
+                    continue;
+                }
+                const tool = tools.find((t) => t.name === fc.name);
+                let out;
+                try {
+                    if (fc.name === "start_interview") {
+                        process.removeListener("SIGINT", handleSigInt);
+                        try {
+                            out = tool ? await tool.execute(fc.args) : { error: "Tool not found" };
+                        }
+                        finally {
+                            process.on("SIGINT", handleSigInt);
+                        }
+                    }
+                    else {
+                        out = tool
+                            ? await withTimeout(tool.execute(fc.args), 45_000, `tool:${fc.name}`)
+                            : { error: "Tool not found" };
+                    }
+                }
+                catch (e) {
+                    out = e.message?.includes("No API key configured")
+                        ? { error: "CareerVivid API key not found. Run 'cv login' to authenticate." }
+                        : { error: e.message };
+                }
+                boundOnToolResult(fc.name, out);
+                fnResponses.push({ functionResponse: { id: fc.id, name: fc.name, response: out } });
+            }
+            userTurn = { role: "user", parts: fnResponses };
+            round++;
+        }
+    }
+    process.stdout.write("\n" + chalk.dim("─".repeat(48)) + "\n");
+    return responseAccumulator;
+}

package/dist/commands/agent/repl/input.d.ts

@@ -0,0 +1,21 @@
+/**
+ * repl/input.ts
+ *
+ * Handles all user input collection:
+ *  - First-turn quick-action menu (autocomplete)
+ *  - Subsequent turn free-text input
+ *  - Multi-line paste mode (<<<)
+ *  - Fast-paste buffer accumulation
+ */
+/** Read the first-turn menu selection. Returns the cleaned user intent string. */
+export declare function readFirstTurnInput(): Promise<string>;
+/** Reads a single multi-line paste block. User ends with an empty Enter. */
+export declare function readMultiLineInput(prefix: string): Promise<string>;
+export interface InputResult {
+    text: string;
+    /** True when the input arrived in < 150ms (possible paste line) */
+    isFastLine: boolean;
+}
+/** Read a normal subsequent-turn line. Returns the raw text and timing flag. */
+export declare function readNormalInput(showContinuation: boolean): Promise<InputResult>;
+//# sourceMappingURL=input.d.ts.map

package/dist/commands/agent/repl/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/repl/input.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,kFAAkF;AAClF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAyB1D;AAED,4EAA4E;AAC5E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoBxE;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,gFAAgF;AAChF,wBAAsB,eAAe,CAAC,gBAAgB,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAUrF"}

package/dist/commands/agent/repl/input.js

@@ -0,0 +1,78 @@
+/**
+ * repl/input.ts
+ *
+ * Handles all user input collection:
+ *  - First-turn quick-action menu (autocomplete)
+ *  - Subsequent turn free-text input
+ *  - Multi-line paste mode (<<<)
+ *  - Fast-paste buffer accumulation
+ */
+import chalk from "chalk";
+import pkg from "enquirer";
+const { prompt } = pkg;
+const MENU_ITEMS = [
+    "📄 View or update my resume",
+    "🔍 Search for job opportunities",
+    "📊 Check my job pipeline / tracker",
+    "✉️  Draft a cover letter or tailor my resume",
+    "🎙  Start an AI mock interview (voice or text)",
+    "📈 Get an overview of my job search progress",
+    "🗓️  Pick up where we left off",
+];
+/** Read the first-turn menu selection. Returns the cleaned user intent string. */
+export async function readFirstTurnInput() {
+    console.log(chalk.dim("  What would you like to do today?\n"));
+    for (const item of MENU_ITEMS) {
+        console.log(chalk.dim(`  ${item}`));
+    }
+    console.log("");
+    const firstResp = await prompt({
+        type: "autocomplete",
+        name: "choice",
+        message: chalk.bold.hex("#6366f1")("❯") + chalk.dim(" ·"),
+        limit: 7,
+        suggest(input, choices) {
+            if (!input)
+                return choices;
+            return choices.filter((c) => c.value.toLowerCase().includes(input.toLowerCase()));
+        },
+        choices: MENU_ITEMS.map(item => ({ name: item, value: item })),
+        footer: chalk.dim("  ↑↓ to navigate  ·  type to filter  ·  Enter to send"),
+    });
+    const raw = firstResp.choice?.trim() || "";
+    // Strip emoji prefixes so the agent gets clean text
+    return raw.replace(/^[\p{Emoji}\s]+/u, "").trim() || raw;
+}
+/** Reads a single multi-line paste block. User ends with an empty Enter. */
+export async function readMultiLineInput(prefix) {
+    console.log(chalk.dim("  📋 Multi-line mode: paste your text, then press Enter twice to submit.\n"));
+    const lines = prefix ? [prefix] : [];
+    let emptyCount = 0;
+    while (emptyCount < 1) {
+        const lineResp = await prompt({
+            type: "input",
+            name: "line",
+            message: chalk.dim("  │"),
+        });
+        if (lineResp.line === "") {
+            emptyCount++;
+        }
+        else {
+            emptyCount = 0;
+            lines.push(lineResp.line);
+        }
+    }
+    return lines.join("\n").trim();
+}
+/** Read a normal subsequent-turn line. Returns the raw text and timing flag. */
+export async function readNormalInput(showContinuation) {
+    const t0 = Date.now();
+    const response = await prompt({
+        type: "input",
+        name: "query",
+        message: showContinuation
+            ? chalk.dim("... ")
+            : chalk.bold.hex("#6366f1")("❯") + chalk.dim(" ·"),
+    });
+    return { text: response.query, isFastLine: Date.now() - t0 < 150 };
+}

package/dist/commands/agent/repl/slashCommands.d.ts

@@ -0,0 +1,33 @@
+/**
+ * repl/slashCommands.ts
+ *
+ * Handles all slash (/) commands typed in the REPL:
+ *   /help, /voice, /speak, /models, /model
+ *
+ * Returns `true` if the command was handled (caller should re-prompt),
+ * returns `false` if the input was not a slash command.
+ */
+interface ModelSwitchContext {
+    currentModel: string;
+    cvApiKey: string | undefined;
+    engine: any;
+    systemInstruction: string;
+    tools: any[];
+    options: {
+        think?: number;
+    };
+}
+export interface SlashCommandResult {
+    /** If model was switched, contains the new values */
+    modelSwitch?: {
+        newModel: string;
+        newEngine: any;
+    };
+}
+/**
+ * Dispatch a slash command. Returns the result or null if not a slash command.
+ * Always returns non-null for slash inputs — caller should re-prompt after.
+ */
+export declare function handleSlashCommand(input: string, currentModel: string, modelCtx: Omit<ModelSwitchContext, "currentModel">): Promise<SlashCommandResult | null>;
+export {};
+//# sourceMappingURL=slashCommands.d.ts.map

package/dist/commands/agent/repl/slashCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashCommands.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/repl/slashCommands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA6IH,UAAU,kBAAkB;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE,GAAG,CAAC;IACZ,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7B;AAyCD,MAAM,WAAW,kBAAkB;IACjC,qDAAqD;IACrD,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,GAAG,CAAA;KAAE,CAAC;CACpD;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,IAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC,GACjD,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAkCpC"}

package/dist/commands/agent/repl/slashCommands.js

@@ -0,0 +1,193 @@
+/**
+ * repl/slashCommands.ts
+ *
+ * Handles all slash (/) commands typed in the REPL:
+ *   /help, /voice, /speak, /models, /model
+ *
+ * Returns `true` if the command was handled (caller should re-prompt),
+ * returns `false` if the input was not a slash command.
+ */
+import chalk from "chalk";
+import pkg from "enquirer";
+import { CV_MODELS } from "../configurator.js";
+import { CareerVividProxyEngine } from "../../../agent/CareerVividProxyEngine.js";
+import { isVoiceEnabled, setVoiceEnabled, stopPlayback, getLastResponse, speakText, getCurrentVoice, setCurrentVoice, getCurrentTtsModel, setCurrentTtsModel, AVAILABLE_VOICES, AVAILABLE_TTS_MODELS, } from "../../../lib/tts.js";
+const { prompt } = pkg;
+// ── /help ─────────────────────────────────────────────────────────────────────
+function handleHelp() {
+    console.log(chalk.cyan("\n  Slash commands:"));
+    console.log(chalk.dim("  /model <name>  — Switch to a different model mid-session"));
+    console.log(chalk.dim("  /models        — List all available CareerVivid models"));
+    console.log(chalk.dim("  /voice         — Voice / TTS settings (interactive)"));
+    console.log(chalk.dim("  /voice on|off  — Quick toggle"));
+    console.log(chalk.dim("  /speak         — Read the last agent response aloud"));
+    console.log(chalk.dim("  /help          — Show this help message"));
+    console.log(chalk.dim("  exit           — End the session"));
+    console.log(chalk.cyan("\n  Shell escape (run terminal commands without leaving the agent):"));
+    console.log(chalk.dim("  !<command>     — e.g. !ls -la  or  !git status\n"));
+    console.log(chalk.cyan("  Paste long content (job descriptions, cover letters):"));
+    console.log(chalk.dim("  <<<            — Open multi-line paste mode; press Enter twice when done"));
+    console.log(chalk.dim("  <<<your text   — Start with text directly after <<<\n"));
+}
+// ── /voice (interactive select) ───────────────────────────────────────────────
+async function handleVoice(arg) {
+    // Quick text shortcuts (scriptable / muscle-memory)
+    if (arg === "on") {
+        setVoiceEnabled(true);
+        console.log(chalk.green(`\n  🔊 Voice on  (${getCurrentVoice()} · ${getCurrentTtsModel()})\n`));
+        return;
+    }
+    if (arg === "off") {
+        setVoiceEnabled(false);
+        stopPlayback();
+        console.log(chalk.yellow("\n  🔇 Voice off\n"));
+        return;
+    }
+    // Interactive top-level menu
+    const topChoice = await prompt({
+        type: "select",
+        name: "action",
+        message: `Voice settings  (${chalk.dim(`voice: ${getCurrentVoice()}  model: ${getCurrentTtsModel()}}`)})`,
+        choices: [
+            { name: "toggle", message: isVoiceEnabled() ? "🔇 Turn voice off" : "🔊 Turn voice on" },
+            { name: "set-voice", message: "🎵 Pick a voice" },
+            { name: "set-model", message: "⚙️  Pick a TTS model" },
+            { name: "speak", message: "▶️  Replay last response" },
+            { name: "cancel", message: chalk.dim("Cancel") },
+        ],
+    });
+    if (topChoice.action === "toggle") {
+        const newState = !isVoiceEnabled();
+        setVoiceEnabled(newState);
+        if (!newState)
+            stopPlayback();
+        console.log(newState
+            ? chalk.green(`\n  🔊 Voice on  (${getCurrentVoice()} · ${getCurrentTtsModel()})\n`)
+            : chalk.yellow("\n  🔇 Voice off\n"));
+    }
+    else if (topChoice.action === "set-voice") {
+        const { voice } = await prompt({
+            type: "select",
+            name: "voice",
+            message: "Choose a voice:",
+            choices: AVAILABLE_VOICES.map((v) => ({
+                name: v,
+                message: v === getCurrentVoice() ? chalk.green(`${v}  ← active`) : v,
+            })),
+        });
+        setCurrentVoice(voice);
+        console.log(chalk.green(`\n  🎵 Voice set to ${chalk.bold(voice)}\n`));
+    }
+    else if (topChoice.action === "set-model") {
+        const MODEL_LABELS = {
+            "gemini-3.1-flash-tts-preview": "Gemini 3.1 Flash  (latest, fast)",
+            "gemini-2.5-flash-preview-tts": "Gemini 2.5 Flash  (previous gen, fast)",
+            "gemini-2.5-pro-preview-tts": "Gemini 2.5 Pro    (previous gen, high quality)",
+        };
+        const { model } = await prompt({
+            type: "select",
+            name: "model",
+            message: "Choose a TTS model:",
+            choices: AVAILABLE_TTS_MODELS.map((m) => ({
+                name: m,
+                message: m === getCurrentTtsModel()
+                    ? chalk.green(`${MODEL_LABELS[m] ?? m}  ← active`)
+                    : (MODEL_LABELS[m] ?? m),
+            })),
+        });
+        setCurrentTtsModel(model);
+        console.log(chalk.green(`\n  ⚙️  TTS model set to ${chalk.bold(model)}\n`));
+    }
+    else if (topChoice.action === "speak") {
+        const last = getLastResponse();
+        if (!last) {
+            console.log(chalk.dim("\n  Nothing to speak yet.\n"));
+        }
+        else {
+            speakText(last).catch(() => { });
+            console.log(chalk.dim("\n  🔊 Speaking...\n"));
+        }
+    }
+}
+// ── /speak ────────────────────────────────────────────────────────────────────
+function handleSpeak() {
+    const last = getLastResponse();
+    if (!last) {
+        console.log(chalk.dim("\n  Nothing to speak yet. Ask the agent something first.\n"));
+    }
+    else {
+        speakText(last).catch(() => { });
+        console.log(chalk.dim("\n  🔊 Speaking last response...\n"));
+    }
+}
+// ── /models ───────────────────────────────────────────────────────────────────
+function handleModels(currentModel) {
+    console.log(chalk.cyan("\n  Available CareerVivid models:"));
+    for (const m of CV_MODELS) {
+        const active = m.value === currentModel ? chalk.green(" ← active") : "";
+        console.log(`  ${m.name}${active}`);
+    }
+    console.log(chalk.dim("\n  Usage: /model gemini-2.5-flash\n"));
+}
+function handleModel(arg, ctx) {
+    if (!arg) {
+        console.log(chalk.yellow(`\n  Current model: ${chalk.bold(ctx.currentModel)}`));
+        console.log(chalk.dim("  Usage: /model <name>   e.g. /model gemini-3.1-pro-preview"));
+        console.log(chalk.dim("  Run /models to see all available options.\n"));
+        return null;
+    }
+    const known = CV_MODELS.find(m => m.value === arg);
+    if (!known && !arg.includes("/") && !arg.includes("-")) {
+        console.log(chalk.red(`\n  Unknown model: ${arg}`));
+        console.log(chalk.dim("  Run /models to see available options.\n"));
+        return null;
+    }
+    let newEngine = ctx.engine;
+    if (ctx.cvApiKey && ctx.engine instanceof CareerVividProxyEngine) {
+        newEngine = new CareerVividProxyEngine({
+            cvApiKey: ctx.cvApiKey,
+            model: arg,
+            systemInstruction: ctx.systemInstruction,
+            tools: ctx.tools,
+            thinkingBudget: arg.includes("pro") ? (ctx.options.think ?? 8192) : 0,
+            maxHistoryLength: 40,
+        });
+    }
+    const creditInfo = known ? chalk.dim(` (${known.cost} credit/turn)`) : "";
+    console.log(chalk.green(`\n  ✔ Switched to ${chalk.bold(arg)}${creditInfo}`));
+    console.log(chalk.dim("  Conversation history has been reset.\n"));
+    return { newModel: arg, newEngine };
+}
+/**
+ * Dispatch a slash command. Returns the result or null if not a slash command.
+ * Always returns non-null for slash inputs — caller should re-prompt after.
+ */
+export async function handleSlashCommand(input, currentModel, modelCtx) {
+    if (!input.startsWith("/"))
+        return null;
+    const [cmd, ...rest] = input.slice(1).split(" ");
+    const arg = rest.join(" ").trim();
+    switch (cmd) {
+        case "help":
+            handleHelp();
+            break;
+        case "voice":
+            await handleVoice(arg);
+            break;
+        case "speak":
+            handleSpeak();
+            break;
+        case "models":
+            handleModels(currentModel);
+            break;
+        case "model": {
+            const result = handleModel(arg, { ...modelCtx, currentModel });
+            if (result)
+                return { modelSwitch: result };
+            break;
+        }
+        default:
+            console.log(chalk.yellow(`\n  Unknown command: /${cmd}. Type /help for available commands.\n`));
+    }
+    return {};
+}

package/dist/commands/agent/repl/toolHandlers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * repl/toolHandlers.ts
+ *
+ * Tool call confirmation, spinner lifecycle, mutation budgets,
+ * circuit breaker, and audit logging for the REPL.
+ */
+import ora from "ora";
+export declare const WRITE_TOOLS: Set<string>;
+export declare const SESSION_MAX_MUTATIONS = 25;
+export declare const TURN_MAX_MUTATIONS = 10;
+export interface ToolHandlerState {
+    sessionMutations: number;
+    turnMutations: number;
+    trustAllCommands: boolean;
+    trustAllWrites: boolean;
+    currentSpinner: ReturnType<typeof ora> | null;
+    lastToolCall: {
+        name: string;
+        argsHash: string;
+        count: number;
+    };
+}
+export declare function createToolHandlerState(): ToolHandlerState;
+/**
+ * Called before a tool executes. Returns true to allow, false to deny.
+ * Manages confirmation prompts, spinner start, and mutation budgets.
+ */
+export declare function onToolCall(name: string, args: any, thinkingSpinner: ReturnType<typeof ora>, state: ToolHandlerState): Promise<boolean>;
+/**
+ * Called after a tool completes. Stops spinner, logs audit entry.
+ */
+export declare function onToolResult(name: string, result: any, state: ToolHandlerState): void;
+//# sourceMappingURL=toolHandlers.d.ts.map

package/dist/commands/agent/repl/toolHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolHandlers.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/repl/toolHandlers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,GAAG,MAAM,KAAK,CAAC;AAQtB,eAAO,MAAM,WAAW,aAItB,CAAC;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AA6CrC,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,UAAU,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC;IAC9C,YAAY,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACjE;AAED,wBAAgB,sBAAsB,IAAI,gBAAgB,CASzD;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,eAAe,EAAE,UAAU,CAAC,OAAO,GAAG,CAAC,EACvC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,OAAO,CAAC,CAmGlB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,gBAAgB,QAe9E"}