codebot-ai 1.6.0 → 1.8.0

package/dist/capabilities.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Capability-Based Tool Permissions for CodeBot v1.8.0
+ *
+ * Fine-grained, per-tool resource restrictions.
+ * Configured via .codebot/policy.json → tools.capabilities.
+ *
+ * Example:
+ * {
+ *   "execute": {
+ *     "shell_commands": ["npm", "node", "git", "tsc"],
+ *     "max_output_kb": 500
+ *   },
+ *   "write_file": {
+ *     "fs_write": ["./src/**", "./tests/**"]
+ *   }
+ * }
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityChecker = void 0;
+const path = __importStar(require("path"));
+// ── Capability Checker ──
+class CapabilityChecker {
+    capabilities;
+    projectRoot;
+    constructor(capabilities, projectRoot) {
+        this.capabilities = capabilities;
+        this.projectRoot = projectRoot;
+    }
+    /** Get capabilities for a tool. undefined = no restrictions. */
+    getToolCapabilities(toolName) {
+        return this.capabilities[toolName];
+    }
+    /** Check if a specific capability is allowed. */
+    checkCapability(toolName, capabilityType, value) {
+        const caps = this.capabilities[toolName];
+        if (!caps)
+            return { allowed: true }; // No caps defined = unrestricted
+        switch (capabilityType) {
+            case 'fs_read':
+                return this.checkGlobs(caps.fs_read, value, 'fs_read', toolName);
+            case 'fs_write':
+                return this.checkGlobs(caps.fs_write, value, 'fs_write', toolName);
+            case 'net_access':
+                return this.checkDomain(caps.net_access, value, toolName);
+            case 'shell_commands':
+                return this.checkCommandPrefix(caps.shell_commands, value, toolName);
+            case 'max_output_kb':
+                return this.checkOutputSize(caps.max_output_kb, value, toolName);
+            default:
+                return { allowed: true };
+        }
+    }
+    /** Check if a path matches any of the allowed glob patterns. */
+    checkGlobs(patterns, filePath, capName, toolName) {
+        if (!patterns || patterns.length === 0)
+            return { allowed: true };
+        const resolved = path.resolve(filePath);
+        const relative = path.relative(this.projectRoot, resolved);
+        // Don't restrict paths outside the project (those are handled by security.ts)
+        if (relative.startsWith('..'))
+            return { allowed: true };
+        for (const pattern of patterns) {
+            if (this.matchGlob(relative, pattern)) {
+                return { allowed: true };
+            }
+        }
+        return {
+            allowed: false,
+            reason: `Tool "${toolName}" ${capName} capability blocks "${relative}" (allowed: ${patterns.join(', ')})`,
+        };
+    }
+    /** Check if a domain is in the allowed list. */
+    checkDomain(allowed, domain, toolName) {
+        if (allowed === undefined)
+            return { allowed: true }; // undefined = unrestricted
+        if (allowed.length === 0) {
+            // Empty array = no network access allowed
+            return {
+                allowed: false,
+                reason: `Tool "${toolName}" has no allowed network domains`,
+            };
+        }
+        if (allowed.includes('*'))
+            return { allowed: true };
+        const normalizedDomain = domain.toLowerCase();
+        for (const d of allowed) {
+            const nd = d.toLowerCase();
+            if (normalizedDomain === nd)
+                return { allowed: true };
+            if (normalizedDomain.endsWith('.' + nd))
+                return { allowed: true };
+        }
+        return {
+            allowed: false,
+            reason: `Tool "${toolName}" cannot access domain "${domain}" (allowed: ${allowed.join(', ')})`,
+        };
+    }
+    /** Check if a command starts with an allowed prefix. */
+    checkCommandPrefix(allowed, command, toolName) {
+        if (!allowed || allowed.length === 0)
+            return { allowed: true };
+        const cmd = command.trim();
+        for (const prefix of allowed) {
+            if (cmd === prefix || cmd.startsWith(prefix + ' ')) {
+                return { allowed: true };
+            }
+        }
+        // Extract first word for the error message
+        const firstWord = cmd.split(/\s+/)[0] || cmd.substring(0, 30);
+        return {
+            allowed: false,
+            reason: `Tool "${toolName}" cannot run "${firstWord}" (allowed commands: ${allowed.join(', ')})`,
+        };
+    }
+    /** Check if output size is within the cap. */
+    checkOutputSize(maxKb, actualKb, toolName) {
+        if (maxKb === undefined || maxKb <= 0)
+            return { allowed: true };
+        if (actualKb <= maxKb)
+            return { allowed: true };
+        return {
+            allowed: false,
+            reason: `Tool "${toolName}" output ${actualKb}KB exceeds cap of ${maxKb}KB`,
+        };
+    }
+    /** Simple glob matching (** = any depth, * = one segment). */
+    matchGlob(relativePath, pattern) {
+        const cleanPattern = pattern.replace(/^\.\//, '');
+        const cleanPath = relativePath.replace(/^\.\//, '');
+        // Exact match
+        if (cleanPath === cleanPattern)
+            return true;
+        // Prefix match (directory)
+        if (cleanPath.startsWith(cleanPattern + '/'))
+            return true;
+        if (cleanPath.startsWith(cleanPattern + path.sep))
+            return true;
+        // Glob expansion
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' +
+                cleanPattern
+                    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                    .replace(/\*\*/g, '<<GLOBSTAR>>')
+                    .replace(/\*/g, '[^/]*')
+                    .replace(/<<GLOBSTAR>>/g, '.*') +
+                '$');
+            return regex.test(cleanPath);
+        }
+        return false;
+    }
+}
+exports.CapabilityChecker = CapabilityChecker;
+//# sourceMappingURL=capabilities.js.map

