@cjhyy/code-shell 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/{chunk-WHRTARDJ.cjs → chunk-YAFCN7ZW.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
-var _chunkDICG4AB7cjs = require('./chunk-DICG4AB7.cjs');
+var _chunkGZBD6QRScjs = require('./chunk-GZBD6QRS.cjs');
 
 
 
@@ -8,12 +8,15 @@ var _chunkDICG4AB7cjs = require('./chunk-DICG4AB7.cjs');
 var _chunkEL2RL5DGcjs = require('./chunk-EL2RL5DG.cjs');
 
 
+var _chunkJHNCK7JPcjs = require('./chunk-JHNCK7JP.cjs');
+
+
 var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
 
 // src/llm/providers/openai.ts
 _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
 var _openai = require('openai'); var _openai2 = _interopRequireDefault(_openai);
-var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
+var OpenAIClient = (_class = class extends _chunkGZBD6QRScjs.LLMClientBase {
   __init() {this._client = null}
   constructor(config) {
     super(config);_class.prototype.__init.call(this);;
@@ -34,10 +37,28 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
     return this.withRetry(async () => {
       const messages = this.buildMessages(options.systemPrompt, options.messages);
       const tools = _optionalChain([options, 'access', _ => _.tools, 'optionalAccess', _2 => _2.length]) ? this.convertTools(options.tools) : void 0;
-      if (options.stream && options.onChunk) {
-        return this.streamMessage(options, messages, tools);
+      const span = _chunkJHNCK7JPcjs.logger.span("llm.request", {
+        cat: "llm",
+        provider: this.provider,
+        model: this.model,
+        stream: !!(options.stream && options.onChunk),
+        messageCount: messages.length,
+        toolCount: _nullishCoalesce(_optionalChain([tools, 'optionalAccess', _3 => _3.length]), () => ( 0))
+      });
+      try {
+        const response = options.stream && options.onChunk ? await this.streamMessage(options, messages, tools) : await this.nonStreamMessage(options, messages, tools);
+        span.end({
+          stopReason: response.stopReason,
+          promptTokens: _optionalChain([response, 'access', _4 => _4.usage, 'optionalAccess', _5 => _5.promptTokens]),
+          completionTokens: _optionalChain([response, 'access', _6 => _6.usage, 'optionalAccess', _7 => _7.completionTokens]),
+          cacheReadTokens: _optionalChain([response, 'access', _8 => _8.usage, 'optionalAccess', _9 => _9.cacheReadTokens]),
+          cacheCreationTokens: _optionalChain([response, 'access', _10 => _10.usage, 'optionalAccess', _11 => _11.cacheCreationTokens])
+        });
+        return response;
+      } catch (err) {
+        span.fail(err);
+        throw err;
       }
-      return this.nonStreamMessage(options, messages, tools);
     });
   }
   async nonStreamMessage(options, messages, tools) {
@@ -55,9 +76,9 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
       const choice = response.choices[0];
       if (!choice) throw new (0, _chunkEL2RL5DGcjs.LLMError)("No response from OpenAI", "openai");
       const usage = {
-        promptTokens: _nullishCoalesce(_optionalChain([response, 'access', _3 => _3.usage, 'optionalAccess', _4 => _4.prompt_tokens]), () => ( 0)),
-        completionTokens: _nullishCoalesce(_optionalChain([response, 'access', _5 => _5.usage, 'optionalAccess', _6 => _6.completion_tokens]), () => ( 0)),
-        totalTokens: _nullishCoalesce(_optionalChain([response, 'access', _7 => _7.usage, 'optionalAccess', _8 => _8.total_tokens]), () => ( 0))
+        promptTokens: _nullishCoalesce(_optionalChain([response, 'access', _12 => _12.usage, 'optionalAccess', _13 => _13.prompt_tokens]), () => ( 0)),
+        completionTokens: _nullishCoalesce(_optionalChain([response, 'access', _14 => _14.usage, 'optionalAccess', _15 => _15.completion_tokens]), () => ( 0)),
+        totalTokens: _nullishCoalesce(_optionalChain([response, 'access', _16 => _16.usage, 'optionalAccess', _17 => _17.total_tokens]), () => ( 0))
       };
       this.recordUsage(usage);
       return this.processChoice(choice, usage);
@@ -81,36 +102,64 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
         { signal: options.signal }
       );
       let text = "";
+      let reasoningContent = "";
       const toolCallsMap = /* @__PURE__ */ new Map();
       let streamUsage;
+      const streamStartedAt = Date.now();
+      let firstByteLogged = false;
       for await (const chunk of stream) {
         if (chunk.usage) {
           streamUsage = chunk.usage;
         }
-        const delta = _optionalChain([chunk, 'access', _9 => _9.choices, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.delta]);
+        const delta = _optionalChain([chunk, 'access', _18 => _18.choices, 'access', _19 => _19[0], 'optionalAccess', _20 => _20.delta]);
         if (!delta) continue;
+        const reasoningDelta = delta.reasoning_content;
+        if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
+          reasoningContent += reasoningDelta;
+        }
         if (delta.content) {
+          if (!firstByteLogged) {
+            firstByteLogged = true;
+            _chunkJHNCK7JPcjs.logger.debug("llm.first_byte", {
+              cat: "llm",
+              provider: this.provider,
+              model: this.model,
+              ttft_ms: Date.now() - streamStartedAt
+            });
+          }
           text += delta.content;
-          _optionalChain([options, 'access', _12 => _12.onChunk, 'optionalCall', _13 => _13({ type: "text", text: delta.content })]);
+          _optionalChain([options, 'access', _21 => _21.onChunk, 'optionalCall', _22 => _22({ type: "text", text: delta.content })]);
         }
         if (delta.tool_calls) {
           for (const tc of delta.tool_calls) {
             const idx = tc.index;
             if (!toolCallsMap.has(idx)) {
-              toolCallsMap.set(idx, { id: _nullishCoalesce(tc.id, () => ( "")), name: _nullishCoalesce(_optionalChain([tc, 'access', _14 => _14.function, 'optionalAccess', _15 => _15.name]), () => ( "")), args: "" });
-              _optionalChain([options, 'access', _16 => _16.onChunk, 'optionalCall', _17 => _17({
+              toolCallsMap.set(idx, { id: _nullishCoalesce(tc.id, () => ( "")), name: _nullishCoalesce(_optionalChain([tc, 'access', _23 => _23.function, 'optionalAccess', _24 => _24.name]), () => ( "")), args: "" });
+              _optionalChain([options, 'access', _25 => _25.onChunk, 'optionalCall', _26 => _26({
                 type: "tool_use_start",
-                toolCall: { id: tc.id, toolName: _optionalChain([tc, 'access', _18 => _18.function, 'optionalAccess', _19 => _19.name]) }
+                toolCall: { id: tc.id, toolName: _optionalChain([tc, 'access', _27 => _27.function, 'optionalAccess', _28 => _28.name]) }
               })]);
             }
             const existing = toolCallsMap.get(idx);
             if (tc.id) existing.id = tc.id;
-            if (_optionalChain([tc, 'access', _20 => _20.function, 'optionalAccess', _21 => _21.name])) existing.name = tc.function.name;
-            if (_optionalChain([tc, 'access', _22 => _22.function, 'optionalAccess', _23 => _23.arguments])) existing.args += tc.function.arguments;
+            if (_optionalChain([tc, 'access', _29 => _29.function, 'optionalAccess', _30 => _30.name])) existing.name = tc.function.name;
+            if (_optionalChain([tc, 'access', _31 => _31.function, 'optionalAccess', _32 => _32.arguments])) {
+              existing.args += tc.function.arguments;
+              if (existing.id) {
+                try {
+                  const parsed = JSON.parse(existing.args || "{}");
+                  _optionalChain([options, 'access', _33 => _33.onChunk, 'optionalCall', _34 => _34({
+                    type: "tool_use_delta",
+                    toolCall: { id: existing.id, toolName: existing.name, args: parsed }
+                  })]);
+                } catch (e) {
+                }
+              }
+            }
           }
         }
-        if (_optionalChain([chunk, 'access', _24 => _24.choices, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.finish_reason])) {
-          _optionalChain([options, 'access', _27 => _27.onChunk, 'optionalCall', _28 => _28({ type: "stop", stopReason: chunk.choices[0].finish_reason })]);
+        if (_optionalChain([chunk, 'access', _35 => _35.choices, 'access', _36 => _36[0], 'optionalAccess', _37 => _37.finish_reason])) {
+          _optionalChain([options, 'access', _38 => _38.onChunk, 'optionalCall', _39 => _39({ type: "stop", stopReason: chunk.choices[0].finish_reason })]);
         }
       }
       const toolCalls = [];
@@ -118,17 +167,23 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
         let args = {};
         try {
           args = JSON.parse(tc.args || "{}");
-        } catch (e) {
+        } catch (e2) {
         }
         toolCalls.push({ id: tc.id, toolName: tc.name, args });
       }
       const usage = {
-        promptTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _29 => _29.prompt_tokens]), () => ( 0)),
-        completionTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _30 => _30.completion_tokens]), () => ( 0)),
-        totalTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _31 => _31.total_tokens]), () => ( 0))
+        promptTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _40 => _40.prompt_tokens]), () => ( 0)),
+        completionTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _41 => _41.completion_tokens]), () => ( 0)),
+        totalTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _42 => _42.total_tokens]), () => ( 0))
       };
       this.recordUsage(usage);
