@gh-symphony/cli 0.0.17 → 0.0.18

package/dist/{chunk-MHIWAIVD.js → chunk-ZYYY55WB.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getGhToken
-} from "./chunk-JO3AXHQI.js";
+} from "./chunk-7UBUBSMH.js";
 import {
   bold,
   cyan,
@@ -17,7 +17,7 @@ import {
   createStore,
   releaseProjectLock,
   resolveOrchestratorLogLevel
-} from "./chunk-EFMFGOWM.js";
+} from "./chunk-LZE6YUSB.js";
 import {
   deriveIssueWorkspaceKeyFromIdentifier,
   isFileMissing,
@@ -26,14 +26,14 @@ import {
   parseRecentEvents,
   readJsonFile,
   safeReadDir
-} from "./chunk-TF3QNWNC.js";
+} from "./chunk-OL73UN2X.js";
 import {
   resolveRuntimeRoot
 } from "./chunk-5NV3LSAJ.js";
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-TH5QPO3Y.js";
+} from "./chunk-C7G7RJ4G.js";
 import {
   daemonPidPath,
   httpStatusPath,
@@ -91,7 +91,8 @@ var DashboardFsReader = class {
     if (issues) {
       return issues.map((issue) => ({
         ...issue,
-        completedOnce: issue.completedOnce ?? false
+        completedOnce: issue.completedOnce ?? false,
+        failureRetryCount: issue.failureRetryCount ?? 0
       }));
     }
     const legacyLeases = await readJsonFile(join(this.projectDir(), "leases.json")) ?? [];
@@ -100,6 +101,7 @@ var DashboardFsReader = class {
       identifier: lease.issueIdentifier,
       workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
       completedOnce: false,
+      failureRetryCount: 0,
       state: lease.status === "active" ? "claimed" : "released",
       currentRunId: lease.status === "active" ? lease.runId : null,
       retryEntry: null,
@@ -114,6 +116,24 @@ var DashboardFsReader = class {
     const runs = await mapWithConcurrency(runIds, RUN_RECORD_LOAD_CONCURRENCY, (runId) => this.loadRun(runId));
     return runs.filter((run) => Boolean(run));
   }
+  async loadRunsForIssue(issueId, issueIdentifier) {
+    const runIds = await safeReadDir(join(this.projectDir(), "runs"));
+    const runs = await mapWithConcurrency(runIds, RUN_RECORD_LOAD_CONCURRENCY, async (runId) => {
+      try {
+        const run = await this.loadRun(runId);
+        if (!run) {
+          return null;
+        }
+        return run.issueId === issueId || run.issueIdentifier === issueIdentifier ? run : null;
+      } catch (error) {
+        if (isFileMissing(error)) {
+          return null;
+        }
+        return null;
+      }
+    });
+    return runs.filter((run) => Boolean(run));
+  }
   async loadRecentRunEvents(runId, limit = DEFAULT_RECENT_EVENT_LIMIT) {
     if (limit <= 0) {
       return [];
@@ -170,64 +190,81 @@ async function statusForIssue(reader, issueIdentifier) {
     return null;
   }
   const currentRunCandidate = issueRecord.currentRunId ? await reader.loadRun(issueRecord.currentRunId) : null;
-  const currentRun = isMatchingIssueRun(currentRunCandidate, reader.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : await findLatestRunForIssue(reader, issueRecord.issueId, issueIdentifier);
-  const recentEvents = currentRun === null ? [] : await reader.loadRecentRunEvents(currentRun.runId);
+  const currentRun = isMatchingIssueRun(currentRunCandidate, reader.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : null;
+  const issueRuns = currentRun === null ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : currentRun.tokenUsage ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : null;
+  const resolvedRun = currentRun ?? findLatestRunForIssue(issueRuns ?? []);
+  const recentEvents = resolvedRun === null ? [] : await reader.loadRecentRunEvents(resolvedRun.runId);
+  const cumulativeTokens = aggregateIssueTokenUsage(issueRuns ?? []);
   const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
-  const currentAttempt = currentRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
+  const currentAttempt = resolvedRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
   return {
     issue_identifier: issueRecord.identifier,
     issue_id: issueRecord.issueId,
-    status: currentRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
+    status: resolvedRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
     workspace: {
-      path: currentRun?.workingDirectory ?? null
+      path: resolvedRun?.workingDirectory ?? null
     },
     attempts: {
       restart_count: Math.max(0, currentAttempt - 1),
       current_retry_attempt: currentAttempt
     },
-    running: currentRun === null ? null : {
-      session_id: currentRun.runtimeSession?.sessionId ?? null,
-      turn_count: currentRun.turnCount ?? null,
-      state: currentRun.issueState ?? null,
-      started_at: currentRun.startedAt ?? null,
-      last_event: currentRun.lastEvent ?? null,
+    running: resolvedRun === null ? null : {
+      session_id: resolvedRun.runtimeSession?.sessionId ?? null,
+      turn_count: resolvedRun.turnCount ?? null,
+      state: resolvedRun.issueState ?? null,
+      started_at: resolvedRun.startedAt ?? null,
+      last_event: resolvedRun.lastEvent ?? null,
       last_message: latestEventMessage,
-      last_event_at: currentRun.lastEventAt ?? null,
-      tokens: currentRun.tokenUsage ? {
-        input_tokens: currentRun.tokenUsage.inputTokens,
-        output_tokens: currentRun.tokenUsage.outputTokens,
-        total_tokens: currentRun.tokenUsage.totalTokens
+      last_event_at: resolvedRun.lastEventAt ?? null,
+      tokens: resolvedRun.tokenUsage ? {
+        input_tokens: resolvedRun.tokenUsage.inputTokens,
+        output_tokens: resolvedRun.tokenUsage.outputTokens,
+        total_tokens: resolvedRun.tokenUsage.totalTokens,
+        cumulative_input_tokens: cumulativeTokens.inputTokens,
+        cumulative_output_tokens: cumulativeTokens.outputTokens,
+        cumulative_total_tokens: cumulativeTokens.totalTokens
       } : null
     },
-    retry: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
-      due_at: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
-      kind: currentRun?.retryKind ?? null,
-      error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null
+    retry: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
+      due_at: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
+      kind: resolvedRun?.retryKind ?? null,
+      error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null
     } : null,
     logs: {
-      codex_session_logs: currentRun === null ? [] : [
+      codex_session_logs: resolvedRun === null ? [] : [
         {
           label: "worker",
-          path: join(reader.runDir(currentRun.runId), "worker.log"),
+          path: join(reader.runDir(resolvedRun.runId), "worker.log"),
           url: null
         }
       ]
     },
     recent_events: recentEvents,
-    last_error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
+    last_error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
     tracked: {
       issue_orchestration_state: issueRecord.state,
       current_run_id: issueRecord.currentRunId,
       workspace_key: issueRecord.workspaceKey,
       completed_once: issueRecord.completedOnce,
-      run_phase: currentRun?.runPhase ?? null,
-      execution_phase: currentRun?.executionPhase ?? null
+      run_phase: resolvedRun?.runPhase ?? null,
+      execution_phase: resolvedRun?.executionPhase ?? null
     }
   };
 }
-async function findLatestRunForIssue(reader, issueId, issueIdentifier) {
-  const matchingRuns = (await reader.loadAllRuns()).filter((run) => run.issueId === issueId || run.issueIdentifier === issueIdentifier).sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
-  return matchingRuns[0] ?? null;
+function aggregateIssueTokenUsage(runs) {
+  return runs.reduce((total, run) => ({
+    inputTokens: total.inputTokens + (run.tokenUsage?.inputTokens ?? 0),
+    outputTokens: total.outputTokens + (run.tokenUsage?.outputTokens ?? 0),
+    totalTokens: total.totalTokens + (run.tokenUsage?.totalTokens ?? 0)
+  }), {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  });
+}
+function findLatestRunForIssue(matchingRuns) {
+  const sortedRuns = [...matchingRuns].sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+  return sortedRuns[0] ?? null;
 }
 function assertValidDashboardProjectId(projectId) {
   if (projectId.length === 0 || projectId === "." || projectId === ".." || projectId.includes("/") || projectId.includes("\\")) {