package/dist/cli.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const agent_1 = require("./agent");
 const openai_1 = require("./providers/openai");
 const anthropic_1 = require("./providers/anthropic");
@@ -44,9 +46,11 @@ const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
 const scheduler_1 = require("./scheduler");
-const VERSION = '1.6.0';
-// Session-wide token tracking
-let sessionTokens = { input: 0, output: 0, total: 0 };
+const audit_1 = require("./audit");
+const policy_1 = require("./policy");
+const sandbox_1 = require("./sandbox");
+const replay_1 = require("./replay");
+const VERSION = '1.8.0';
 const C = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -86,17 +90,158 @@ async function main() {
         await (0, setup_1.runSetup)();
         return;
     }
+    // ── v1.7.0: New standalone commands ──
+    // --init-policy: Generate default policy file
+    if (args['init-policy']) {
+        const policyPath = path.join(process.cwd(), '.codebot', 'policy.json');
+        const policyDir = path.dirname(policyPath);
+        if (!fs.existsSync(policyDir))
+            fs.mkdirSync(policyDir, { recursive: true });
+        if (fs.existsSync(policyPath)) {
+            console.log(c(`Policy file already exists at ${policyPath}`, 'yellow'));
+            console.log(c('Delete it first if you want to regenerate.', 'dim'));
+        }
+        else {
+            fs.writeFileSync(policyPath, (0, policy_1.generateDefaultPolicyFile)(), 'utf-8');
+            console.log(c(`Created default policy at ${policyPath}`, 'green'));
+        }
+        return;
+    }
+    // --verify-audit: Verify audit chain integrity
+    if (args['verify-audit']) {
+        const logger = new audit_1.AuditLogger();
+        const sessionId = typeof args['verify-audit'] === 'string' ? args['verify-audit'] : undefined;
+        if (sessionId) {
+            const entries = logger.query({ sessionId });
+            if (entries.length === 0) {
+                console.log(c(`No audit entries found for session ${sessionId}`, 'yellow'));
+                return;
+            }
+            const result = audit_1.AuditLogger.verify(entries);
+            if (result.valid) {
+                console.log(c(`Audit chain valid (${result.entriesChecked} entries checked)`, 'green'));
+            }
+            else {
+                console.log(c(`Audit chain INVALID at sequence ${result.firstInvalidAt}`, 'red'));
+                console.log(c(`Reason: ${result.reason}`, 'red'));
+            }
+        }
+        else {
+            // Verify all entries from today's log
+            const entries = logger.query();
+            if (entries.length === 0) {
+                console.log(c('No audit entries found.', 'yellow'));
+                return;
+            }
+            // Group by session and verify each
+            const sessions = new Map();
+            for (const e of entries) {
+                if (!sessions.has(e.sessionId))
+                    sessions.set(e.sessionId, []);
+                sessions.get(e.sessionId).push(e);
+            }
+            let allValid = true;
+            for (const [sid, sessionEntries] of sessions) {
+                const result = audit_1.AuditLogger.verify(sessionEntries);
+                const shortId = sid.substring(0, 12);
+                if (result.valid) {
+                    console.log(c(`  ${shortId}  ${result.entriesChecked} entries  valid`, 'green'));
+                }
+                else {
+                    console.log(c(`  ${shortId}  INVALID at seq ${result.firstInvalidAt}: ${result.reason}`, 'red'));
+                    allValid = false;
+                }
+            }
+            console.log(allValid
+                ? c(`\nAll ${sessions.size} session chains verified.`, 'green')
+                : c(`\nSome chains are invalid — possible tampering detected.`, 'red'));
+        }
+        return;
+    }
+    // --sandbox-info: Show sandbox status
+    if (args['sandbox-info']) {
+        const info = (0, sandbox_1.getSandboxInfo)();
+        console.log(c('Sandbox Status:', 'bold'));
+        console.log(`  Docker: ${info.available ? c('available', 'green') : c('not available', 'yellow')}`);
+        console.log(`  Image:  ${info.image}`);
+        console.log(`  CPU:    ${info.defaults.cpus} cores max`);
+        console.log(`  Memory: ${info.defaults.memoryMb}MB max`);
+        console.log(`  Network: ${info.defaults.network ? 'enabled' : 'disabled'} by default`);
+        return;
+    }
+    // --replay: Replay a saved session
+    if (args.replay) {
+        const replayId = typeof args.replay === 'string'
+            ? args.replay
+            : history_1.SessionManager.latest();
+        if (!replayId) {
+            console.log(c('No session to replay. Specify an ID or ensure a previous session exists.', 'yellow'));
+            return;
+        }
+        const data = (0, replay_1.loadSessionForReplay)(replayId);
+        if (!data) {
+            console.log(c(`Session ${replayId} not found or empty.`, 'red'));
+            return;
+        }
+        console.log(c(`\nReplaying session ${replayId.substring(0, 12)}...`, 'cyan'));
+        console.log(c(`  ${data.messages.length} messages (${data.userMessages.length} user, ${data.assistantMessages.length} assistant)`, 'dim'));
+        const replayProvider = new replay_1.ReplayProvider(data.assistantMessages);
+        const config = await resolveConfig(args);
+        const agent = new agent_1.Agent({
+            provider: replayProvider,
+            model: config.model,
+            providerName: 'replay',
+            autoApprove: true,
+        });
+        // Collect recorded tool results in order for sequential comparison
+        const recordedResults = Array.from(data.toolResults.values());
+        let resultIndex = 0;
+        let divergences = 0;
+        for (const userMsg of data.userMessages) {
+            console.log(c(`\n> ${truncate(userMsg.content, 100)}`, 'cyan'));
+            for await (const event of agent.run(userMsg.content)) {
+                if (event.type === 'tool_result' && event.toolResult && !event.toolResult.is_error) {
+                    const recorded = recordedResults[resultIndex++];
+                    if (recorded !== undefined) {
+                        const diff = (0, replay_1.compareOutputs)(recorded, event.toolResult.result);
+                        if (diff) {
+                            divergences++;
+                            console.log(c(`  ⚠ Divergence in ${event.toolResult.name || 'tool'}:`, 'yellow'));
+                            console.log(c(`    ${diff.split('\n').join('\n    ')}`, 'dim'));
+                        }
+                        else {
+                            console.log(c(`  ✓ ${event.toolResult.name || 'tool'} — output matches`, 'green'));
+                        }
+                    }
+                }
+                else if (event.type === 'text') {
+                    process.stdout.write(c('.', 'dim'));
+                }
+            }
+        }
+        console.log(c(`\n\nReplay complete.`, 'bold'));
+        if (divergences === 0) {
+            console.log(c('  All tool outputs match — session is reproducible.', 'green'));
+        }
+        else {
+            console.log(c(`  ${divergences} divergence(s) detected — environment may have changed.`, 'yellow'));
+        }
+        return;
+    }
     // First run: auto-launch setup if nothing is configured
     if ((0, setup_1.isFirstRun)() && process.stdin.isTTY && !args.message) {
         console.log(c('Welcome! No configuration found — launching setup...', 'cyan'));
         await (0, setup_1.runSetup)();
-        // If setup saved a config, continue to main flow
-        // Otherwise exit
         if ((0, setup_1.isFirstRun)())
             return;
     }
     const config = await resolveConfig(args);
     const provider = createProvider(config);