-      return { text, toolCalls, usage, stopReason: "stop" };
+      return {
+        text,
+        toolCalls,
+        usage,
+        stopReason: "stop",
+        ...reasoningContent ? { reasoningContent } : {}
+      };
     } catch (err) {
       this.handleApiError(err);
       throw err;
@@ -142,7 +197,7 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
         let args = {};
         try {
           args = JSON.parse(tc.function.arguments || "{}");
-        } catch (e2) {
+        } catch (e3) {
         }
         toolCalls.push({
           id: tc.id,
@@ -151,17 +206,27 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
         });
       }
     }
-    return { text, toolCalls, usage, stopReason: _nullishCoalesce(choice.finish_reason, () => ( void 0)) };
+    const reasoningContent = extractReasoningContent(
+      choice.message
+    );
+    return {
+      text,
+      toolCalls,
+      usage,
+      stopReason: _nullishCoalesce(choice.finish_reason, () => ( void 0)),
+      ...reasoningContent ? { reasoningContent } : {}
+    };
   }
   buildMessages(systemPrompt, messages) {
-    const result = [
-      { role: "system", content: systemPrompt }
-    ];
+    const result = [{ role: "system", content: systemPrompt }];
+    const needsReasoningBackfill = isDeepSeekThinkingModel(this.model);
     for (const msg of messages) {
       if (msg.role === "system") continue;
       if (msg.role === "assistant") {
+        const param = { role: "assistant" };
+        let reasoningContent;
         if (typeof msg.content === "string") {
-          result.push({ role: "assistant", content: msg.content });
+          param.content = msg.content;
         } else {
           const textParts = [];
           const toolCalls = [];
@@ -177,13 +242,23 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
                   arguments: JSON.stringify(_nullishCoalesce(block.input, () => ( {})))
                 }
               });
+            } else if (block.type === "reasoning" && block.reasoningContent) {
+              reasoningContent = block.reasoningContent;
+            }
+            if (!reasoningContent && block.reasoningContent) {
+              reasoningContent = block.reasoningContent;
             }
           }
