@meistrari/tela-cli 0.7.42 → 0.7.44

package/dist/index.js

@@ -3446,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;
@@ -3473,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}
 `;
@@ -3626,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;
@@ -3635,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;
     }
@@ -3763,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": {
@@ -3845,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);
@@ -3855,7 +3874,9 @@ var require_run = __commonJS({
               detail: summary.detail,
               recordStep: true,
               parentToolUseId,
-              tokens
+              tokens,
+              usage,
+              startsTurn: !parentToolUseId
             });
           }
           const toolUses = extractAssistantToolUses(event.message);
@@ -3863,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);
           }
@@ -3920,7 +3944,8 @@ var require_run = __commonJS({
             text,
             summary: summary.summary,
             detail: summary.detail,
-            recordStep: true
+            recordStep: true,
+            startsTurn: true
           }];
         }
         case "tool_use_summary": {
@@ -3983,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;
@@ -4000,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;
@@ -4027,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);
@@ -4118,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}
@@ -4134,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;
             }
@@ -4161,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;
             }
@@ -4182,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";
@@ -4258,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();
@@ -4282,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)
@@ -4293,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: {
@@ -4950,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: {
@@ -5125,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) {
@@ -5281,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,
@@ -5344,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.");
       }
@@ -5387,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;
@@ -5397,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", {
@@ -5467,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", {

package/package.json

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