@sna-sdk/core 0.9.9 → 0.9.10

package/dist/core/providers/claude-code.d.ts

@@ -1,9 +1,40 @@
 import { AgentProvider, SpawnOptions, AgentProcess } from './types.js';
 
+/**
+ * Parse `command -v claude` output to extract the executable path.
+ * Handles: direct paths, alias with/without quotes, bare command names.
+ * @internal Exported for testing only.
+ */
+declare function parseCommandVOutput(raw: string): string;
+/**
+ * Validate a Claude CLI path by running `<path> --version`.
+ * Adds the binary's directory to PATH so shebang resolution works (nvm/fnm).
+ */
+declare function validateClaudePath(claudePath: string): {
+    ok: boolean;
+    version?: string;
+};
+/**
+ * Save a validated Claude path to cache for faster startup next time.
+ */
+declare function cacheClaudePath(claudePath: string, cacheDir?: string): void;
+interface ResolveResult {
+    path: string;
+    version?: string;
+    source: "env" | "cache" | "static" | "shell" | "fallback";
+}
+/**
+ * Resolve Claude CLI path. Tries: env override → cache → static paths → shell detection.
+ * All candidates are validated with `--version` before returning.
+ * Consumer apps should call this and handle the `fallback` source (= not found).
+ */
+declare function resolveClaudeCli(opts?: {
+    cacheDir?: string;
+}): ResolveResult;
 declare class ClaudeCodeProvider implements AgentProvider {
     readonly name = "claude-code";
     isAvailable(): Promise<boolean>;
     spawn(options: SpawnOptions): AgentProcess;
 }
 
-export { ClaudeCodeProvider };
+export { ClaudeCodeProvider, type ResolveResult, cacheClaudePath, parseCommandVOutput, resolveClaudeCli, validateClaudePath };

package/dist/core/providers/claude-code.js

@@ -6,38 +6,80 @@ import { fileURLToPath } from "url";
 import { writeHistoryJsonl, buildRecalledConversation } from "./cc-history-adapter.js";
 import { logger } from "../../lib/logger.js";
 const SHELL = process.env.SHELL || "/bin/zsh";