+    // Deterministic mode: set temperature=0
+    if (args.deterministic) {
+        provider.temperature = 0;
+        console.log(c('  Deterministic mode: temperature=0', 'dim'));
+    }
     // Session management
     let resumeId;
     if (args.continue) {
@@ -118,6 +263,7 @@ async function main() {
     const agent = new agent_1.Agent({
         provider,
         model: config.model,
+        providerName: config.provider,
         maxIterations: config.maxIterations,
         autoApprove: config.autoApprove,
         onMessage: (msg) => session.save(msg),
@@ -133,6 +279,7 @@ async function main() {
     // Non-interactive: single message from CLI args
     if (typeof args.message === 'string') {
         await runOnce(agent, args.message);
+        printSessionSummary(agent);
         return;
     }
     // Non-interactive: piped stdin
@@ -140,6 +287,7 @@ async function main() {
         const input = await readStdin();
         if (input.trim()) {
             await runOnce(agent, input.trim());
+            printSessionSummary(agent);
         }
         return;
     }
@@ -151,6 +299,22 @@ async function main() {
     // Cleanup scheduler on exit
     scheduler.stop();
 }
+/** Print session summary with tokens, cost, tool calls, files modified */
+function printSessionSummary(agent) {
+    const tracker = agent.getTokenTracker();
+    tracker.saveUsage();
+    const summary = tracker.getSummary();
+    const duration = (new Date(summary.endTime).getTime() - new Date(summary.startTime).getTime()) / 1000;
+    const mins = Math.floor(duration / 60);
+    const secs = Math.floor(duration % 60);
+    console.log(c('\n── Session Summary ──', 'dim'));
+    console.log(`  Duration:  ${mins}m ${secs}s`);
+    console.log(`  Model:     ${summary.model} via ${summary.provider}`);
+    console.log(`  Tokens:    ${summary.totalInputTokens.toLocaleString()} in / ${summary.totalOutputTokens.toLocaleString()} out (${tracker.formatCost()})`);
+    console.log(`  Requests:  ${summary.requestCount}`);
+    console.log(`  Tools:     ${summary.toolCalls} calls`);
+    console.log(`  Files:     ${summary.filesModified} modified`);
+}
 function createProvider(config) {
     if (config.provider === 'anthropic') {
         return new anthropic_1.AnthropicProvider({
@@ -159,7 +323,6 @@ function createProvider(config) {
             model: config.model,
         });
     }
-    // All other providers use OpenAI-compatible format
     return new openai_1.OpenAIProvider({
         baseUrl: config.baseUrl,
         apiKey: config.apiKey,
@@ -186,7 +349,7 @@ async function repl(agent, config, session) {
         }
         try {
             for await (const event of agent.run(input)) {
-                renderEvent(event);
+                renderEvent(event, agent);
             }
         }
         catch (err) {
@@ -197,18 +360,19 @@ async function repl(agent, config, session) {
         rl.prompt();
     });
     rl.on('close', () => {
+        printSessionSummary(agent);
         console.log(c('\nBye!', 'dim'));
         process.exit(0);
     });
 }
 async function runOnce(agent, message) {
     for await (const event of agent.run(message)) {
-        renderEvent(event);
+        renderEvent(event, agent);
     }
     console.log();
 }
 let isThinking = false;
-function renderEvent(event) {
+function renderEvent(event, agent) {
     switch (event.type) {
         case 'thinking':
             if (!isThinking) {
@@ -248,20 +412,15 @@ function renderEvent(event) {
             }
             break;
         case 'usage':
-            if (event.usage) {
-                if (event.usage.inputTokens)
-                    sessionTokens.input += event.usage.inputTokens;
-                if (event.usage.outputTokens)
-                    sessionTokens.output += event.usage.outputTokens;
-                if (event.usage.totalTokens)
-                    sessionTokens.total += event.usage.totalTokens;
+            if (event.usage && agent) {
+                const tracker = agent.getTokenTracker();
                 const parts = [];
                 if (event.usage.inputTokens)
                     parts.push(`in: ${event.usage.inputTokens}`);
                 if (event.usage.outputTokens)
                     parts.push(`out: ${event.usage.outputTokens}`);
                 if (parts.length > 0) {
-                    console.log(c(`  [${parts.join(', ')} tokens]`, 'dim'));
+                    console.log(c(`  [${parts.join(', ')} tokens | ${tracker.formatCost()}]`, 'dim'));
                 }
             }
             break;
@@ -306,7 +465,10 @@ function handleSlashCommand(input, agent, config) {
   /auto      Toggle autonomous mode
   /routines  List scheduled routines
   /undo      Undo last file edit (/undo [path])
-  /usage     Show token usage for this session
+  /usage     Show token usage & cost for this session
+  /cost      Show running cost
+  /policy    Show current security policy
+  /audit     Verify audit chain for this session
   /config    Show current config
   /quit      Exit`);
             break;
@@ -365,10 +527,41 @@ function handleSlashCommand(input, agent, config) {
             break;
         }
         case '/usage': {
-            console.log(c('\nToken Usage (this session):', 'bold'));
-            console.log(`  Input:  ${sessionTokens.input.toLocaleString()} tokens`);
-            console.log(`  Output: ${sessionTokens.output.toLocaleString()} tokens`);
-            console.log(`  Total:  ${(sessionTokens.input + sessionTokens.output).toLocaleString()} tokens`);
+            const tracker = agent.getTokenTracker();
+            const summary = tracker.getSummary();
+            console.log(c('\nSession Usage:', 'bold'));
+            console.log(`  Input:    ${summary.totalInputTokens.toLocaleString()} tokens`);
+            console.log(`  Output:   ${summary.totalOutputTokens.toLocaleString()} tokens`);
+            console.log(`  Cost:     ${tracker.formatCost()}`);
+            console.log(`  Requests: ${summary.requestCount}`);
+            console.log(`  Tools:    ${summary.toolCalls} calls`);
+            console.log(`  Files:    ${summary.filesModified} modified`);
+            break;
+        }
+        case '/cost': {
+            const tracker = agent.getTokenTracker();
+            console.log(c(`  ${tracker.formatStatusLine()}`, 'dim'));
+            break;
+        }
+        case '/policy': {
+            const policy = agent.getPolicyEnforcer().getPolicy();
+            console.log(c('\nCurrent Policy:', 'bold'));
+            console.log(JSON.stringify(policy, null, 2));
+            break;
+        }
+        case '/audit': {
+            const auditLogger = agent.getAuditLogger();
+            const result = auditLogger.verifySession();
+            if (result.entriesChecked === 0) {
+                console.log(c('No audit entries yet.', 'dim'));
+            }
+            else if (result.valid) {
+                console.log(c(`Audit chain valid (${result.entriesChecked} entries)`, 'green'));
+            }
+            else {
+                console.log(c(`Audit chain INVALID at sequence ${result.firstInvalidAt}`, 'red'));
+                console.log(c(`  ${result.reason}`, 'red'));
+            }
             break;
         }
         case '/routines': {
@@ -409,7 +602,6 @@ function showModels() {
     }
 }
 async function resolveConfig(args) {
-    // Load saved config (CLI args override saved config)
     const saved = (0, setup_1.loadConfig)();
     const model = args.model || process.env.CODEBOT_MODEL || saved.model || 'qwen2.5-coder:32b';
     const detected = (0, registry_1.detectProvider)(model);
@@ -421,7 +613,6 @@ async function resolveConfig(args) {
         maxIterations: parseInt(args['max-iterations'] || String(saved.maxIterations || 50), 10),
         autoApprove: !!args['auto-approve'] || !!args.autonomous || !!args.auto || !!saved.autoApprove,
     };
-    // Auto-resolve base URL and API key from provider
     if (!config.baseUrl || !config.apiKey) {
         const defaults = registry_1.PROVIDER_DEFAULTS[config.provider];
         if (defaults) {
@@ -431,14 +622,12 @@ async function resolveConfig(args) {
                 config.apiKey = process.env[defaults.envKey] || process.env.CODEBOT_API_KEY || '';
         }
     }
-    // Fallback: try saved config API key, then generic env vars
     if (!config.apiKey && saved.apiKey) {
         config.apiKey = saved.apiKey;
     }
     if (!config.apiKey) {
         config.apiKey = process.env.CODEBOT_API_KEY || process.env.OPENAI_API_KEY || '';
     }
-    // If still no base URL, auto-detect local provider
     if (!config.baseUrl) {
         config.baseUrl = await autoDetectProvider();
     }
@@ -494,6 +683,40 @@ function parseArgs(argv) {
             result.setup = true;
             continue;
         }
+        if (arg === '--init-policy') {
+            result['init-policy'] = true;
+            continue;
+        }
+        if (arg === '--sandbox-info') {
+            result['sandbox-info'] = true;
+            continue;
+        }
+        if (arg === '--verify-audit') {
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                result['verify-audit'] = next;
+                i++;
+            }
+            else {
+                result['verify-audit'] = true;
+            }
+            continue;
+        }
+        if (arg === '--replay') {
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                result['replay'] = next;
+                i++;
+            }
+            else {
+                result['replay'] = true; // replay latest
+            }
+            continue;
+        }
+        if (arg === '--deterministic') {
+            result['deterministic'] = true;
+            continue;
+        }
         if (arg.startsWith('--')) {
             const key = arg.slice(2);
             const next = argv[i + 1];
@@ -540,9 +763,19 @@ ${c('Options:', 'bold')}
   --resume <id>        Resume a previous session by ID
   --continue, -c       Resume the most recent session
   --max-iterations <n> Max agent loop iterations (default: 50)
+  --sandbox <mode>     Execution sandbox: docker, host, auto (default: auto)
   -h, --help           Show this help
   -v, --version        Show version
 
+${c('Security & Policy:', 'bold')}
+  --init-policy        Generate default .codebot/policy.json
+  --verify-audit [id]  Verify audit log hash chain integrity
+  --sandbox-info       Show Docker sandbox status
+
+${c('Debugging & Replay:', 'bold')}
+  --replay [id]        Replay a session, re-execute tools, compare outputs
+  --deterministic      Set temperature=0 for reproducible outputs
+
 ${c('Supported Providers:', 'bold')}
   Local:      Ollama, LM Studio, vLLM (auto-detected)
   Anthropic:  Claude Opus/Sonnet/Haiku (ANTHROPIC_API_KEY)
@@ -560,6 +793,8 @@ ${c('Examples:', 'bold')}
   codebot --model deepseek-chat            Uses DeepSeek API
   codebot --model qwen2.5-coder:32b        Uses local Ollama
   codebot --autonomous "refactor src/"     Full auto, no prompts
+  codebot --init-policy                    Create security policy
+  codebot --verify-audit                   Check audit integrity
 
 ${c('Interactive Commands:', 'bold')}
   /help      Show commands
@@ -569,6 +804,10 @@ ${c('Interactive Commands:', 'bold')}
   /auto      Toggle autonomous mode
   /clear     Clear conversation
   /compact   Force context compaction
+  /usage     Show token usage & cost
+  /cost      Show running cost
+  /policy    Show security policy
+  /audit     Verify session audit chain
   /config    Show configuration
   /quit      Exit`);
 }

package/dist/history.d.ts

@@ -1,4 +1,5 @@
 import { Message } from './types';
+import { IntegrityResult } from './integrity';
 export interface SessionMeta {
     id: string;
     model: string;
@@ -11,14 +12,17 @@ export declare class SessionManager {
     private sessionId;
     private filePath;
     private model;
+    private integrityKey;
     constructor(model: string, sessionId?: string);
     getId(): string;
-    /** Append a message to the session file */
+    /** Append a message to the session file (HMAC signed) */
     save(message: Message): void;
-    /** Save all messages (atomic overwrite via temp file + rename) */
+    /** Save all messages (atomic overwrite, HMAC signed) */
     saveAll(messages: Message[]): void;
-    /** Load messages from a session file (skips malformed lines) */
+    /** Load messages from a session file (verifies HMAC, drops tampered) */
     load(): Message[];
+    /** Verify integrity of all messages in this session. */
+    verifyIntegrity(): IntegrityResult;
     /** List recent sessions */
     static list(limit?: number): SessionMeta[];
     /** Get the most recent session ID */