-          const param = { role: "assistant" };
           if (textParts.length) param.content = textParts.join("\n");
           if (toolCalls.length) param.tool_calls = toolCalls;
-          result.push(param);
         }
+        if (!reasoningContent && needsReasoningBackfill) {
+          reasoningContent = "";
+        }
+        if (reasoningContent !== void 0) {
+          param.reasoning_content = reasoningContent;
+        }
+        result.push(param);
       } else if (msg.role === "tool") {
         result.push({
           role: "tool",
@@ -252,6 +327,13 @@ var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
     throw err;
   }
 }, _class);
+function extractReasoningContent(msg) {
+  const candidate = _nullishCoalesce(msg.reasoning_content, () => ( msg.reasoning));
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function isDeepSeekThinkingModel(model) {
+  return /^deepseek-v4(?:-|$)/i.test(model);
+}
 
 
 

package/dist/{chunk-LRAY5IYC.cjs → chunk-YD7XTI7T.cjs}

@@ -1,13 +1,72 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
 
-var _chunkHD7MT5XUcjs = require('./chunk-HD7MT5XU.cjs');
-
-
-
 
 var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
 
+// src/context/token-counter.ts
+function estimateStringTokens(text) {
+  if (!text) return 0;
+  const cjkChars = (_nullishCoalesce(text.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g), () => ( []))).length;
+  const cjkRatio = cjkChars / text.length;
+  if (cjkRatio > 0.3) {
+    const cjkTokens = cjkChars / RATIOS.cjk;
+    const otherChars = text.length - cjkChars;
+    const otherTokens = otherChars / RATIOS.english;
+    return Math.ceil(cjkTokens + otherTokens);
+  }
+  const codeIndicators = ["{", "}", "(", ")", ";", "=>", "import ", "function ", "class ", "const "];
+  const codeScore = codeIndicators.reduce((s, ind) => s + (text.includes(ind) ? 1 : 0), 0);
+  if (codeScore >= 3) return Math.ceil(text.length / RATIOS.code);
+  if (text.startsWith("{") || text.startsWith("[")) return Math.ceil(text.length / RATIOS.json);
+  return Math.ceil(text.length / RATIOS.english);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += 4;
+    if (typeof msg.content === "string") {
+      total += estimateStringTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        total += estimateBlockTokens(block);
+      }
+    }
+  }
+  return total;
+}
+function estimateBlockTokens(block) {
+  let tokens = 2;
+  if (block.text) tokens += estimateStringTokens(block.text);
+  if (block.content && typeof block.content === "string") {
+    tokens += estimateStringTokens(block.content);
+  }
+  if (block.input) {
+    tokens += estimateStringTokens(JSON.stringify(block.input));
+  }
+  if (block.name) tokens += estimateStringTokens(block.name);
+  return tokens;
+}
+var RATIOS;
+var init_token_counter = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+  "src/context/token-counter.ts"() {
+    "use strict";
+    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    RATIOS = {
+      english: 4,
+      // ~4 chars per token for English prose
+      code: 3.2,
+      // ~3.2 chars per token for code (more tokens per char)
+      json: 3.5,
+      // JSON structures
+      mixed: 3.6,
+      // Mixed content (typical for tool results)
+      cjk: 1.5
+      // CJK characters: ~1.5 chars per token
+    };
+  }
+});
+
 // src/context/compaction.ts
 var compaction_exports = {};
 _chunkIJSHQGMPcjs.__export.call(void 0, compaction_exports, {
@@ -25,7 +84,7 @@ _chunkIJSHQGMPcjs.__export.call(void 0, compaction_exports, {
   windowCompact: () => windowCompact
 });
 function estimateTokens(messages) {
-  return Math.ceil(_chunkHD7MT5XUcjs.estimateMessagesTokens.call(void 0, messages) * (4 / 3));
+  return Math.ceil(estimateMessagesTokens(messages) * (4 / 3));
 }
 function adjustIndexToPreserveAPIInvariants(messages, startIndex) {
   let adjusted = startIndex;
@@ -269,7 +328,7 @@ function extractReferencedFilePaths(messages) {
 var init_compaction = _chunkIJSHQGMPcjs.__esm.call(void 0, {
   "src/context/compaction.ts"() {
     _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
-    _chunkHD7MT5XUcjs.init_token_counter.call(void 0, );
+    init_token_counter();
   }
 });
 

package/dist/{chunk-S74VVJBF.js → chunk-ZLPJJZUW.js}

@@ -271,13 +271,35 @@ var SessionManager = class {
       if (!existsSync2(stateFile)) continue;
       try {
         const state = JSON.parse(readFileSync2(stateFile, "utf-8"));
-        sessions.push(state);
+        const transcriptFile = join(this.sessionsDir, dir, "transcript.jsonl");
+        const preview = readFirstUserMessage(transcriptFile);
+        sessions.push({ ...state, preview });
       } catch {
       }
     }
     return sessions.sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
   }
 };
+function readFirstUserMessage(transcriptFile) {
+  if (!existsSync2(transcriptFile)) return void 0;
+  const raw = readFileSync2(transcriptFile, "utf-8");
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event.type !== "message") continue;
+    if (event.data?.role !== "user") continue;
+    const content = event.data.content;
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((b) => b.type === "text")?.text ?? "" : "";
+    if (!text.trim()) continue;
+    return text.replace(/\s+/g, " ").trim();
+  }
+  return void 0;
+}
 
 export {
   Transcript,

package/dist/chunk-ZRVPCXI7.js

@@ -0,0 +1,202 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/logging/logger.ts
+init_esm_shims();
+import {
+  appendFileSync,
+  mkdirSync,
+  existsSync,
+  readdirSync,
+  unlinkSync,
+  readFileSync
+} from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOGS_DIR = join(homedir(), ".code-shell", "logs");
+var MAX_LOG_FILES = 7;
+var MAX_IN_MEMORY_ERRORS = 100;
+function isLocalDev() {
+  if (process.env.CODE_SHELL_DEV === "1") return true;
+  if (process.argv.includes("--debug") || process.argv.includes("-d")) return true;
+  if (process.argv.some((a) => a.startsWith("--debug="))) return true;
+  if (process.env.NODE_ENV === "test" || process.env.BUN_TEST === "1") return false;
+  if (process.argv.some((a) => a.includes("/tests/") || a.endsWith(".test.ts"))) return false;
+  const entry = process.argv[1] ?? "";
+  if (entry.includes(`${"/"}src${"/"}`)) return true;
+  return false;
+}
+function resolveDefaultLevel() {
+  const raw = process.env.CODE_SHELL_LOG_LEVEL?.toLowerCase().trim();
+  if (raw && Object.hasOwn(LEVEL_ORDER, raw)) return raw;
+  return isLocalDev() ? "debug" : "info";
+}
+function resolveCategoryFilter() {
+  const cliArg = process.argv.find((a) => a.startsWith("--debug="));
+  let raw;
+  if (cliArg) raw = cliArg.slice("--debug=".length);
+  else {
+    const env = process.env.CODE_SHELL_DEBUG;
+    if (env && env !== "1" && env !== "true") raw = env;
+  }
+  if (!raw) return null;
+  const set = new Set(
+    raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
+  );
+  return set.size > 0 ? set : null;
+}
+var _currentSid = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+function setCurrentSid(sid) {
+  _currentSid = sid;
+}
+function getCurrentSid() {
+  return _currentSid;
+}
+var inMemoryErrors = [];
+var errorLogSink = null;
+var Logger = class _Logger {
+  constructor(context = {}) {
+    this.context = context;
+    this.enabled = process.env.CODE_SHELL_LOG !== "0";
+    this.minLevel = resolveDefaultLevel();
+    this.categoryFilter = resolveCategoryFilter();
+    this.stderrEcho = process.env.CODE_SHELL_DEBUG === "1" || process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e");
+  }
+  enabled;
+  minLevel;
+  categoryFilter;
+  stderrEcho;
+  dirReady = false;
+  child(extra) {
+    return new _Logger({ ...this.context, ...extra });
+  }
+  /**
+   * Set the session id stamped on every subsequent log entry written by
+   * any logger in the process. Called by Engine once a run's
+   * authoritative session id is known.
+   */
+  setSid(sid) {
+    setCurrentSid(sid);
+  }
+  getSid() {
+    return getCurrentSid();
+  }
+  debug(msg, data) {
+    this.write("debug", msg, data);
+  }
+  info(msg, data) {
+    this.write("info", msg, data);
+  }
+  warn(msg, data) {
+    this.write("warn", msg, data);
+  }
+  error(msgOrErr, data) {
+    let msg;
+    let entryData;
+    let errObj;
+    if (typeof msgOrErr === "string") {
+      msg = msgOrErr;
+      if (data instanceof Error) {
+        errObj = data;
+        entryData = { error: data.message, stack: data.stack };
+      } else {
+        entryData = data;
+      }
+    } else if (msgOrErr instanceof Error) {
+      msg = msgOrErr.message;
+      errObj = msgOrErr;
+      entryData = { stack: msgOrErr.stack };
+    } else {
+      msg = String(msgOrErr);
+    }
+    this.recordError(msg, entryData);
+    this.write("error", msg, entryData);
+    if (errObj) errorLogSink?.logError(errObj);
+  }
+  recordError(msg, data) {
+    if (inMemoryErrors.length >= MAX_IN_MEMORY_ERRORS) inMemoryErrors.shift();
+    inMemoryErrors.push({ msg, t: (/* @__PURE__ */ new Date()).toISOString(), data });
+  }
+  write(level, msg, data) {
+    if (!this.enabled) return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.minLevel]) return;
+    const cat = data?.cat ?? this.context.cat;
+    if (level === "debug" && this.categoryFilter) {
+      if (!cat || !this.categoryFilter.has(cat.toLowerCase())) return;
+    }
+    const t = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { t, l: level, msg, ...this.context };
+    if (cat && !entry.cat) entry.cat = cat;
+    if (entry.sid === void 0) entry.sid = _currentSid;
+    if (data) entry.d = data;
+    const line = JSON.stringify(entry) + "\n";
+    if (this.stderrEcho) {
+      process.stderr.write(line);
+      return;
+    }
+    try {
+      if (!this.dirReady) {
+        if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
+        this.dirReady = true;
+      }
+      const dateStr = t.slice(0, 10);
+      appendFileSync(join(LOGS_DIR, `${dateStr}.log`), line, "utf-8");
+    } catch {
+    }
+  }
+  getMinLevel() {
+    return this.minLevel;
+  }
+  isCategoryActive(cat) {
+    return !this.categoryFilter || this.categoryFilter.has(cat.toLowerCase());
+  }
+  /**
+   * Open a span: writes a `<name>.begin` debug entry now and returns a handle
+   * whose `end()` writes `<name>.end` with `duration_ms` populated. Use for
+   * any "I want begin → end + how long" pattern (tool exec, LLM request,
+   * permission ask, etc.) so the begin/end pair is grouped under one cat
+   * and the duration is computed once instead of by hand from timestamps.
+   */
+  span(name, data) {
+    const startedAt = Date.now();
+    this.write("debug", `${name}.begin`, data);
+    return {
+      end: (extra) => {
+        const duration_ms = Date.now() - startedAt;
+        this.write("info", `${name}.end`, { ...data, ...extra, duration_ms });
+      },
+      fail: (err, extra) => {
+        const duration_ms = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        this.write("error", `${name}.fail`, { ...data, ...extra, duration_ms, error: message });
+      }
+    };
+  }
+};
+var logger = new Logger();
+function rotateLogs() {
+  try {
+    if (!existsSync(LOGS_DIR)) return;
+    const files = readdirSync(LOGS_DIR).filter((f) => f.endsWith(".log")).sort();
+    if (files.length <= MAX_LOG_FILES) return;
+    for (const f of files.slice(0, files.length - MAX_LOG_FILES)) {
+      try {
+        unlinkSync(join(LOGS_DIR, f));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+export {
+  logger,
+  rotateLogs
+};

package/dist/cli/commands/builtin/advanced-commands.d.ts

@@ -1,5 +1,5 @@
 /**
- * Advanced slash commands — /vim, /voice, /bridge, /plugins, /lsp
+ * Advanced / reserved slash commands
  */
 import type { SlashCommand } from "../registry.js";
 export declare const advancedCommands: SlashCommand[];

package/dist/cli/commands/builtin/extra-commands.d.ts

@@ -1,6 +1,6 @@
 /**
- * Extra slash commands — /dream, /login, /logout, /mcp, /context, /stats,
- * /summary, /skills, /agents, /theme, /output-style
+ * Extra slash commands — /login, /logout, /mcp (config & auth);
+ * /skills, /log (read-only inspection); /models (interactive panel).
  */
 import type { SlashCommand } from "../registry.js";
 export declare const extraCommands: SlashCommand[];

package/dist/cli/commands/builtin/more-commands.d.ts

@@ -1,7 +1,5 @@
 /**
- * Additional slash commands to match restored-src parity:
- * /fast, /rewind, /usage, /files, /release-notes, /security-review,
- * /env, /brief, /feedback, /tag
+ * Additional slash commands — /files, /release-notes, /security-review, /feedback
  */
 import type { SlashCommand } from "../registry.js";
 export declare const moreCommands: SlashCommand[];

package/dist/cli/commands/registry.d.ts

@@ -37,6 +37,14 @@ export interface CommandContext {
     chatLog: unknown[];
     /** Load restored chat entries into the UI (used by /resume). */
     loadChatEntries?: (entries: RestoredChatEntry[]) => void;
+    /** Open the Ink onboarding wizard (used by /login). */
+    startOnboarding?: () => void;
+    /** Open the Ink model selector (used by /model with no args). */
+    openModelSelector?: () => void;
+    /** Open the Ink session picker (used by /resume with no args). */
+    openSessionPicker?: () => void;
+    /** Open the Ink model management panel (used by /models). */
+    openModelManager?: () => void;
 }
 export type CommandGroup = "core" | "git" | "context" | "config" | "advanced";
 export interface SlashCommand {

package/dist/cli/cost-tracker.d.ts

@@ -55,3 +55,9 @@ export interface SessionCostState {
     estimatedCost: number;
 }
 export declare const costTracker: CostTracker;
+/**
+ * Wire the LLM base-class usage hook into the singleton cost tracker.
+ * Called once from main.ts so every LLM call (REPL, run, arena, sub-agents)
+ * records into a single tracker without each call site having to remember.
+ */
+export declare function installCostTracking(): Promise<void>;