@meistrari/tela-cli 0.7.28 → 0.7.30

package/dist/index.js

@@ -910,11 +910,16 @@ var require_process = __commonJS({
     exports2.runCommand = runCommand;
     exports2.runShell = runShell;
     exports2.commandExists = commandExists;
+    exports2.resolveExecutable = resolveExecutable;
     exports2.runInteractiveCommand = runInteractiveCommand;
     exports2.runStreamingCommand = runStreamingCommand;
     exports2.spawnStreamingCommand = spawnStreamingCommand;
     var node_child_process_1 = require("node:child_process");
     var node_events_1 = require("node:events");
+    var node_fs_1 = require("node:fs");
+    var promises_1 = require("node:fs/promises");
+    var node_os_1 = require("node:os");
+    var node_path_1 = require("node:path");
     var CommandError = class extends Error {
       result;
       constructor(message, result) {
@@ -981,8 +986,89 @@ var require_process = __commonJS({
       } catch {
       }
     }
+    function hasPathSeparator(command) {
+      return command.includes("/") || command.includes("\\");
+    }
+    function pathDelimiterForPlatform(platform) {
+      return platform === "win32" ? ";" : ":";
+    }
+    function shellSingleQuote(value) {
+      return `'${String(value).replace(/'/g, "'\\''")}'`;
+    }
+    function isSafeExecutableName(command) {
+      return /^[A-Za-z0-9._+-]+$/.test(command);
+    }
+    function getWindowsExecutableSuffixes(command, env) {
+      if (/\.[^\\/]+$/.test(command)) {
+        return [""];
+      }
+      const pathExt = env.PATHEXT || ".COM;.EXE;.BAT;.CMD";
+      return pathExt.split(";").map((item) => item.trim()).filter(Boolean);
+    }
+    function getPathExecutableCandidates(command, env, platform) {
+      if (hasPathSeparator(command)) {
+        return [command];
+      }
+      const suffixes = platform === "win32" ? getWindowsExecutableSuffixes(command, env) : [""];
+      return (env.PATH || "").split(pathDelimiterForPlatform(platform)).map((item) => item.trim()).filter(Boolean).flatMap((directory) => suffixes.map((suffix) => (0, node_path_1.join)(directory, `${command}${suffix}`)));
+    }
+    function getKnownExecutableCandidates(command, homeDir, platform) {
+      if (platform === "win32" || hasPathSeparator(command)) {
+        return [];
+      }
+      return [
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        (0, node_path_1.join)(homeDir, ".claude", "local"),
+        (0, node_path_1.join)(homeDir, ".claude", "local", "bin"),
+        (0, node_path_1.join)(homeDir, ".bun", "bin"),
+        (0, node_path_1.join)(homeDir, ".npm-global", "bin"),
+        (0, node_path_1.join)(homeDir, ".local", "bin")
+      ].map((directory) => (0, node_path_1.join)(directory, command));
+    }
+    async function findFirstExecutable(candidates, accessFn) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const candidate of candidates) {
+        if (!candidate || seen.has(candidate)) {
+          continue;
+        }
+        seen.add(candidate);
+        try {
+          await accessFn(candidate, node_fs_1.constants.X_OK);
+          return candidate;
+        } catch {
+        }
+      }
+      return null;
+    }
+    async function resolveExecutableFromShell(command, options) {
+      if (hasPathSeparator(command) || !isSafeExecutableName(command)) {
+        return null;
+      }
+      const lookupCommand = options.platform === "win32" ? ["where", command] : [
+        options.shell || (options.platform === "darwin" ? "/bin/zsh" : options.env.SHELL || process.env.SHELL || "/bin/sh"),
+        "-lc",
+        `command -v ${shellSingleQuote(command)}`
+      ];
+      try {
+        const result = await options.runCommandFn(lookupCommand, {
+          env: options.env,
+          allowFailure: true,
+          timeoutMs: options.timeoutMs
+        });
+        if (result.exitCode !== 0) {
+          return null;
+        }
+        const candidates = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return await findFirstExecutable(candidates, options.accessFn);
+      } catch {
+        return null;
+      }
+    }
     async function runCommand(command, options = {}) {
       assertCommand(command);
+      let timedOut = false;
+      let timeout;
       const child = (0, node_child_process_1.spawn)(command[0], command.slice(1), {
         cwd: options.cwd,
         env: buildEnv(options.env),
@@ -992,6 +1078,13 @@ var require_process = __commonJS({
           "pipe"
         ]
       });
+      if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          signalProcessGroup(child, "SIGTERM");
+        }, options.timeoutMs);
+        timeout.unref?.();
+      }
       if (options.input !== void 0) {
         child.stdin?.end(options.input);
       }
@@ -1000,12 +1093,15 @@ var require_process = __commonJS({
         readStream(child.stderr),
         (0, node_events_1.once)(child, "close")
       ]);
+      if (timeout) {
+        clearTimeout(timeout);
+      }
       const [code] = closeResult;
       const result = {
         command,
         exitCode: code ?? 1,
         stdout,
-        stderr
+        stderr: timedOut ? `${stderr}${stderr ? "\n" : ""}Command timed out after ${options.timeoutMs}ms.` : stderr
       };
       if (result.exitCode !== 0 && !options.allowFailure) {
         throw new CommandError(`Command failed (${result.exitCode}): ${command.join(" ")}`, result);
@@ -1016,8 +1112,31 @@ var require_process = __commonJS({
       return await runCommand([process.env.SHELL ?? "/bin/sh", "-c", script], options);
     }
     async function commandExists(command) {
-      const result = await runCommand(["which", command], { allowFailure: true });
-      return result.exitCode === 0;
+      return await resolveExecutable(command) !== null;
+    }
+    async function resolveExecutable(command, options = {}) {
+      const platform = options.platform ?? process.platform;
+      const env = options.env ?? process.env;
+      const accessFn = options.accessFn ?? promises_1.access;
+      const runCommandFn = options.runCommandFn ?? runCommand;
+      const timeoutMs = options.timeoutMs ?? 5e3;
+      const homeDir = options.homeDir ?? (0, node_os_1.homedir)();
+      const pathCandidate = await findFirstExecutable(getPathExecutableCandidates(command, env, platform), accessFn);
+      if (pathCandidate) {
+        return pathCandidate;
+      }
+      const shellCandidate = await resolveExecutableFromShell(command, {
+        env,
+        runCommandFn,
+        accessFn,
+        platform,
+        shell: options.shell,
+        timeoutMs
+      });
+      if (shellCandidate) {
+        return shellCandidate;
+      }
+      return await findFirstExecutable(getKnownExecutableCandidates(command, homeDir, platform), accessFn);
     }
     async function runInteractiveCommand(command, options = {}) {
       assertCommand(command);
@@ -1415,6 +1534,7 @@ var require_auth2 = __commonJS({
   "../../packages/agent/dist/auth.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveAgentApiDataToken = resolveAgentApiDataToken;
     exports2.buildAgentApiHeaders = buildAgentApiHeaders;
     var tela_local_config_1 = require_dist();
     var errors_1 = require_errors();
@@ -1456,18 +1576,14 @@ var require_auth2 = __commonJS({
       }
       return dataToken;
     }
-    async function buildAgentApiHeaders(config, options = {}) {
+    async function resolveAgentApiDataToken(config, options = {}) {
       const fetchFn = options.fetchFn ?? fetch;
       const credentialRef = config.credentialRef;
       const credentials = config.credentials;
       const resolvedEnvironment = config.resolvedEnvironment;
       let credential = config.credential;
       if (!credential && config.auth?.session.accessToken) {
-        const dataToken2 = await exchangeDataToken(config, config.auth.session.accessToken, fetchFn);
-        return {
-          "x-data-token": dataToken2,
-          Accept: "application/json"
-        };
+        return await exchangeDataToken(config, config.auth.session.accessToken, fetchFn);
       }
       if (!credential) {
         throw (0, errors_1.createUserFacingError)({
@@ -1477,10 +1593,7 @@ var require_auth2 = __commonJS({
         });
       }
       if (credential.kind === "data-token" && credential.dataToken) {
-        return {
-          "x-data-token": credential.dataToken,
-          Accept: "application/json"
-        };
+        return credential.dataToken;
       }
       if (credential.kind === "user-session") {
         if (!credentialRef || !credentials || !resolvedEnvironment) {
@@ -1500,7 +1613,10 @@ var require_auth2 = __commonJS({
           fixes: ["Sign in with Dock or choose a user-session context before running agent commands."]
         });
       }
-      const dataToken = await exchangeDataToken(config, credential.accessToken, fetchFn);
+      return await exchangeDataToken(config, credential.accessToken, fetchFn);
+    }
+    async function buildAgentApiHeaders(config, options = {}) {
+      const dataToken = await resolveAgentApiDataToken(config, options);
       return {
         "x-data-token": dataToken,
         Accept: "application/json"
@@ -1515,6 +1631,7 @@ var require_agent_api = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AgentApiError = void 0;
+    exports2.fetchOpenRouterModels = fetchOpenRouterModels;
     exports2.listOrganizations = listOrganizations;
     exports2.provisionForgejoUser = provisionForgejoUser;
     exports2.fetchRepositoryLookup = fetchRepositoryLookup;
@@ -1593,6 +1710,37 @@ var require_agent_api = __commonJS({
       }
     };
     exports2.AgentApiError = AgentApiError;
+    function isOpenRouterModelPricingSummary(value) {
+      if (!value || typeof value !== "object") {
+        return false;
+      }
+      const candidate = value;
+      return typeof candidate.prompt_per_million === "number" && typeof candidate.completion_per_million === "number" && (candidate.input_cache_read_per_million === void 0 || typeof candidate.input_cache_read_per_million === "number");
+    }
+    function isOpenRouterModelSummary(value) {
+      if (!value || typeof value !== "object") {
+        return false;
+      }
+      const candidate = value;
+      return typeof candidate.id === "string" && typeof candidate.name === "string" && typeof candidate.context_length === "number" && (candidate.max_completion_tokens === null || typeof candidate.max_completion_tokens === "number") && isOpenRouterModelPricingSummary(candidate.pricing);
+    }
+    async function fetchOpenRouterModels(config, fetchFn = fetch, options = {}) {
+      const headers = options.headers ?? await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, "/v3/openrouter/models"), {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+      });
+      const responseText = await response.text();
+      const payload = parseJsonBody(responseText);
+      if (!response.ok) {
+        throw new AgentApiError(payload?.error ?? `Agent API OpenRouter model lookup failed with status ${response.status}`, response.status, responseText);
+      }
+      if (!payload || payload.object !== "list" || !Array.isArray(payload.data) || !payload.data.every(isOpenRouterModelSummary)) {
+        throw new AgentApiError("Agent API OpenRouter model lookup returned an invalid payload", response.status, responseText);
+      }
+      return payload.data;
+    }
     async function listOrganizations(config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
       const response = await fetchFn(joinUrl2(config.agentApiUrl, "/v3/organizations"), {
@@ -1877,7 +2025,7 @@ var require_claude = __commonJS({
       }
       return tools;
     }
-    async function prepareProjectScopedClaudeLaunch(repoRoot) {
+    async function prepareProjectScopedClaudeLaunch(repoRoot, options = {}) {
       const settingsPath = (0, node_path_1.join)(repoRoot, ".claude", "settings.json");
       let settingsContent;
       try {
@@ -1903,12 +2051,13 @@ var require_claude = __commonJS({
         settingsPath,
         allowedTools,
         mcpConfig: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : EMPTY_MCP_CONFIG,
-        mcpConfigPath: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : void 0
+        mcpConfigPath: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : void 0,
+        claudeExecutablePath: options.claudeExecutablePath
       };
     }
     function buildProjectScopedClaudeCommand(launch, options = {}) {
       const command = [
-        "claude",
+        launch.claudeExecutablePath ?? "claude",
         "--setting-sources",
         "project",
         "--permission-mode",
@@ -1970,9 +2119,10 @@ var require_claude = __commonJS({
       };
     }
     async function inspectClaudeCli(options = {}) {
-      const commandExistsFn = options.commandExistsFn ?? process_1.commandExists;
+      const resolveExecutableFn = options.resolveExecutableFn ?? process_1.resolveExecutable;
       const runCommandFn = options.runCommandFn ?? process_1.runCommand;
-      if (!await commandExistsFn("claude")) {
+      const executablePath = options.commandExistsFn ? await options.commandExistsFn("claude") ? "claude" : null : await resolveExecutableFn("claude");
+      if (!executablePath) {
         return {
           available: false,
           supportsProjectScopedRun: false,
@@ -1980,13 +2130,14 @@ var require_claude = __commonJS({
           detail: "`claude` is not available on PATH."
         };
       }
-      const result = await runCommandFn(["claude", "--version"], { allowFailure: true });
+      const result = await runCommandFn([executablePath, "--version"], { allowFailure: true });
       const output = `${result.stdout}
 ${result.stderr}`.trim();
       const parsedVersion = parseClaudeCliVersion(output);
       if (!parsedVersion) {
         return {
           available: true,
+          executablePath,
           supportsProjectScopedRun: false,
           problem: "unparseable",
           detail: output || "Claude CLI version output was empty."
@@ -1996,6 +2147,7 @@ ${result.stderr}`.trim();
       if (compareClaudeCliVersions(parsedVersion, exports2.MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN) < 0) {
         return {
           available: true,
+          executablePath,
           version,
           parsedVersion,
           supportsProjectScopedRun: false,
@@ -2005,6 +2157,7 @@ ${result.stderr}`.trim();
       }
       return {
         available: true,
+        executablePath,
         version,
         parsedVersion,
         supportsProjectScopedRun: true,
@@ -2840,7 +2993,9 @@ var require_feedback = __commonJS({
     }
     async function launchFeedbackClaude(options) {
       const runInteractiveCommandFn = options.runInteractiveCommand ?? process_1.runInteractiveCommand;
-      const launch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(options.repoRoot);
+      const launch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(options.repoRoot, {
+        claudeExecutablePath: options.claudeExecutablePath
+      });
       const command = (0, claude_1.buildProjectScopedClaudeCommand)(launch, {
         prompt: options.prompt
       });
@@ -2878,7 +3033,10 @@ var require_feedback = __commonJS({
       const getOriginUrlFn = options.getOriginUrl ?? git_1.getOriginUrl;
       const getHeadCommitHashFn = options.getHeadCommitHash ?? git_1.getHeadCommitHash;
       const getDiffStatAgainstHeadFn = options.getDiffStatAgainstHead ?? git_1.getDiffStatAgainstHead;
-      const commandExistsFn = options.commandExists ?? process_1.commandExists;
+      const inspectClaudeCliFn = options.inspectClaudeCli ?? (async () => await (0, claude_1.inspectClaudeCli)({
+        commandExistsFn: options.commandExists,
+        runCommandFn: options.runCommand
+      }));
       const runInteractiveCommandFn = options.runInteractiveCommand ?? process_1.runInteractiveCommand;
       const selectionMode = getFeedbackSelectionMode(options);
       const config = await ensureConfig();
@@ -2902,13 +3060,27 @@ var require_feedback = __commonJS({
           launchedClaude: false
         });
       }
-      if (!await commandExistsFn("claude")) {
+      let claudeExecutablePath;
+      const claudeInspection = await inspectClaudeCliFn();
+      if (!claudeInspection.available) {
         throw (0, errors_1.createUserFacingError)({
           code: "feedback_claude_missing",
           summary: "Claude CLI is not available on PATH.",
           fixes: ["Install the Claude CLI before using `tela feedback --apply ...`."]
         });
       }
+      if (!claudeInspection.supportsProjectScopedRun) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "feedback_claude_version_unsupported",
+          summary: "Claude CLI version does not support project-scoped feedback runs.",
+          details: claudeInspection.detail,
+          fixes: [
+            "Update Claude CLI before using `tela feedback --apply ...`.",
+            "Run `claude --version` to confirm the installed version."
+          ]
+        });
+      }
+      claudeExecutablePath = claudeInspection.executablePath;
       let selectedFeedbacks = selectionMode === "select" ? [] : actionableFeedbacks;
       if (selectionMode === "select" && options.feedbackIds?.length) {
         selectedFeedbacks = selectFeedbackEntriesById(feedbackEntries, options.feedbackIds);
@@ -3004,6 +3176,7 @@ var require_feedback = __commonJS({
       await launchFeedbackClaude({
         repoRoot: data.repoRoot,
         prompt,
+        claudeExecutablePath,
         runInteractiveCommand: runInteractiveCommandFn
       });
       const diffStat = await getDiffStatAgainstHeadFn(repoRoot) || "<no local diff detected>";
@@ -3038,7 +3211,8 @@ var require_commit_message = __commonJS({
       return input.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
     }
     async function generateCommitMessageWithClaude(context) {
-      if (!await (0, process_1.commandExists)("claude")) {
+      const claudePath = await (0, process_1.resolveExecutable)("claude");
+      if (!claudePath) {
         throw new Error("Claude CLI is not available");
       }
       const prompt = `You are writing a git commit message for already staged changes.
@@ -3058,7 +3232,7 @@ Write exactly one short natural-language git commit message.
 - Keep it concise
 - Return only the commit message text`;
       const result = await (0, process_1.runCommand)([
-        "claude",
+        claudePath,
         "-p",
         prompt,
         "--output-format",
@@ -3232,6 +3406,22 @@ ${error.result.stderr}`.toLowerCase();
   }
 });
 
+// ../../packages/agent/dist/shell.js
+var require_shell = __commonJS({
+  "../../packages/agent/dist/shell.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.shellSingleQuote = shellSingleQuote;
+    exports2.shellJoinCommand = shellJoinCommand;
+    function shellSingleQuote(value) {
+      return `'${value.replace(/'/g, `'"'"'`)}'`;
+    }
+    function shellJoinCommand(command) {
+      return command.map((argument) => shellSingleQuote(argument)).join(" ");
+    }
+  }
+});
+
 // ../../packages/agent/dist/commands/run.js
 var require_run = __commonJS({
   "../../packages/agent/dist/commands/run.js"(exports2) {
@@ -3239,7 +3429,9 @@ var require_run = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.readLocalAgentRunConfig = readLocalAgentRunConfig;
     exports2.updateLocalAgentRunMode = updateLocalAgentRunMode;
+    exports2.updateLocalAgentRunModel = updateLocalAgentRunModel;
     exports2.buildLocalAgentClaudeCommand = buildLocalAgentClaudeCommand;
+    exports2.buildLocalAgentClaudeLaunchCommand = buildLocalAgentClaudeLaunchCommand;
     exports2.prepareLocalAgentRun = prepareLocalAgentRun;
     exports2.parseRunInputAssignment = parseRunInputAssignment;
     exports2.parseRunInputAssignments = parseRunInputAssignments;
@@ -3258,10 +3450,14 @@ var require_run = __commonJS({
     var promises_1 = require("node:fs/promises");
     var node_os_1 = require("node:os");
     var node_path_1 = require("node:path");
+    var agent_api_1 = require_agent_api();
+    var auth_1 = require_auth2();
     var claude_1 = require_claude();
     var git_1 = require_git();
     var errors_1 = require_errors();
     var process_1 = require_process();
+    var config_1 = require_config2();
+    var shell_1 = require_shell();
     var ui_1 = require_ui();
     var INITIAL_PROMPT = "Follow the instructions and return the result.";
     var REQUIRED_AGENT_FILES = [
@@ -4250,6 +4446,27 @@ ${detail.errors.join("\n")}` : summary);
         isMultiturn: options.mode === "chat"
       };
       await (0, promises_1.writeFile)(agentConfig.path, `${JSON.stringify(updated, null, 2)}
+`);
+      return parseAgentConfig("agent.config.json", JSON.stringify(updated));
+    }
+    async function updateLocalAgentRunModel(options) {
+      const repoRoot = await resolveRepositoryRoot(options.cwd ?? process.cwd());
+      const agentConfig = await readAgentConfigFile(repoRoot);
+      const parsed = parseJsonObjectFile("agent.config.json", agentConfig.content, "agent.config.json must be a valid JSON object.");
+      const model = options.model.trim();
+      parseAgentConfig("agent.config.json", agentConfig.content);
+      if (!model || !isOpenRouterModelId(model)) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "run_openrouter_model_invalid",
+          summary: "Choose an OpenRouter model id.",
+          fixes: ["Use a provider-qualified OpenRouter model id, for example `openai/gpt-5.4`."]
+        });
+      }
+      const updated = {
+        ...parsed,
+        model
+      };
+      await (0, promises_1.writeFile)(agentConfig.path, `${JSON.stringify(updated, null, 2)}
 `);
       return parseAgentConfig("agent.config.json", JSON.stringify(updated));
     }
@@ -4281,6 +4498,89 @@ ${detail.errors.join("\n")}` : summary);
         verbose: mode === "one-shot"
       });
     }
+    function isOpenRouterModelId(model) {
+      return Boolean(model && model.includes("/"));
+    }
+    function buildOpenRouterProxyBaseUrl(agentApiUrl) {
+      return new URL("/v3/openrouter", agentApiUrl.endsWith("/") ? agentApiUrl : `${agentApiUrl}/`).toString().replace(/\/$/, "");
+    }
+    function buildOpenRouterClaudeEnvironmentOverrides(model, dataToken, agentApiUrl) {
+      const proxyBaseUrl = buildOpenRouterProxyBaseUrl(agentApiUrl);
+      return {
+        ANTHROPIC_BASE_URL: proxyBaseUrl,
+        ANTHROPIC_AUTH_TOKEN: dataToken,
+        ANTHROPIC_API_KEY: "",
+        ANTHROPIC_DEFAULT_OPUS_MODEL: model,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: model,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: model,
+        CLAUDE_CODE_SUBAGENT_MODEL: model
+      };
+    }
+    function redactClaudeEnvironmentOverrides(overrides) {
+      return {
+        ...overrides,
+        ANTHROPIC_AUTH_TOKEN: overrides.ANTHROPIC_AUTH_TOKEN === void 0 ? void 0 : "<redacted>"
+      };
+    }
+    function buildRedactedClaudeShellCommand(command, environmentOverrides) {
+      const unsetArgs = (0, claude_1.getProjectScopedClaudeEnvDenylist)().map((key) => `-u ${key}`);
+      const setArgs = Object.entries(environmentOverrides).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${(0, shell_1.shellSingleQuote)(value)}`);
+      return ["env", ...unsetArgs, ...setArgs, (0, shell_1.shellJoinCommand)(command)].join(" ");
+    }
+    async function ensureOpenRouterModelAvailable(model, models) {
+      if (models.some((candidate) => candidate.id === model)) {
+        return;
+      }
+      throw (0, errors_1.createUserFacingError)({
+        code: "run_openrouter_model_unavailable",
+        summary: `OpenRouter model is not available through Tela: ${model}`,
+        fixes: [
+          "Use a model returned by `GET /v3/openrouter/models`.",
+          "Update `agent.config.json` to a supported OpenRouter model id, for example `openai/gpt-5.4`."
+        ]
+      });
+    }
+    async function buildLocalAgentClaudeLaunchCommand(prepared, mode, options = {}) {
+      const command = buildLocalAgentClaudeCommand(prepared, mode);
+      const baseEnv = (0, claude_1.buildProjectScopedClaudeEnvironment)(options.baseEnv);
+      const model = prepared.config.model;
+      if (!isOpenRouterModelId(model)) {
+        return {
+          command,
+          env: baseEnv,
+          environmentOverrides: {},
+          redactedEnvironmentOverrides: {},
+          redactedCommand: buildRedactedClaudeShellCommand(command, {}),
+          provider: "anthropic",
+          model
+        };
+      }
+      const resolveConfigFn = options.resolveAgentConfig ?? config_1.resolveAgentConfig;
+      const resolveDataTokenFn = options.resolveAgentApiDataToken ?? auth_1.resolveAgentApiDataToken;
+      const fetchModelsFn = options.fetchOpenRouterModels ?? agent_api_1.fetchOpenRouterModels;
+      const config = await resolveConfigFn();
+      const dataToken = await resolveDataTokenFn(config, { fetchFn: options.fetch });
+      const headers = {
+        "x-data-token": dataToken,
+        Accept: "application/json"
+      };
+      const models = await fetchModelsFn(config, options.fetch, { headers });
+      await ensureOpenRouterModelAvailable(model, models);
+      const environmentOverrides = buildOpenRouterClaudeEnvironmentOverrides(model, dataToken, config.agentApiUrl);
+      const redactedEnvironmentOverrides = redactClaudeEnvironmentOverrides(environmentOverrides);
+      return {
+        command,
+        env: {
+          ...baseEnv,
+          ...environmentOverrides
+        },
+        environmentOverrides,
+        redactedEnvironmentOverrides,
+        redactedCommand: buildRedactedClaudeShellCommand(command, redactedEnvironmentOverrides),
+        provider: "openrouter",
+        model
+      };
+    }
     async function resolveRepositoryRoot(cwd) {
       try {
         return await (0, git_1.getRepositoryRoot)(cwd);
@@ -4342,7 +4642,9 @@ ${detail.errors.join("\n")}` : summary);
       const outputFormat = parseJsonObjectFile("output-format.json", outputFormatContent, "output-format.json must be a valid JSON object.");
       const config = parseAgentConfig("agent.config.json", agentConfigContent);
       const resultKind = Object.keys(outputFormat).length > 0 ? "json" : "markdown";
-      const claudeLaunch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(repoRoot);
+      const claudeLaunch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(repoRoot, {
+        claudeExecutablePath: claudeInspection.executablePath
+      });
       return {
         repoRoot,
         config,
@@ -4999,7 +5301,7 @@ Input folder: ${comparableInputRoot}`,
         inputs
       };
     }
-    async function runInteractiveAgent(prepared, runInteractiveCommandFn, options) {
+    async function runInteractiveAgent(prepared, claudeLaunch, runInteractiveCommandFn, options) {
       if (options.surface === "json") {
         throw (0, errors_1.createUserFacingError)({
           code: "run_multiturn_json_unsupported",
@@ -5019,12 +5321,12 @@ Input folder: ${comparableInputRoot}`,
       if (options.surface === "plain") {
         writeLine2(options.writeStdout, "Launching Claude in interactive chat mode. Tela will resume after Claude exits.");
       }
-      await runInteractiveCommandFn(buildLocalAgentClaudeCommand(prepared, "chat"), {
+      await runInteractiveCommandFn(claudeLaunch.command, {
         cwd: prepared.repoRoot,
-        env: (0, claude_1.buildProjectScopedClaudeEnvironment)()
+        env: claudeLaunch.env
       });
     }
-    async function runOneShotAgent(prepared, options, tracker) {
+    async function runOneShotAgent(prepared, options, tracker, claudeLaunch) {
       const plainRenderer = new PlainTranscriptRenderer();
       const runStreamingCommandFn = options.runStreamingCommand ?? process_1.runStreamingCommand;
       const spawnStreamingCommandFn = options.spawnStreamingCommand ?? ((command2, spawnOptions) => ({
@@ -5042,10 +5344,10 @@ Input folder: ${comparableInputRoot}`,
         writeLine2(options.writeStdout, "Streaming Claude execution in one-shot mode.");
       }
       let cancelled = false;
-      const command = buildLocalAgentClaudeCommand(prepared, "one-shot");
+      const command = claudeLaunch.command;
       const handle = spawnStreamingCommandFn(command, {
         cwd: prepared.repoRoot,
-        env: (0, claude_1.buildProjectScopedClaudeEnvironment)(),
+        env: claudeLaunch.env,
         allowFailure: true,
         onStdoutLine: async (line) => {
           const trimmed = line.trim();
@@ -5132,26 +5434,32 @@ Input folder: ${comparableInputRoot}`,
           isMultiturn: options.mode === "chat"
         }
       } : preparedBase;
+      const mode = prepared.config.isMultiturn ? "chat" : "one-shot";
+      const claudeLaunch = await buildLocalAgentClaudeLaunchCommand(prepared, mode, {
+        resolveAgentConfig: options.resolveAgentConfig,
+        fetchOpenRouterModels: options.fetchOpenRouterModels,
+        resolveAgentApiDataToken: options.resolveAgentApiDataToken,
+        fetch: options.fetch
+      });
       const inputs = await prepareLocalAgentRunInputsForLaunch(prepared, {
         cwd: options.cwd,
         inputAssignments: options.inputAssignments,
         stagedInputs: options.stagedInputs,
         resolveInputConflict: options.resolveInputConflict
       });
-      const mode = prepared.config.isMultiturn ? "chat" : "one-shot";
       const tracker = new RunStateTracker(prepared, mode);
       const agentRunsRoot = options.agentRunsRoot ?? getDefaultAgentRunsRoot();
       let snapshot = tracker.snapshot();
       effectiveOptions.onSnapshot?.(snapshot);
       try {
         if (prepared.config.isMultiturn) {
-          await runInteractiveAgent(prepared, options.runInteractiveCommand ?? process_1.runInteractiveCommand, effectiveOptions);
+          await runInteractiveAgent(prepared, claudeLaunch, options.runInteractiveCommand ?? process_1.runInteractiveCommand, effectiveOptions);
           snapshot = tracker.finalize("success", {
             summary: "Claude chat exited. Reading result artifact\u2026"
           });
           effectiveOptions.onSnapshot?.(snapshot);
         } else {
-          snapshot = await runOneShotAgent(prepared, effectiveOptions, tracker);
+          snapshot = await runOneShotAgent(prepared, effectiveOptions, tracker, claudeLaunch);
         }
       } catch (error) {
         let terminalSnapshot = tracker.snapshot();
@@ -5741,6 +6049,7 @@ var require_cli = __commonJS({
     var sync_1 = require_sync();
     var config_1 = require_config2();
     var errors_1 = require_errors();
+    var claude_1 = require_claude();
     var git_1 = require_git();
     var process_1 = require_process();
     var setup_1 = require_setup();
@@ -6419,15 +6728,28 @@ var require_cli = __commonJS({
           write(io.stdout, renderFeedbackResult(result2));
         return 0;
       }
-      if (!await (0, process_1.commandExists)("claude")) {
+      const claudeInspection = await (0, claude_1.inspectClaudeCli)();
+      if (!claudeInspection.available) {
         throw (0, errors_1.createUserFacingError)({
           code: "feedback_claude_missing",
           summary: "Claude CLI is not available on PATH."
         });
       }
+      if (!claudeInspection.supportsProjectScopedRun) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "feedback_claude_version_unsupported",
+          summary: "Claude CLI version does not support project-scoped feedback runs.",
+          details: claudeInspection.detail,
+          fixes: [
+            "Update Claude CLI before using `tela agent feedback`.",
+            "Run `claude --version` to confirm the installed version."
+          ]
+        });
+      }
       const selectedFeedbacks = data.actionableEntries;
       await (0, feedback_1.launchFeedbackClaude)({
         repoRoot: data.repoRoot,
+        claudeExecutablePath: claudeInspection.executablePath,
         prompt: (0, feedback_1.buildClaudeFeedbackPrompt)({
           repoRoot: data.repoRoot,
           organizationName: data.organizationName,
@@ -6641,6 +6963,7 @@ var require_dist2 = __commonJS({
     __exportStar(require_git(), exports2);
     __exportStar(require_process(), exports2);
     __exportStar(require_setup(), exports2);
+    __exportStar(require_shell(), exports2);
     __exportStar(require_types2(), exports2);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/tela-cli",
-  "version": "0.7.28",
+  "version": "0.7.30",
   "description": "Tela command line tools for local state and agent workflows.",
   "license": "UNLICENSED",
   "repository": {