-function resolveClaudePath(cwd) {
-  if (process.env.SNA_CLAUDE_COMMAND) return process.env.SNA_CLAUDE_COMMAND;
-  const cached = path.join(cwd, ".sna/claude-path");
-  if (fs.existsSync(cached)) {
-    const p = fs.readFileSync(cached, "utf8").trim();
-    if (p) {
-      try {
-        execSync(`test -x "${p}"`, { stdio: "pipe" });
-        return p;
-      } catch {
-      }
+function parseCommandVOutput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "claude";
+  const aliasMatch = trimmed.match(/=\s*['"]?([^'"]+?)['"]?\s*$/);
+  if (aliasMatch) return aliasMatch[1];
+  const pathMatch = trimmed.match(/^(\/\S+)/m);
+  if (pathMatch) return pathMatch[1];
+  return trimmed;
+}
+function validateClaudePath(claudePath) {
+  try {
+    const claudeDir = path.dirname(claudePath);
+    const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
+    const out = execSync(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
+    return { ok: true, version: out.split("\n")[0].slice(0, 30) };
+  } catch {
+    return { ok: false };
+  }
+}
+function cacheClaudePath(claudePath, cacheDir) {
+  const dir = cacheDir ?? path.join(process.cwd(), ".sna");
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "claude-path"), claudePath);
+  } catch {
+  }
+}
+function resolveClaudeCli(opts) {
+  const cacheDir = opts?.cacheDir;
+  if (process.env.SNA_CLAUDE_COMMAND) {
+    const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
+    return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
+  }
+  const cacheFile = cacheDir ? path.join(cacheDir, "claude-path") : path.join(process.cwd(), ".sna/claude-path");
+  try {
+    const cached = fs.readFileSync(cacheFile, "utf8").trim();
+    if (cached) {
+      const v = validateClaudePath(cached);
+      if (v.ok) return { path: cached, version: v.version, source: "cache" };
     }
+  } catch {
   }
-  for (const p of [
+  const staticPaths = [
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     `${process.env.HOME}/.local/bin/claude`,
-    `${process.env.HOME}/.claude/bin/claude`
-  ]) {
-    try {
-      execSync(`test -x "${p}"`, { stdio: "pipe" });
-      return p;
-    } catch {
+    `${process.env.HOME}/.claude/bin/claude`,
+    `${process.env.HOME}/.volta/bin/claude`
+  ];
+  for (const p of staticPaths) {
+    const v = validateClaudePath(p);
+    if (v.ok) {
+      cacheClaudePath(p, cacheDir);
+      return { path: p, version: v.version, source: "static" };
     }
   }
   try {
     const raw = execSync(`${SHELL} -i -l -c "command -v claude" 2>/dev/null`, { encoding: "utf8", timeout: 5e3 }).trim();
-    const match = raw.match(/=(.+)/) ?? raw.match(/^(\/\S+)/m);
-    return match ? match[1] : raw;
+    const resolved = parseCommandVOutput(raw);
+    if (resolved && resolved !== "claude") {
+      const v = validateClaudePath(resolved);
+      if (v.ok) {
+        cacheClaudePath(resolved, cacheDir);
+        return { path: resolved, version: v.version, source: "shell" };
+      }
+    }
   } catch {
-    return "claude";
   }
+  return { path: "claude", source: "fallback" };
+}
+function resolveClaudePath(cwd) {
+  const result = resolveClaudeCli({ cacheDir: path.join(cwd, ".sna") });
+  logger.log("agent", `claude path: ${result.source}=${result.path}${result.version ? ` (${result.version})` : ""}`);
+  return result.path;
 }
 const _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
@@ -473,6 +515,10 @@ class ClaudeCodeProvider {
     delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
     delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const claudeDir = path.dirname(claudePath);
+    if (claudeDir && claudeDir !== ".") {
+      cleanEnv.PATH = `${claudeDir}:${cleanEnv.PATH ?? ""}`;
+    }
     const proc = spawn(claudePath, [...claudePrefix, ...args], {
       cwd: options.cwd,
       env: cleanEnv,
@@ -483,5 +529,9 @@ class ClaudeCodeProvider {
   }
 }
 export {
-  ClaudeCodeProvider
+  ClaudeCodeProvider,
+  cacheClaudePath,
+  parseCommandVOutput,
+  resolveClaudeCli,
+  validateClaudePath
 };

package/dist/electron/index.cjs

@@ -30,7 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/electron/index.ts
 var electron_exports = {};
 __export(electron_exports, {
-  startSnaServer: () => startSnaServer
+  cacheClaudePath: () => cacheClaudePath,
+  parseCommandVOutput: () => parseCommandVOutput,
+  resolveClaudeCli: () => resolveClaudeCli,
+  startSnaServer: () => startSnaServer,
+  validateClaudePath: () => validateClaudePath
 });
 module.exports = __toCommonJS(electron_exports);
 
@@ -39,17 +43,490 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/electron/index.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_url = require("url");
+var import_fs3 = __toESM(require("fs"), 1);
+
+// src/core/providers/claude-code.ts
+var import_child_process = require("child_process");
+var import_events = require("events");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/core/providers/cc-history-adapter.ts
+function buildRecalledConversation(history) {
+  const xml = history.map((msg) => `<${msg.role}>${msg.content}</${msg.role}>`).join("\n");
+  return JSON.stringify({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: `<recalled-conversation>
+${xml}
+</recalled-conversation>` }]
+    }
+  });
+}
+
+// src/lib/logger.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
+var LOG_PATH = import_path.default.join(process.cwd(), ".dev.log");
+try {
+  import_fs.default.writeFileSync(LOG_PATH, "");
+} catch {
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+var tags = {
+  sna: " SNA ",
+  req: " REQ ",
+  agent: " AGT ",
+  stdin: " IN  ",
+  stdout: " OUT ",
+  route: " API ",
+  ws: " WS  ",
+  err: " ERR "
+};
+function appendFile(tag, args) {
+  const line = `${ts()} ${tag} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+  import_fs.default.appendFile(LOG_PATH, line, () => {
+  });
+}
+function log(tag, ...args) {
+  console.log(`${ts()} ${tags[tag] ?? tag}`, ...args);
+  appendFile(tags[tag] ?? tag, args);
+}
+function err(tag, ...args) {
+  console.error(`${ts()} ${tags[tag] ?? tag}`, ...args);
+  appendFile(tags[tag] ?? tag, args);
+}
+var logger = { log, err };
+
+// src/core/providers/claude-code.ts
+var SHELL = process.env.SHELL || "/bin/zsh";
+function parseCommandVOutput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "claude";
+  const aliasMatch = trimmed.match(/=\s*['"]?([^'"]+?)['"]?\s*$/);
+  if (aliasMatch) return aliasMatch[1];
+  const pathMatch = trimmed.match(/^(\/\S+)/m);
+  if (pathMatch) return pathMatch[1];
+  return trimmed;
+}
+function validateClaudePath(claudePath) {
+  try {
+    const claudeDir = import_path2.default.dirname(claudePath);
+    const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
+    const out = (0, import_child_process.execSync)(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
+    return { ok: true, version: out.split("\n")[0].slice(0, 30) };
+  } catch {
+    return { ok: false };
+  }
+}
+function cacheClaudePath(claudePath, cacheDir) {
+  const dir = cacheDir ?? import_path2.default.join(process.cwd(), ".sna");
+  try {
+    if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
+    import_fs2.default.writeFileSync(import_path2.default.join(dir, "claude-path"), claudePath);
+  } catch {
+  }
+}
+function resolveClaudeCli(opts) {
+  const cacheDir = opts?.cacheDir;
+  if (process.env.SNA_CLAUDE_COMMAND) {
+    const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
+    return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
+  }
+  const cacheFile = cacheDir ? import_path2.default.join(cacheDir, "claude-path") : import_path2.default.join(process.cwd(), ".sna/claude-path");
+  try {
+    const cached = import_fs2.default.readFileSync(cacheFile, "utf8").trim();
+    if (cached) {
+      const v = validateClaudePath(cached);
+      if (v.ok) return { path: cached, version: v.version, source: "cache" };
+    }
+  } catch {
+  }
+  const staticPaths = [
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    `${process.env.HOME}/.local/bin/claude`,
+    `${process.env.HOME}/.claude/bin/claude`,
+    `${process.env.HOME}/.volta/bin/claude`
+  ];
+  for (const p of staticPaths) {
+    const v = validateClaudePath(p);
+    if (v.ok) {
+      cacheClaudePath(p, cacheDir);
+      return { path: p, version: v.version, source: "static" };
+    }
+  }
+  try {
+    const raw = (0, import_child_process.execSync)(`${SHELL} -i -l -c "command -v claude" 2>/dev/null`, { encoding: "utf8", timeout: 5e3 }).trim();
+    const resolved = parseCommandVOutput(raw);
+    if (resolved && resolved !== "claude") {
+      const v = validateClaudePath(resolved);
+      if (v.ok) {
+        cacheClaudePath(resolved, cacheDir);
+        return { path: resolved, version: v.version, source: "shell" };
+      }
+    }
+  } catch {
+  }
+  return { path: "claude", source: "fallback" };
+}
+var _ClaudeCodeProcess = class _ClaudeCodeProcess {
+  constructor(proc, options) {
+    this.emitter = new import_events.EventEmitter();
+    this._alive = true;
+    this._sessionId = null;
+    this._initEmitted = false;
+    this.buffer = "";
+    /** True once we receive a real text_delta stream_event this turn */
+    this._receivedStreamEvents = false;
+    /** tool_use IDs already emitted via stream_event (to update instead of re-create in assistant block) */
+    this._streamedToolUseIds = /* @__PURE__ */ new Set();
+    /**
+     * FIFO event queue — ALL events (deltas, assistant, complete, etc.) go through
+     * this queue. A fixed-interval timer drains one item at a time, guaranteeing
+     * strict ordering: deltas → assistant → complete, never out of order.
+     */
+    this.eventQueue = [];
+    this.drainTimer = null;
+    this.proc = proc;
+    proc.stdout.on("data", (chunk) => {
+      this.buffer += chunk.toString();
+      const lines = this.buffer.split("\n");
+      this.buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        logger.log("stdout", line);
+        try {
+          const msg = JSON.parse(line);
+          if (msg.session_id && !this._sessionId) {
+            this._sessionId = msg.session_id;
+          }
+          const event = this.normalizeEvent(msg);
+          if (event) this.enqueue(event);
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", () => {
+    });
+    proc.on("exit", (code) => {
+      this._alive = false;
+      if (this.buffer.trim()) {
+        try {
+          const msg = JSON.parse(this.buffer);
+          const event = this.normalizeEvent(msg);
+          if (event) this.enqueue(event);
+        } catch {
+        }
+      }
+      this.flushQueue();
+      this.emitter.emit("exit", code);
+      logger.log("agent", `process exited (code=${code})`);
+    });
+    proc.on("error", (err2) => {
+      this._alive = false;
+      this.emitter.emit("error", err2);
+    });
+    if (options.history?.length && !options._historyViaResume) {
+      const line = buildRecalledConversation(options.history);
+      this.proc.stdin.write(line + "\n");
+    }
+    if (options.prompt) {
+      this.send(options.prompt);
+    }
+  }
+  // ~67 events/sec
+  /**
+   * Enqueue an event for ordered emission.
+   * Starts the drain timer if not already running.
+   */
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (!this.drainTimer) {
+      this.drainTimer = setInterval(() => this.drainOne(), _ClaudeCodeProcess.DRAIN_INTERVAL_MS);
+    }
+  }
+  /** Emit one event from the front of the queue. Stop timer when empty. */
+  drainOne() {
+    const event = this.eventQueue.shift();
+    if (event) {
+      this.emitter.emit("event", event);
+    }
+    if (this.eventQueue.length === 0 && this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+  }
+  /** Flush all remaining queued events immediately (used on process exit). */
+  flushQueue() {
+    if (this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+    while (this.eventQueue.length > 0) {
+      this.emitter.emit("event", this.eventQueue.shift());
+    }
+  }
+  /**
+   * Split completed assistant text into delta chunks and enqueue them,
+   * followed by the final assistant event. All go through the FIFO queue
+   * so subsequent events (complete, etc.) are guaranteed to come after.
+   */
+  enqueueTextAsDeltas(text) {
+    const CHUNK_SIZE = 4;
+    for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+      this.enqueue({
+        type: "assistant_delta",
+        delta: text.slice(i, i + CHUNK_SIZE),
+        index: 0,
+        timestamp: Date.now()
+      });
+    }
+    this.enqueue({
+      type: "assistant",
+      message: text,
+      timestamp: Date.now()
+    });
+  }
+  get alive() {
+    return this._alive;
+  }
+  get pid() {
+    return this.proc.pid ?? null;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Send a user message to the persistent Claude process via stdin.
+   * Accepts plain string or content block array (text + images).
+   */
+  send(input) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const content = typeof input === "string" ? input : input;
+    const msg = JSON.stringify({
+      type: "user",
+      message: { role: "user", content }
+    });
+    logger.log("stdin", msg.slice(0, 200));
+    this.proc.stdin.write(msg + "\n");
+  }
+  interrupt() {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "interrupt" }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setModel(model) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_model", model }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setPermissionMode(mode) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_permission_mode", permission_mode: mode }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  kill() {
+    if (this._alive) {
+      this._alive = false;
+      this.proc.kill("SIGTERM");
+    }
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  normalizeEvent(msg) {
+    switch (msg.type) {
+      case "system": {
+        if (msg.subtype === "init") {
+          if (this._initEmitted) return null;
+          this._initEmitted = true;
+          return {
+            type: "init",
+            message: `Agent ready (${msg.model ?? "unknown"})`,
+            data: { sessionId: msg.session_id, model: msg.model },
+            timestamp: Date.now()
+          };
+        }
+        return null;
+      }
+      case "stream_event": {
+        const inner = msg.event;
+        if (!inner) return null;
+        if (inner.type === "content_block_start" && inner.content_block?.type === "tool_use") {
+          const block = inner.content_block;
+          this._receivedStreamEvents = true;
+          this._streamedToolUseIds.add(block.id);
+          return {
+            type: "tool_use",
+            message: block.name,
+            data: { toolName: block.name, id: block.id, input: null, streaming: true },
+            timestamp: Date.now()
+          };
+        }
+        if (inner.type === "content_block_delta") {
+          const delta = inner.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            this._receivedStreamEvents = true;
+            return {
+              type: "assistant_delta",
+              delta: delta.text,
+              index: inner.index ?? 0,
+              timestamp: Date.now()
+            };
+          }
+          if (delta?.type === "thinking_delta" && delta.thinking) {
+            return {
+              type: "thinking_delta",
+              message: delta.thinking,
+              timestamp: Date.now()
+            };
+          }
+        }
+        return null;
+      }
+      case "assistant": {
+        if (this._receivedStreamEvents && msg.message?.stop_reason === null) return null;
+        const content = msg.message?.content;
+        if (!Array.isArray(content)) return null;
+        const events = [];
+        const textBlocks = [];
+        for (const block of content) {
+          if (block.type === "thinking") {
+            events.push({
+              type: "thinking",
+              message: block.thinking ?? "",
+              timestamp: Date.now()
+            });
+          } else if (block.type === "tool_use") {
+            const alreadyStreamed = this._streamedToolUseIds.has(block.id);
+            if (alreadyStreamed) this._streamedToolUseIds.delete(block.id);
+            events.push({
+              type: "tool_use",
+              message: block.name,
+              data: { toolName: block.name, input: block.input, id: block.id, update: alreadyStreamed },
+              timestamp: Date.now()
+            });
+          } else if (block.type === "text") {
+            const text = (block.text ?? "").trim();
+            if (text) {
+              textBlocks.push(text);
+            }
+          }
+        }
+        if (events.length > 0 || textBlocks.length > 0) {
+          for (const e of events) {
+            this.enqueue(e);
+          }
+          for (const text of textBlocks) {
+            this.enqueue({ type: "assistant", message: text, timestamp: Date.now() });
+          }
+        }
+        return null;
+      }
+      case "user": {
+        const userContent = msg.message?.content;
+        if (!Array.isArray(userContent)) return null;
+        for (const block of userContent) {
+          if (block.type === "tool_result") {
+            return {
+              type: "tool_result",
+              message: typeof block.content === "string" ? block.content.slice(0, 300) : JSON.stringify(block.content).slice(0, 300),
+              data: { toolUseId: block.tool_use_id, isError: block.is_error },
+              timestamp: Date.now()
+            };
+          }
+        }
+        return null;
+      }
+      case "result": {
+        if (msg.subtype === "success") {
+          if (this._receivedStreamEvents && msg.result) {
+            this.enqueue({
+              type: "assistant",
+              message: msg.result,
+              timestamp: Date.now()
+            });
+            this._receivedStreamEvents = false;
+            this._streamedToolUseIds.clear();
+          }
+          const u = msg.usage ?? {};
+          const mu = msg.modelUsage ?? {};
+          const modelKey = Object.keys(mu)[0] ?? "";
+          const modelInfo = mu[modelKey] ?? {};
+          return {
+            type: "complete",
+            message: msg.result ?? "Done",
+            data: {
+              durationMs: msg.duration_ms,
+              costUsd: msg.total_cost_usd,
+              // Per-turn: actual context window usage this turn
+              inputTokens: u.input_tokens ?? 0,
+              outputTokens: u.output_tokens ?? 0,
+              cacheReadTokens: u.cache_read_input_tokens ?? 0,
+              cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+              // Static model info
+              contextWindow: modelInfo.contextWindow ?? 0,
+              model: modelKey
+            },
+            timestamp: Date.now()
+          };
+        }
+        if (msg.subtype === "error_during_execution" && msg.is_error === false) {
+          return {
+            type: "interrupted",
+            message: "Turn interrupted by user",
+            data: { durationMs: msg.duration_ms, costUsd: msg.total_cost_usd },
+            timestamp: Date.now()
+          };
+        }
+        if (msg.subtype?.startsWith("error") || msg.is_error) {
+          return {
+            type: "error",
+            message: msg.result ?? msg.error ?? "Unknown error",
+            timestamp: Date.now()
+          };
+        }
+        return null;
+      }
+      case "rate_limit_event":
+        return null;
+      default:
+        logger.log("agent", `unhandled event: ${msg.type}`, JSON.stringify(msg).substring(0, 200));
+        return null;
+    }
+  }
+};
+_ClaudeCodeProcess.DRAIN_INTERVAL_MS = 15;
+var ClaudeCodeProcess = _ClaudeCodeProcess;
+
+// src/electron/index.ts
+var import_path3 = __toESM(require("path"), 1);
 function resolveStandaloneScript() {
   const selfPath = (0, import_url.fileURLToPath)(importMetaUrl);
-  let script = import_path.default.resolve(import_path.default.dirname(selfPath), "../server/standalone.js");
+  let script = import_path3.default.resolve(import_path3.default.dirname(selfPath), "../server/standalone.js");
   if (script.includes(".asar") && !script.includes(".asar.unpacked")) {
     script = script.replace(/(\.asar)([/\\])/, ".asar.unpacked$2");
   }
-  if (!import_fs.default.existsSync(script)) {
+  if (!import_fs3.default.existsSync(script)) {
     throw new Error(
       `SNA standalone script not found: ${script}
 Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
@@ -60,14 +537,14 @@ Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
 function buildNodePath() {
   const resourcesPath = process.resourcesPath;
   if (!resourcesPath) return void 0;
-  const unpacked = import_path.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
-  if (!import_fs.default.existsSync(unpacked)) return void 0;
+  const unpacked = import_path3.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
+  if (!import_fs3.default.existsSync(unpacked)) return void 0;
   const existing = process.env.NODE_PATH;
-  return existing ? `${unpacked}${import_path.default.delimiter}${existing}` : unpacked;
+  return existing ? `${unpacked}${import_path3.default.delimiter}${existing}` : unpacked;
 }
 async function startSnaServer(options) {
   const port = options.port ?? 3099;
-  const cwd = options.cwd ?? import_path.default.dirname(options.dbPath);
+  const cwd = options.cwd ?? import_path3.default.dirname(options.dbPath);
   const readyTimeout = options.readyTimeout ?? 15e3;
   const { onLog } = options;
   const standaloneScript = resolveStandaloneScript();
@@ -75,7 +552,7 @@ async function startSnaServer(options) {
   let consumerModules;
   try {
     const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
-    consumerModules = import_path.default.resolve(bsPkg, "../..");
+    consumerModules = import_path3.default.resolve(bsPkg, "../..");
   } catch {
   }
   const env = {
@@ -92,7 +569,7 @@ async function startSnaServer(options) {
     // Consumer overrides last so they can always win
     ...options.env ?? {}
   };
-  const proc = (0, import_child_process.fork)(standaloneScript, [], {
+  const proc = (0, import_child_process2.fork)(standaloneScript, [], {
     cwd,
     env,
     stdio: "pipe"
@@ -132,10 +609,10 @@ async function startSnaServer(options) {
         reject(new Error(`SNA server process exited (code=${code ?? "null"}) before becoming ready`));
       }
     });
-    proc.on("error", (err) => {
+    proc.on("error", (err2) => {
       if (!isReady) {
         clearTimeout(timer);
-        reject(err);
+        reject(err2);
       }
     });
   });
@@ -149,5 +626,9 @@ async function startSnaServer(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  startSnaServer
+  cacheClaudePath,
+  parseCommandVOutput,
+  resolveClaudeCli,
+  startSnaServer,
+  validateClaudePath
 });

package/dist/electron/index.d.ts

@@ -1,4 +1,6 @@
 import { ChildProcess } from 'child_process';
+export { ResolveResult, cacheClaudePath, parseCommandVOutput, resolveClaudeCli, validateClaudePath } from '../core/providers/claude-code.js';
+import '../core/providers/types.js';
 
 /**
  * @sna-sdk/core/electron — Electron launcher API

package/dist/electron/index.js

@@ -1,6 +1,7 @@
 import { fork } from "child_process";
 import { fileURLToPath } from "url";
 import fs from "fs";
+import { resolveClaudeCli, validateClaudePath, cacheClaudePath, parseCommandVOutput } from "../core/providers/claude-code.js";
 import path from "path";
 function resolveStandaloneScript() {
   const selfPath = fileURLToPath(import.meta.url);
@@ -107,5 +108,9 @@ async function startSnaServer(options) {
   };
 }
 export {
-  startSnaServer
+  cacheClaudePath,
+  parseCommandVOutput,
+  resolveClaudeCli,
+  startSnaServer,
+  validateClaudePath
 };

package/dist/node/index.cjs

@@ -41,15 +41,415 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/electron/index.ts
 var import_child_process = require("child_process");
 var import_url = require("url");
+var import_fs2 = __toESM(require("fs"), 1);
+
+// src/core/providers/claude-code.ts
+var import_events = require("events");
+
+// src/core/providers/cc-history-adapter.ts
+function buildRecalledConversation(history) {
+  const xml = history.map((msg) => `<${msg.role}>${msg.content}</${msg.role}>`).join("\n");
+  return JSON.stringify({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: `<recalled-conversation>
+${xml}
+</recalled-conversation>` }]
+    }
+  });
+}
+
+// src/lib/logger.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
+var LOG_PATH = import_path.default.join(process.cwd(), ".dev.log");
+try {
+  import_fs.default.writeFileSync(LOG_PATH, "");
+} catch {
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+var tags = {
+  sna: " SNA ",
+  req: " REQ ",
+  agent: " AGT ",
+  stdin: " IN  ",
+  stdout: " OUT ",
+  route: " API ",
+  ws: " WS  ",
+  err: " ERR "
+};
+function appendFile(tag, args) {
+  const line = `${ts()} ${tag} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+  import_fs.default.appendFile(LOG_PATH, line, () => {
+  });
+}
+function log(tag, ...args) {
+  console.log(`${ts()} ${tags[tag] ?? tag}`, ...args);
+  appendFile(tags[tag] ?? tag, args);
+}
+function err(tag, ...args) {
+  console.error(`${ts()} ${tags[tag] ?? tag}`, ...args);
+  appendFile(tags[tag] ?? tag, args);
+}
+var logger = { log, err };
+
+// src/core/providers/claude-code.ts
+var SHELL = process.env.SHELL || "/bin/zsh";
+var _ClaudeCodeProcess = class _ClaudeCodeProcess {
+  constructor(proc, options) {
+    this.emitter = new import_events.EventEmitter();
+    this._alive = true;
+    this._sessionId = null;
+    this._initEmitted = false;
+    this.buffer = "";
+    /** True once we receive a real text_delta stream_event this turn */
+    this._receivedStreamEvents = false;
+    /** tool_use IDs already emitted via stream_event (to update instead of re-create in assistant block) */
+    this._streamedToolUseIds = /* @__PURE__ */ new Set();
+    /**
+     * FIFO event queue — ALL events (deltas, assistant, complete, etc.) go through
+     * this queue. A fixed-interval timer drains one item at a time, guaranteeing
+     * strict ordering: deltas → assistant → complete, never out of order.
+     */
+    this.eventQueue = [];
+    this.drainTimer = null;
+    this.proc = proc;
+    proc.stdout.on("data", (chunk) => {
+      this.buffer += chunk.toString();
+      const lines = this.buffer.split("\n");
+      this.buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        logger.log("stdout", line);
+        try {
+          const msg = JSON.parse(line);
+          if (msg.session_id && !this._sessionId) {
+            this._sessionId = msg.session_id;
+          }
+          const event = this.normalizeEvent(msg);
+          if (event) this.enqueue(event);
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", () => {
+    });
+    proc.on("exit", (code) => {
+      this._alive = false;
+      if (this.buffer.trim()) {
+        try {
+          const msg = JSON.parse(this.buffer);
+          const event = this.normalizeEvent(msg);
+          if (event) this.enqueue(event);
+        } catch {
+        }
+      }
+      this.flushQueue();
+      this.emitter.emit("exit", code);
+      logger.log("agent", `process exited (code=${code})`);
+    });
+    proc.on("error", (err2) => {
+      this._alive = false;
+      this.emitter.emit("error", err2);
+    });
+    if (options.history?.length && !options._historyViaResume) {
+      const line = buildRecalledConversation(options.history);
+      this.proc.stdin.write(line + "\n");
+    }
+    if (options.prompt) {
+      this.send(options.prompt);
+    }
+  }
+  // ~67 events/sec
+  /**
+   * Enqueue an event for ordered emission.
+   * Starts the drain timer if not already running.
+   */
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (!this.drainTimer) {
+      this.drainTimer = setInterval(() => this.drainOne(), _ClaudeCodeProcess.DRAIN_INTERVAL_MS);
+    }
+  }
+  /** Emit one event from the front of the queue. Stop timer when empty. */
+  drainOne() {
+    const event = this.eventQueue.shift();
+    if (event) {
+      this.emitter.emit("event", event);
+    }
+    if (this.eventQueue.length === 0 && this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+  }
+  /** Flush all remaining queued events immediately (used on process exit). */
+  flushQueue() {
+    if (this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+    while (this.eventQueue.length > 0) {
+      this.emitter.emit("event", this.eventQueue.shift());
+    }
+  }
+  /**
+   * Split completed assistant text into delta chunks and enqueue them,
+   * followed by the final assistant event. All go through the FIFO queue
+   * so subsequent events (complete, etc.) are guaranteed to come after.
+   */
+  enqueueTextAsDeltas(text) {
+    const CHUNK_SIZE = 4;
+    for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+      this.enqueue({
+        type: "assistant_delta",
+        delta: text.slice(i, i + CHUNK_SIZE),
+        index: 0,
+        timestamp: Date.now()
+      });
+    }
+    this.enqueue({
+      type: "assistant",
+      message: text,
+      timestamp: Date.now()
+    });
+  }
+  get alive() {
+    return this._alive;
+  }
+  get pid() {
+    return this.proc.pid ?? null;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Send a user message to the persistent Claude process via stdin.
+   * Accepts plain string or content block array (text + images).
+   */
+  send(input) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const content = typeof input === "string" ? input : input;
+    const msg = JSON.stringify({
+      type: "user",
+      message: { role: "user", content }
+    });
+    logger.log("stdin", msg.slice(0, 200));
+    this.proc.stdin.write(msg + "\n");
+  }
+  interrupt() {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "interrupt" }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setModel(model) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_model", model }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setPermissionMode(mode) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_permission_mode", permission_mode: mode }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  kill() {
+    if (this._alive) {
+      this._alive = false;
+      this.proc.kill("SIGTERM");
+    }
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  normalizeEvent(msg) {
+    switch (msg.type) {
+      case "system": {
+        if (msg.subtype === "init") {
+          if (this._initEmitted) return null;
+          this._initEmitted = true;
+          return {
+            type: "init",
+            message: `Agent ready (${msg.model ?? "unknown"})`,
+            data: { sessionId: msg.session_id, model: msg.model },
+            timestamp: Date.now()
+          };
+        }
+        return null;
+      }
+      case "stream_event": {
+        const inner = msg.event;
+        if (!inner) return null;
+        if (inner.type === "content_block_start" && inner.content_block?.type === "tool_use") {
+          const block = inner.content_block;
+          this._receivedStreamEvents = true;
+          this._streamedToolUseIds.add(block.id);
+          return {
+            type: "tool_use",
+            message: block.name,
+            data: { toolName: block.name, id: block.id, input: null, streaming: true },
+            timestamp: Date.now()
+          };
+        }
+        if (inner.type === "content_block_delta") {
+          const delta = inner.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            this._receivedStreamEvents = true;
+            return {
+              type: "assistant_delta",
+              delta: delta.text,
+              index: inner.index ?? 0,
+              timestamp: Date.now()
+            };
+          }
+          if (delta?.type === "thinking_delta" && delta.thinking) {
+            return {
+              type: "thinking_delta",
+              message: delta.thinking,
+              timestamp: Date.now()
+            };
+          }
+        }
+        return null;
+      }
+      case "assistant": {
+        if (this._receivedStreamEvents && msg.message?.stop_reason === null) return null;
+        const content = msg.message?.content;
+        if (!Array.isArray(content)) return null;
+        const events = [];
+        const textBlocks = [];
+        for (const block of content) {
+          if (block.type === "thinking") {
+            events.push({
+              type: "thinking",
+              message: block.thinking ?? "",
+              timestamp: Date.now()
+            });
+          } else if (block.type === "tool_use") {
+            const alreadyStreamed = this._streamedToolUseIds.has(block.id);
+            if (alreadyStreamed) this._streamedToolUseIds.delete(block.id);
+            events.push({
+              type: "tool_use",
+              message: block.name,
+              data: { toolName: block.name, input: block.input, id: block.id, update: alreadyStreamed },
+              timestamp: Date.now()
+            });
+          } else if (block.type === "text") {
+            const text = (block.text ?? "").trim();
+            if (text) {
+              textBlocks.push(text);
+            }
+          }
+        }
+        if (events.length > 0 || textBlocks.length > 0) {
+          for (const e of events) {
+            this.enqueue(e);
+          }
+          for (const text of textBlocks) {
+            this.enqueue({ type: "assistant", message: text, timestamp: Date.now() });
+          }
+        }
+        return null;
+      }
+      case "user": {
+        const userContent = msg.message?.content;
+        if (!Array.isArray(userContent)) return null;
+        for (const block of userContent) {
+          if (block.type === "tool_result") {
+            return {
+              type: "tool_result",
+              message: typeof block.content === "string" ? block.content.slice(0, 300) : JSON.stringify(block.content).slice(0, 300),
+              data: { toolUseId: block.tool_use_id, isError: block.is_error },
+              timestamp: Date.now()
+            };
+          }
+        }
+        return null;
+      }
+      case "result": {
+        if (msg.subtype === "success") {
+          if (this._receivedStreamEvents && msg.result) {
+            this.enqueue({
+              type: "assistant",
+              message: msg.result,
+              timestamp: Date.now()
+            });
+            this._receivedStreamEvents = false;
+            this._streamedToolUseIds.clear();
+          }
+          const u = msg.usage ?? {};
+          const mu = msg.modelUsage ?? {};
+          const modelKey = Object.keys(mu)[0] ?? "";
+          const modelInfo = mu[modelKey] ?? {};
+          return {
+            type: "complete",
+            message: msg.result ?? "Done",
+            data: {
+              durationMs: msg.duration_ms,
+              costUsd: msg.total_cost_usd,
+              // Per-turn: actual context window usage this turn
+              inputTokens: u.input_tokens ?? 0,
+              outputTokens: u.output_tokens ?? 0,
+              cacheReadTokens: u.cache_read_input_tokens ?? 0,
+              cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+              // Static model info
+              contextWindow: modelInfo.contextWindow ?? 0,
+              model: modelKey
+            },
+            timestamp: Date.now()
+          };
+        }
+        if (msg.subtype === "error_during_execution" && msg.is_error === false) {
+          return {
+            type: "interrupted",
+            message: "Turn interrupted by user",
+            data: { durationMs: msg.duration_ms, costUsd: msg.total_cost_usd },
+            timestamp: Date.now()
+          };
+        }
+        if (msg.subtype?.startsWith("error") || msg.is_error) {
+          return {
+            type: "error",
+            message: msg.result ?? msg.error ?? "Unknown error",
+            timestamp: Date.now()
+          };
+        }
+        return null;
+      }
+      case "rate_limit_event":
+        return null;
+      default:
+        logger.log("agent", `unhandled event: ${msg.type}`, JSON.stringify(msg).substring(0, 200));
+        return null;
+    }
+  }
+};
+_ClaudeCodeProcess.DRAIN_INTERVAL_MS = 15;
+var ClaudeCodeProcess = _ClaudeCodeProcess;
+
+// src/electron/index.ts
+var import_path2 = __toESM(require("path"), 1);
 function resolveStandaloneScript() {
   const selfPath = (0, import_url.fileURLToPath)(importMetaUrl);
-  let script = import_path.default.resolve(import_path.default.dirname(selfPath), "../server/standalone.js");
+  let script = import_path2.default.resolve(import_path2.default.dirname(selfPath), "../server/standalone.js");
   if (script.includes(".asar") && !script.includes(".asar.unpacked")) {
     script = script.replace(/(\.asar)([/\\])/, ".asar.unpacked$2");
   }
-  if (!import_fs.default.existsSync(script)) {
+  if (!import_fs2.default.existsSync(script)) {
     throw new Error(
       `SNA standalone script not found: ${script}
 Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
@@ -60,14 +460,14 @@ Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
 function buildNodePath() {
   const resourcesPath = process.resourcesPath;
   if (!resourcesPath) return void 0;
-  const unpacked = import_path.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
-  if (!import_fs.default.existsSync(unpacked)) return void 0;
+  const unpacked = import_path2.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
+  if (!import_fs2.default.existsSync(unpacked)) return void 0;
   const existing = process.env.NODE_PATH;
-  return existing ? `${unpacked}${import_path.default.delimiter}${existing}` : unpacked;
+  return existing ? `${unpacked}${import_path2.default.delimiter}${existing}` : unpacked;
 }
 async function startSnaServer(options) {
   const port = options.port ?? 3099;
-  const cwd = options.cwd ?? import_path.default.dirname(options.dbPath);
+  const cwd = options.cwd ?? import_path2.default.dirname(options.dbPath);
   const readyTimeout = options.readyTimeout ?? 15e3;
   const { onLog } = options;
   const standaloneScript = resolveStandaloneScript();
@@ -75,7 +475,7 @@ async function startSnaServer(options) {
   let consumerModules;
   try {
     const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
-    consumerModules = import_path.default.resolve(bsPkg, "../..");
+    consumerModules = import_path2.default.resolve(bsPkg, "../..");
   } catch {
   }
   const env = {
@@ -132,10 +532,10 @@ async function startSnaServer(options) {
         reject(new Error(`SNA server process exited (code=${code ?? "null"}) before becoming ready`));
       }
     });
-    proc.on("error", (err) => {
+    proc.on("error", (err2) => {
       if (!isReady) {
         clearTimeout(timer);
-        reject(err);
+        reject(err2);
       }
     });
   });

package/dist/node/index.d.ts

@@ -1,2 +1,4 @@
 export { SnaServerHandle, SnaServerOptions, startSnaServer } from '../electron/index.js';
 import 'child_process';
+import '../core/providers/claude-code.js';
+import '../core/providers/types.js';

package/dist/server/standalone.js

@@ -397,38 +397,80 @@ var logger = { log, err };
 
 // src/core/providers/claude-code.ts
 var SHELL = process.env.SHELL || "/bin/zsh";
-function resolveClaudePath(cwd) {
-  if (process.env.SNA_CLAUDE_COMMAND) return process.env.SNA_CLAUDE_COMMAND;
-  const cached = path4.join(cwd, ".sna/claude-path");
-  if (fs4.existsSync(cached)) {
-    const p = fs4.readFileSync(cached, "utf8").trim();
-    if (p) {
-      try {
-        execSync(`test -x "${p}"`, { stdio: "pipe" });
-        return p;
-      } catch {
-      }
+function parseCommandVOutput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "claude";
+  const aliasMatch = trimmed.match(/=\s*['"]?([^'"]+?)['"]?\s*$/);
+  if (aliasMatch) return aliasMatch[1];
+  const pathMatch = trimmed.match(/^(\/\S+)/m);
+  if (pathMatch) return pathMatch[1];
+  return trimmed;
+}
+function validateClaudePath(claudePath) {
+  try {
+    const claudeDir = path4.dirname(claudePath);
+    const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
+    const out = execSync(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
+    return { ok: true, version: out.split("\n")[0].slice(0, 30) };
+  } catch {
+    return { ok: false };
+  }
+}
+function cacheClaudePath(claudePath, cacheDir) {
+  const dir = cacheDir ?? path4.join(process.cwd(), ".sna");
+  try {
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(path4.join(dir, "claude-path"), claudePath);
+  } catch {
+  }
+}
+function resolveClaudeCli(opts) {
+  const cacheDir = opts?.cacheDir;
+  if (process.env.SNA_CLAUDE_COMMAND) {
+    const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
+    return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
+  }
+  const cacheFile = cacheDir ? path4.join(cacheDir, "claude-path") : path4.join(process.cwd(), ".sna/claude-path");
+  try {
+    const cached = fs4.readFileSync(cacheFile, "utf8").trim();
+    if (cached) {
+      const v = validateClaudePath(cached);
+      if (v.ok) return { path: cached, version: v.version, source: "cache" };
     }
+  } catch {
   }
-  for (const p of [
+  const staticPaths = [
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     `${process.env.HOME}/.local/bin/claude`,
-    `${process.env.HOME}/.claude/bin/claude`
-  ]) {
-    try {
-      execSync(`test -x "${p}"`, { stdio: "pipe" });
-      return p;
-    } catch {
+    `${process.env.HOME}/.claude/bin/claude`,
+    `${process.env.HOME}/.volta/bin/claude`
+  ];
+  for (const p of staticPaths) {
+    const v = validateClaudePath(p);
+    if (v.ok) {
+      cacheClaudePath(p, cacheDir);
+      return { path: p, version: v.version, source: "static" };
     }
   }
   try {
     const raw = execSync(`${SHELL} -i -l -c "command -v claude" 2>/dev/null`, { encoding: "utf8", timeout: 5e3 }).trim();
-    const match = raw.match(/=(.+)/) ?? raw.match(/^(\/\S+)/m);
-    return match ? match[1] : raw;
+    const resolved = parseCommandVOutput(raw);
+    if (resolved && resolved !== "claude") {
+      const v = validateClaudePath(resolved);
+      if (v.ok) {
+        cacheClaudePath(resolved, cacheDir);
+        return { path: resolved, version: v.version, source: "shell" };
+      }
+    }
   } catch {
-    return "claude";
   }
+  return { path: "claude", source: "fallback" };
+}
+function resolveClaudePath(cwd) {
+  const result = resolveClaudeCli({ cacheDir: path4.join(cwd, ".sna") });
+  logger.log("agent", `claude path: ${result.source}=${result.path}${result.version ? ` (${result.version})` : ""}`);
+  return result.path;
 }
 var _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
@@ -864,6 +906,10 @@ var ClaudeCodeProvider = class {
     delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
     delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const claudeDir = path4.dirname(claudePath);
+    if (claudeDir && claudeDir !== ".") {
+      cleanEnv.PATH = `${claudeDir}:${cleanEnv.PATH ?? ""}`;
+    }
     const proc = spawn2(claudePath, [...claudePrefix, ...args], {
       cwd: options.cwd,
       env: cleanEnv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sna-sdk/core",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "Skills-Native Application runtime — server, providers, session management, database, and CLI",
   "type": "module",
   "bin": {