@meistrari/tela-cli 0.7.41 → 0.7.43

package/dist/index.js

@@ -274,7 +274,7 @@ var require_defaults = __commonJS({
             services: {
               pantry: "https://pantry-api.tela.tools",
               workflow: "https://workflow-api.tela.tools",
-              agent: "https://agent-gateway-api.tela.tools"
+              agent: "https://agent-api-production-81c9.up.railway.app"
             }
           },
           staging: {
@@ -366,6 +366,7 @@ var require_config = __commonJS({
     var paths_1 = require_paths();
     var LEGACY_STAGING_AUTH_API_URL = "https://auth.staging.tela.com";
     var LEGACY_STAGING_DEFAULT_API_URL = "https://api.staging.tela.com";
+    var LEGACY_PRODUCTION_AGENT_GATEWAY_URL = "https://agent-gateway-api.tela.tools";
     var CREDENTIAL_MATERIAL_KEYS = /* @__PURE__ */ new Set([
       "accessToken",
       "refreshToken",
@@ -523,6 +524,13 @@ var require_config = __commonJS({
       };
     }
     function applyDefaultEnvironmentValues(id, currentEnvironment, defaultEnvironment) {
+      const services = {
+        ...defaultEnvironment.services,
+        ...currentEnvironment.services
+      };
+      if (id === "production" && services.agent === LEGACY_PRODUCTION_AGENT_GATEWAY_URL) {
+        services.agent = defaultEnvironment.services.agent;
+      }
       return {
         ...currentEnvironment,
         authApiUrl: id === "staging" && currentEnvironment.authApiUrl === LEGACY_STAGING_AUTH_API_URL ? defaultEnvironment.authApiUrl : currentEnvironment.authApiUrl,
@@ -530,10 +538,7 @@ var require_config = __commonJS({
         // staging moved to the telastaging.com domain.
         defaultApiUrl: id === "staging" && currentEnvironment.defaultApiUrl === LEGACY_STAGING_DEFAULT_API_URL ? defaultEnvironment.defaultApiUrl : currentEnvironment.defaultApiUrl,
         authApplication: currentEnvironment.authApplication ?? defaultEnvironment.authApplication,
-        services: {
-          ...defaultEnvironment.services,
-          ...currentEnvironment.services
-        }
+        services
       };
     }
     function assertNoCredentialMaterial(value) {
@@ -2186,7 +2191,6 @@ var require_config2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getDefaultAgentCloneRoot = getDefaultAgentCloneRoot;
-    exports2.isDirectAgentApiUrl = isDirectAgentApiUrl;
     exports2.resolveAgentConfig = resolveAgentConfig;
     exports2.ensureConfigInteractive = ensureConfigInteractive;
     var node_os_1 = require("node:os");
@@ -2194,23 +2198,10 @@ var require_config2 = __commonJS({
     var tela_local_config_1 = require_dist();
     var credentials_1 = require_credentials2();
     var errors_1 = require_errors();
-    var AGENT_GATEWAY_HOSTS = /* @__PURE__ */ new Set([
-      "agent-gateway-api.tela.tools"
-    ]);
     function getDefaultAgentCloneRoot(env = process.env) {
       const configured = env.TELA_AGENT_CLONE_ROOT?.trim();
       return configured ? (0, node_path_1.resolve)(configured.replace(/^~(?=$|\/)/, (0, node_os_1.homedir)())) : (0, node_path_1.join)((0, node_os_1.homedir)(), "tela-agents");
     }
-    function isDirectAgentApiUrl(value) {
-      if (!value)
-        return false;
-      try {
-        const url = new URL(value);
-        return !AGENT_GATEWAY_HOSTS.has(url.hostname);
-      } catch {
-        return false;
-      }
-    }
     async function resolveAgentConfig(options = {}) {
       const env = options.env ?? process.env;
       const localConfig = await (0, tela_local_config_1.loadConfig)();
@@ -2220,22 +2211,13 @@ var require_config2 = __commonJS({
         workspace: options.workspace,
         env
       });
-      const shouldRequireAgentService = options.requireAgentService !== false || options.requireDirectAgentService === true;
-      if (shouldRequireAgentService && !Object.prototype.hasOwnProperty.call(resolved.environment.services, "agent")) {
+      if (options.requireAgentService !== false && !Object.prototype.hasOwnProperty.call(resolved.environment.services, "agent")) {
         throw (0, errors_1.createUserFacingError)({
           code: "agent_service_missing",
           summary: `Context ${resolved.id} does not define an agent service URL.`,
           fixes: ["Add services.agent to the selected Tela environment in Dock before running agent commands."]
         });
       }
-      const configuredAgentServiceUrl = resolved.environment.services.agent;
-      if (options.requireDirectAgentService === true && !isDirectAgentApiUrl(configuredAgentServiceUrl)) {
-        throw (0, errors_1.createUserFacingError)({
-          code: "agent_service_gateway_unsupported",
-          summary: `Context ${resolved.id} points Agent API to an Agent Gateway URL, which cannot be used for tela agent setup.`,
-          fixes: ["Connect an environment with a direct Agent API URL, such as Staging, before running agent setup."]
-        });
-      }
       const credentials = options.credentials ?? (0, credentials_1.createAgentCredentialAdapter)(env);
       const credential = await credentials.get(resolved.context.credentialRef);
       if (!credential) {
@@ -3464,6 +3446,7 @@ var require_run = __commonJS({
     exports2.addLocalAgentRunInputs = addLocalAgentRunInputs;
     exports2.removeLocalAgentRunInput = removeLocalAgentRunInput;
     exports2.createInitialRunSnapshot = createInitialRunSnapshot;
+    exports2.getDefaultAgentRunsRoot = getDefaultAgentRunsRoot;
     exports2.runLocalAgentCommand = runLocalAgentCommand;
     exports2.renderRunExecutionRecap = renderRunExecutionRecap;
     exports2.renderRunArtifactCard = renderRunArtifactCard;
@@ -3491,6 +3474,7 @@ var require_run = __commonJS({
     ];
     var TOOL_PROGRESS_MILESTONES = [0, 5, 15, 30];
     var RUN_ARCHIVE_SCHEMA_VERSION = 1;
+    var LIVE_DEBUG_SNAPSHOT_INTERVAL_MS = 1e3;
     function writeLine2(writer, line) {
       const message = `${line}
 `;
@@ -3644,7 +3628,7 @@ var require_run = __commonJS({
       const detail = summarizeToolInput(name, input);
       return detail ? { summary: truncate(`${name} ${detail}`), detail: `${name}: ${detail}` } : { summary: name };
     }
-    function extractMessageTokens(message) {
+    function extractMessageUsage(message) {
       if (!message || typeof message !== "object")
         return void 0;
       const usage = message.usage;
@@ -3653,6 +3637,21 @@ var require_run = __commonJS({
       const usageRecord = usage;
       const input = safeNumber(usageRecord.input_tokens) ?? 0;
       const output = safeNumber(usageRecord.output_tokens) ?? 0;
+      const cached = safeNumber(usageRecord.cache_read_input_tokens) ?? safeNumber(usageRecord.cache_read_tokens) ?? 0;
+      if (input <= 0 && output <= 0 && cached <= 0)
+        return void 0;
+      return {
+        inputTokens: input,
+        outputTokens: output,
+        cachedTokens: cached
+      };
+    }
+    function extractMessageTokens(message) {
+      const usage = extractMessageUsage(message);
+      if (!usage)
+        return void 0;
+      const input = usage.inputTokens;
+      const output = usage.outputTokens;
       const total = input + output;
       return total > 0 ? total : void 0;
     }
@@ -3781,6 +3780,7 @@ var require_run = __commonJS({
                 summary: "Claude session started.",
                 detail: safeString(event.cwd),
                 model: safeString(event.model),
+                claudeSessionId: safeString(event.session_id),
                 recordStep: true
               }];
             case "status": {
@@ -3863,6 +3863,7 @@ var require_run = __commonJS({
           const normalized = [];
           const parentToolUseId = safeString(event.parent_tool_use_id);
           const tokens = extractMessageTokens(event.message);
+          const usage = extractMessageUsage(event.message);
           const text = extractAssistantText(event.message);
           if (text.trim()) {
             const summary = summarizeLines(text);
@@ -3873,7 +3874,9 @@ var require_run = __commonJS({
               detail: summary.detail,
               recordStep: true,
               parentToolUseId,
-              tokens
+              tokens,
+              usage,
+              startsTurn: !parentToolUseId
             });
           }
           const toolUses = extractAssistantToolUses(event.message);
@@ -3881,8 +3884,11 @@ var require_run = __commonJS({
             const batch = buildToolBatchEvent(buildDerivedToolSummary(toolUses), toolUses);
             if (batch.kind === "tool_batch") {
               batch.parentToolUseId = parentToolUseId;
+              batch.startsTurn = !parentToolUseId && normalized.length === 0;
               if (tokens != null && normalized.length === 0)
                 batch.tokens = tokens;
+              if (usage && normalized.length === 0)
+                batch.usage = usage;
             }
             normalized.push(batch);
           }
@@ -3938,7 +3944,8 @@ var require_run = __commonJS({
             text,
             summary: summary.summary,
             detail: summary.detail,
-            recordStep: true
+            recordStep: true,
+            startsTurn: true
           }];
         }
         case "tool_use_summary": {
@@ -4001,6 +4008,38 @@ var require_run = __commonJS({
       const elapsed = timeElapsed != null && Number.isFinite(timeElapsed) ? ` timeElapsed="${String(timeElapsed).replace(/"/g, "&quot;")}"` : "";
       return `<step${elapsed}>${escapeReasoningStepContent(content)}</step>`;
     }
+    function mapRunStatusToDebugTimelineStatus(status) {
+      switch (status) {
+        case "success":
+          return "completed";
+        case "failed":
+          return "failed";
+        case "cancelled":
+          return "cancelled";
+        case "running":
+          return "running";
+        case "starting":
+        default:
+          return "pending";
+      }
+    }
+    function getTimelineToolCategory(toolName) {
+      const normalized = toolName?.toLowerCase() ?? "";
+      if (includesAny(normalized, ["bash", "shell", "exec", "command", "terminal"]))
+        return "shell";
+      if (includesAny(normalized, ["grep", "glob", "search", "find", "lsp"]))
+        return "search";
+      if (includesAny(normalized, ["read", "fetch", "get", "open", "view"]))
+        return "file";
+      if (includesAny(normalized, ["write", "edit", "patch", "replace", "update", "insert", "delete", "move", "apply"]))
+        return "edit";
+      if (includesAny(normalized, ["web", "url", "browser"]))
+        return "web";
+      return "other";
+    }
+    function includesAny(value, needles) {
+      return needles.some((needle) => value.includes(needle));
+    }
     function normalizeToolInput(input) {
       if (isRecord2(input)) {
         return input;
@@ -4018,11 +4057,19 @@ var require_run = __commonJS({
       reasoningSteps = [];
       activeTools = /* @__PURE__ */ new Map();
       subagentBuckets = /* @__PURE__ */ new Map();
+      timelineEvents = [];
+      timelineToolEventIndexes = /* @__PURE__ */ new Map();
+      runTurns = [];
+      debugSessionId = (0, node_crypto_1.randomUUID)();
       execution;
       stepIndex = 0;
+      sequenceIndex = 0;
+      runTurnIndex = 0;
       status = "starting";
       currentActivity = "Preparing Claude run\u2026";
       model;
+      claudeSessionId = null;
+      currentRunTurnId = null;
       constructor(prepared, mode, startedAtMs = Date.now()) {
         this.prepared = prepared;
         this.mode = mode;
@@ -4045,6 +4092,163 @@ var require_run = __commonJS({
           notable
         });
       }
+      elapsedMs() {
+        return Math.max(0, Date.now() - this.startedAtMs);
+      }
+      eventClock() {
+        const relativeTimeMs = this.elapsedMs();
+        return {
+          relativeTimeMs,
+          timestamp: this.startedAtMs + relativeTimeMs
+        };
+      }
+      startRunTurn(startMs = this.elapsedMs()) {
+        const lastTurn = this.runTurns.at(-1);
+        if (lastTurn && lastTurn.endMs == null) {
+          lastTurn.endMs = Math.max(lastTurn.startMs, startMs);
+        }
+        const id = `run-turn-${++this.runTurnIndex}`;
+        this.runTurns.push({
+          id,
+          startMs
+        });
+        this.currentRunTurnId = id;
+        return id;
+      }
+      ensureRunTurn() {
+        return this.currentRunTurnId ?? this.startRunTurn();
+      }
+      finishRunTurn(endMs = this.elapsedMs()) {
+        const turn = this.currentRunTurnId ? this.runTurns.find((candidate) => candidate.id === this.currentRunTurnId) : this.runTurns.at(-1);
+        if (turn) {
+          turn.endMs = Math.max(turn.startMs, endMs);
+        }
+      }
+      addTimelineTextEvent(event) {
+        if (event.startsTurn) {
+          this.startRunTurn();
+        }
+        const { relativeTimeMs, timestamp } = this.eventClock();
+        this.timelineEvents.push({
+          type: "text",
+          relativeTimeMs,
+          timestamp,
+          sequenceIndex: ++this.sequenceIndex,
+          runTurnId: this.ensureRunTurn(),
+          tokensIn: event.usage?.inputTokens,
+          tokensOut: event.usage?.outputTokens,
+          cachedTokens: event.usage?.cachedTokens,
+          text: event.text,
+          displaySummary: event.summary
+        });
+      }
+      addTimelineToolEvents(event) {
+        if (event.startsTurn) {
+          this.startRunTurn();
+        }
+        for (let index = 0; index < event.tools.length; index += 1) {
+          const tool = event.tools[index];
+          const includeUsage = index === 0;
+          const { relativeTimeMs, timestamp } = this.eventClock();
+          const timelineEvent = {
+            type: "tool_call",
+            relativeTimeMs,
+            timestamp,
+            sequenceIndex: ++this.sequenceIndex,
+            runTurnId: this.ensureRunTurn(),
+            ...includeUsage && event.usage ? {
+              tokensIn: event.usage.inputTokens,
+              tokensOut: event.usage.outputTokens,
+              cachedTokens: event.usage.cachedTokens
+            } : {},
+            toolName: tool.name,
+            callId: tool.id,
+            arguments: normalizeToolInput(tool.input),
+            displaySummary: tool.detail ?? tool.summary,
+            category: getTimelineToolCategory(tool.name)
+          };
+          this.timelineToolEventIndexes.set(tool.id, this.timelineEvents.length);
+          this.timelineEvents.push(timelineEvent);
+        }
+      }
+      completeTimelineToolEvent(event) {
+        const index = this.timelineToolEventIndexes.get(event.toolUseId);
+        if (index == null)
+          return;
+        const existing = this.timelineEvents[index];
+        if (!existing || existing.type !== "tool_call")
+          return;
+        const endMs = this.elapsedMs();
+        existing.status = event.isError ? "failed" : "success";
+        existing.result = {
+          output: event.output,
+          isError: event.isError,
+          durationMs: Math.max(0, endMs - existing.relativeTimeMs)
+        };
+      }
+      buildDebugTimeline() {
+        const events = this.timelineEvents.map((event) => ({
+          ...event,
+          result: event.result ? { ...event.result } : void 0,
+          arguments: event.arguments ? { ...event.arguments } : void 0
+        }));
+        const fallbackEndMs = this.execution.durationMs ?? this.elapsedMs();
+        const turns = this.runTurns.length > 0 ? this.runTurns : [{ id: "run-turn-1", startMs: 0, endMs: fallbackEndMs }];
+        const timelineStatus = mapRunStatusToDebugTimelineStatus(this.status);
+        const spans = turns.map((turn) => {
+          const turnEvents = events.filter((event) => event.runTurnId === turn.id);
+          const isOpenTurn = turn.endMs == null && (timelineStatus === "running" || timelineStatus === "pending");
+          const endCandidates = [
+            turn.endMs,
+            isOpenTurn ? fallbackEndMs : void 0,
+            ...turnEvents.map((event) => {
+              const duration = event.type === "tool_call" ? event.result?.durationMs ?? 0 : 0;
+              return event.relativeTimeMs + duration;
+            })
+          ].filter((value) => typeof value === "number" && Number.isFinite(value));
+          const endMs = Math.max(turn.startMs, endCandidates.length > 0 ? Math.max(...endCandidates) : fallbackEndMs);
+          return {
+            id: turn.id,
+            type: "run_turn",
+            parentId: null,
+            startMs: turn.startMs,
+            endMs,
+            metrics: {
+              tokensIn: turnEvents.reduce((sum, event) => sum + (event.tokensIn ?? 0), 0),
+              tokensOut: turnEvents.reduce((sum, event) => sum + (event.tokensOut ?? 0), 0),
+              cachedTokens: turnEvents.reduce((sum, event) => sum + (event.cachedTokens ?? 0), 0),
+              costUsd: turnEvents.reduce((sum, event) => sum + (event.costUsd ?? 0), 0),
+              toolCallCount: turnEvents.filter((event) => event.type === "tool_call").length,
+              apiCallCount: 1
+            }
+          };
+        });
+        const tokensIn = events.reduce((sum, event) => sum + (event.tokensIn ?? 0), 0);
+        const tokensOut = events.reduce((sum, event) => sum + (event.tokensOut ?? 0), 0);
+        const cachedTokens = events.reduce((sum, event) => sum + (event.cachedTokens ?? 0), 0);
+        return {
+          sessionId: this.debugSessionId,
+          status: timelineStatus,
+          metrics: {
+            durationMs: fallbackEndMs,
+            toolCalls: events.filter((event) => event.type === "tool_call").length,
+            apiCalls: this.execution.numTurns ?? spans.length,
+            tokensIn,
+            tokensOut,
+            cachedTokens,
+            totalCostUsd: this.execution.totalCostUsd ?? events.reduce((sum, event) => sum + (event.costUsd ?? 0), 0),
+            cacheSavingsUsd: 0
+          },
+          prompt: {
+            model: this.model ?? null,
+            claudeSessionId: this.claudeSessionId,
+            timestamp: this.startedAtMs,
+            text: INITIAL_PROMPT
+          },
+          events,
+          spans
+        };
+      }
       pushReasoningStep(parentToolUseId, step) {
         if (parentToolUseId && this.subagentBuckets.has(parentToolUseId)) {
           this.subagentBuckets.get(parentToolUseId).reasoningSteps.push(step);
@@ -4136,6 +4340,7 @@ var require_run = __commonJS({
             this.execution.status = "running";
             this.currentActivity = event.summary;
             this.model = event.model ?? this.model;
+            this.claudeSessionId = event.claudeSessionId ?? this.claudeSessionId;
             if (event.recordStep) {
               this.addStep("status", event.summary, event.detail);
               this.addReasoningText(event.detail ? `${event.summary}
@@ -4152,6 +4357,9 @@ ${event.detail}` : event.summary);
             this.execution.status = "running";
             this.currentActivity = event.summary;
             this.addReasoningText(event.text, event.parentToolUseId);
+            if (!event.parentToolUseId) {
+              this.addTimelineTextEvent(event);
+            }
             if (isSubagent && event.tokens != null) {
               this.subagentBuckets.get(event.parentToolUseId).totalTokens += event.tokens;
             }
@@ -4179,6 +4387,9 @@ ${event.detail}` : event.summary);
                 this.subagentBuckets.get(event.parentToolUseId).totalToolUseCount += 1;
               }
             }
+            if (!event.parentToolUseId) {
+              this.addTimelineToolEvents(event);
+            }
             if (isSubagent && event.tokens != null) {
               this.subagentBuckets.get(event.parentToolUseId).totalTokens += event.tokens;
             }
@@ -4200,6 +4411,9 @@ ${event.detail}` : event.summary);
           }
           case "tool_result":
             this.addReasoningToolResult(event.toolUseId, event.output, event.isError, event.parentToolUseId);
+            if (!event.parentToolUseId) {
+              this.completeTimelineToolEvent(event);
+            }
             break;
           case "status_notice":
             this.status = "running";
@@ -4276,6 +4490,7 @@ ${event.detail}` : event.summary);
             this.addStep("result", event.summary, event.detail, event.execution.status !== "success");
             this.addReasoningText(event.detail ? `${event.summary}
 ${event.detail}` : event.summary);
+            this.finishRunTurn();
             break;
         }
         return this.snapshot();
@@ -4300,7 +4515,8 @@ ${event.detail}` : event.summary);
           this.addReasoningText(detail?.errors?.length ? `${summary}
 ${detail.errors.join("\n")}` : summary);
         }
-        return this.snapshot();
+        this.finishRunTurn();
+        return this.snapshot(true);
       }
       buildSubagentReasoningById() {
         if (this.subagentBuckets.size === 0)
@@ -4311,19 +4527,23 @@ ${detail.errors.join("\n")}` : summary);
         }
         return result;
       }
-      snapshot() {
+      snapshot(includeDebugTimeline = false) {
         return {
           repoRoot: this.prepared.repoRoot,
           mode: this.mode,
           model: this.model,
           artifactPath: this.prepared.resultPath,
           sourceResultPath: this.prepared.resultPath,
+          runDirectory: this.prepared.repoRoot,
+          inputDirectory: (0, node_path_1.join)(this.prepared.repoRoot, "input"),
+          outputDirectory: (0, node_path_1.join)(this.prepared.repoRoot, "output"),
           startedAtMs: this.startedAtMs,
           status: this.status,
           currentActivity: this.currentActivity,
           steps: this.steps.map((step) => ({ ...step })),
           reasoningMarkup: this.reasoningSteps.join(""),
           subagentReasoningById: this.buildSubagentReasoningById(),
+          debugTimeline: includeDebugTimeline ? this.buildDebugTimeline() : void 0,
           outputSchema: this.prepared.outputSchema,
           activeTools: Array.from(this.activeTools.values()).map((tool) => ({ ...tool })),
           execution: {
@@ -4968,17 +5188,40 @@ Input folder: ${comparableInputRoot}`,
       return { stagedPath };
     }
     function createInitialRunSnapshot(prepared, mode = prepared.config.isMultiturn ? "chat" : "one-shot") {
+      const startedAtMs = Date.now();
       return {
         repoRoot: prepared.repoRoot,
         mode,
         model: prepared.config.model,
         artifactPath: prepared.resultPath,
         sourceResultPath: prepared.resultPath,
-        startedAtMs: Date.now(),
+        startedAtMs,
         status: "starting",
         currentActivity: mode === "chat" ? "Preparing Claude chat handoff\u2026" : "Validating repository contract\u2026",
         steps: [],
         reasoningMarkup: "",
+        debugTimeline: {
+          sessionId: (0, node_crypto_1.randomUUID)(),
+          status: "pending",
+          metrics: {
+            durationMs: 0,
+            toolCalls: 0,
+            apiCalls: 0,
+            tokensIn: 0,
+            tokensOut: 0,
+            cachedTokens: 0,
+            totalCostUsd: 0,
+            cacheSavingsUsd: 0
+          },
+          prompt: {
+            model: prepared.config.model ?? null,
+            claudeSessionId: null,
+            timestamp: startedAtMs,
+            text: INITIAL_PROMPT
+          },
+          events: [],
+          spans: []
+        },
         outputSchema: prepared.outputSchema,
         activeTools: [],
         execution: {
@@ -5143,6 +5386,8 @@ Input folder: ${comparableInputRoot}`,
           execution: input.execution,
           steps: input.snapshot.steps,
           reasoningMarkup: input.snapshot.reasoningMarkup,
+          subagentReasoningById: input.snapshot.subagentReasoningById,
+          debugTimeline: input.snapshot.debugTimeline,
           inputs: input.inputs
         }), "utf-8");
       } catch (error) {
@@ -5299,6 +5544,7 @@ Input folder: ${comparableInputRoot}`,
         steps: snapshot.steps,
         reasoningMarkup: snapshot.reasoningMarkup,
         subagentReasoningById: snapshot.subagentReasoningById,
+        debugTimeline: snapshot.debugTimeline,
         outputSchema: prepared.outputSchema,
         artifact: {
           path: archived.resultPath,
@@ -5362,7 +5608,7 @@ Input folder: ${comparableInputRoot}`,
       const notifySnapshot = (snapshot2) => {
         options.onSnapshot?.(snapshot2);
       };
-      notifySnapshot(tracker.snapshot());
+      notifySnapshot(tracker.snapshot(true));
       if (options.surface === "plain") {
         writeLine2(options.writeStdout, "Streaming Claude execution in one-shot mode.");
       }
@@ -5405,6 +5651,12 @@ Input folder: ${comparableInputRoot}`,
           }
         }
       });
+      const liveDebugSnapshotTimer = setInterval(() => {
+        const snapshot2 = tracker.snapshot(true);
+        if (snapshot2.status === "running" || snapshot2.status === "starting") {
+          notifySnapshot(snapshot2);
+        }
+      }, LIVE_DEBUG_SNAPSHOT_INTERVAL_MS);
       options.onControl?.({
         interrupt() {
           cancelled = true;
@@ -5415,8 +5667,13 @@ Input folder: ${comparableInputRoot}`,
           handle.kill();
         }
       });
-      const result = await handle.result;
-      let snapshot = tracker.snapshot();
+      let result;
+      try {
+        result = await handle.result;
+      } finally {
+        clearInterval(liveDebugSnapshotTimer);
+      }
+      let snapshot = tracker.snapshot(true);
       if (result.exitCode !== 0) {
         if (cancelled) {
           snapshot = tracker.finalize("cancelled", {
@@ -5485,7 +5742,7 @@ Input folder: ${comparableInputRoot}`,
           snapshot = await runOneShotAgent(prepared, effectiveOptions, tracker, claudeLaunch);
         }
       } catch (error) {
-        let terminalSnapshot = tracker.snapshot();
+        let terminalSnapshot = tracker.snapshot(true);
         let archiveFailureWarning;
         if (error instanceof process_1.CommandError && terminalSnapshot.execution.status !== "failed" && terminalSnapshot.execution.status !== "cancelled") {
           terminalSnapshot = tracker.finalize("failed", {
@@ -5913,8 +6170,7 @@ var require_setup = __commonJS({
         environmentId: options.environmentId,
         workspace: options.workspace,
         credentials: options.credentials,
-        env: options.env,
-        requireDirectAgentService: true
+        env: options.env
       });
       if (!config.contextId) {
         throw new Error("Agent setup requires a resolved Tela context.");
@@ -6028,8 +6284,7 @@ var require_setup = __commonJS({
       const config = await (0, config_1.resolveAgentConfig)({
         contextId: input.contextId,
         credentials,
-        env: options.env,
-        requireDirectAgentService: true
+        env: options.env
       });
       const organizations = await (0, agent_api_1.listOrganizations)(config, options.fetchFn);
       const organization = organizations.find((item) => item.id === input.organizationId);
@@ -6965,7 +7220,7 @@ var require_dist2 = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ensureConfigInteractive = exports2.resolveAgentConfig = exports2.isDirectAgentApiUrl = exports2.getDefaultAgentCloneRoot = void 0;
+    exports2.ensureConfigInteractive = exports2.resolveAgentConfig = exports2.getDefaultAgentCloneRoot = void 0;
     __exportStar(require_agent_api(), exports2);
     __exportStar(require_auth2(), exports2);
     __exportStar(require_claude(), exports2);
@@ -6978,9 +7233,6 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "getDefaultAgentCloneRoot", { enumerable: true, get: function() {
       return config_1.getDefaultAgentCloneRoot;
     } });
-    Object.defineProperty(exports2, "isDirectAgentApiUrl", { enumerable: true, get: function() {
-      return config_1.isDirectAgentApiUrl;
-    } });
     Object.defineProperty(exports2, "resolveAgentConfig", { enumerable: true, get: function() {
       return config_1.resolveAgentConfig;
     } });

package/package.json

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