agent-orchestrator-kit 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-09-04
+
+### Fixed
+- **Amp Cost-once rollup, restore `amp-session-last`, leftover thread-scope.** After persist/recompute, Amp `Cost: $N` is added once **per qualifying session** into `spend.costUsd`, `spendByPlatform.amp.costUsd`, and `phases.*.costUsd` when that session’s `sources[].costUsd` are all null — never copied onto each source (not ×N); several Amp sessions accumulate. Restore without Amp parent locks a fresh `session.json` `lastThreadId` as `amp-session-last` (Amp parent without tty still uses `amp threads list`). Leftover without `--collect` scopes to `last.platform` and the Amp thread id / `T-…` prefix; an explicit `ampThreadId` does not add the env thread. Leftover after `amp-usage` resyncs tokens from sources and keeps billed Cost; `usageModels` stay unique to that thread; `pending.role` is the canonical token.
+
+## [0.12.0] - 2026-09-02
+
+### Fixed
+- **Cursor leftover race, multi-root, 4-decimal estimates, and per-phase clock.** `stop` / `afterAgentResponse` run leftover immediately after a successful jsonl append (fail-open, no stdout); `sessionEnd` leftover stays and stays idempotent. Leftover filters `last.threadId` when it is non-empty and stays time-only when it is `null` or `''`. Hook and collect resolve the consumer in a multi-root window (not the first cwd with `.agents` or `openspec`); leftover walks every candidate that has `openspec/changes`. Written `costUsdEstimated` aggregates are rounded to 4 decimals after sums (`2.3911 + 2.8153 + 1.355 === 6.5614`). Each `phases.<phase>` now stores `startedAt` / `endedAt` / `leadTimeMs` from that phase’s sessions (epoch ms); `durationMs` remains the work-time sum and does not clone `totals.leadTimeMs`.
+
 ## [0.11.0] - 2026-09-02
 
 ### Changed
@@ -266,6 +276,8 @@ All notable changes to this project will be documented in this file.
 ### Added
 - Initial release: 5-role orchestration pipeline, `/opsx:*` commands, IDE sync
 
+[0.13.0]: https://github.com/makshc2/agent-orchestrator-kit/compare/v0.12.0...v0.13.0
+[0.12.0]: https://github.com/makshc2/agent-orchestrator-kit/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/makshc2/agent-orchestrator-kit/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/makshc2/agent-orchestrator-kit/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/makshc2/agent-orchestrator-kit/compare/v0.8.0...v0.9.0

package/README.md

@@ -74,7 +74,7 @@ npx agent-orchestrator-kit@latest init --profile generic --ci gitlab --spec-veri
 
 See [Installation](#installation) for profile/CI options.
 
-**🔄 Already have the kit installed? Upgrade to latest (session attribution + Cursor estimate/dedup in v0.11.0; Cursor fallback estimate + first-class `costUsdEstimated` in v0.10.0; UTC timestamps + Amp stamp parse, Amp billed `$`, Cursor API estimate, archive auto-collect in v0.9.0; locked Amp/Cursor client in v0.8.0; `## Metrics` self-report + opt-in `--collect` in v0.7.0 — **BREAKING:** `--no-collect` is gone; change metrics in v0.5.0+, factory phases 1–3 in v0.4.0+, lean pipeline / archive CLI in v0.3.0+, handoff CLI in v0.1.14+, Figma PAT in v0.1.11+):**
+**🔄 Already have the kit installed? Upgrade to latest (Amp Cost-once rollup + `amp-session-last` + leftover thread-scope in v0.13.0; Cursor leftover race + multi-root + per-phase clock in v0.12.0; session attribution + Cursor estimate/dedup in v0.11.0; Cursor fallback estimate + first-class `costUsdEstimated` in v0.10.0; UTC timestamps + Amp stamp parse, Amp billed `$`, Cursor API estimate, archive auto-collect in v0.9.0; locked Amp/Cursor client in v0.8.0; `## Metrics` self-report + opt-in `--collect` in v0.7.0 — **BREAKING:** `--no-collect` is gone; change metrics in v0.5.0+, factory phases 1–3 in v0.4.0+, lean pipeline / archive CLI in v0.3.0+, handoff CLI in v0.1.14+, Figma PAT in v0.1.11+):**
 
 ```bash
 npx agent-orchestrator-kit@latest update
@@ -804,16 +804,17 @@ Every change accumulates git-tracked `openspec/changes/<name>/metrics.json` —
 - **`## Metrics` self-report** — Session Exit fills `handoff.md` with `platform`, `model`, `input_tokens`, `output_tokens`, `cost_usd`, `amp_credits`, `spend_source` (`unknown` when missing). Persist reads that section; `metrics.json` is the source of truth for what landed. CLI flags do not rewrite the section.
 - **`session.model`** — source product id wins when any collected source has a model; `--model` / `## Metrics: model` / `AOK_MODEL` apply only when sources have no model. Never a Closed role.
 - **Session start** — `handoff --restore` writes a `pending` marker (`startedAt`, expected role).
-- **Session end** — `handoff <name>` closes the pending session: duration, closed role, mapped phase (`explore` / `design` / `spec` / `review` / `apply` / `archive`), runtime (local/cloud), tasks snapshot (`n/m`), and spend from flags → self-report → adapters. Persist collect window is `[pending.startedAt, endedAt]`; a late hook after persist goes to leftover of that session, not the next persist. `--input-tokens` / `--output-tokens` / `--total-tokens` / `--cost-usd` override session totals only and do not wipe `spendByPlatform` / `spendByModel`. Amp billed USD comes from `amp threads usage --details` (`Cost: $N` only; missing line → `costUsd: null`), not from converting credits. Cursor always writes a labeled `costUsdEstimated` when tokens exist: grok-4.6/4.5 use xAI API rates (`costSource: api-estimate`, including `-fast` and the 200k cliff); other models use a versioned fallback of $3/1M input + $15/1M output (or $3.50/1M when only `totalTokens` is present, `costSource: api-estimate-fallback`). That estimate is **not** the Cursor invoice and is never added into billed `costUsd`. Timestamps are ISO-8601 UTC (`…Z`). No restore marker? Pass `--started-at <iso>` or the duration stays honestly `null`.
+- **Session end** — `handoff <name>` closes the pending session: duration, closed role, mapped phase (`explore` / `design` / `spec` / `review` / `apply` / `archive`), runtime (local/cloud), tasks snapshot (`n/m`), and spend from flags → self-report → adapters. Persist collect window is `[pending.startedAt, endedAt]`; a late hook after persist goes to leftover of that session, not the next persist. `--input-tokens` / `--output-tokens` / `--total-tokens` / `--cost-usd` override session totals only and do not wipe `spendByPlatform` / `spendByModel`. Amp billed USD comes from `amp threads usage --details` (`Cost: $N` only; missing line → `costUsd: null`), not from converting credits. After persist/recompute, that Cost is a **Cost-once rollup**: once **per qualifying session** into `spend.costUsd` / `spendByPlatform.amp.costUsd` / `phases.*.costUsd` when that session’s `sources[].costUsd` are all null — never copied onto each source (not ×N); several Amp sessions accumulate. Cursor always writes a labeled `costUsdEstimated` when tokens exist: grok-4.6/4.5 use xAI API rates (`costSource: api-estimate`, including `-fast` and the 200k cliff); other models use a versioned fallback of $3/1M input + $15/1M output (or $3.50/1M when only `totalTokens` is present, `costSource: api-estimate-fallback`). That estimate is **not** the Cursor invoice and is never added into billed `costUsd`. Timestamps are ISO-8601 UTC (`…Z`). No restore marker? Pass `--started-at <iso>` or the duration stays honestly `null`.
 - **Archive** — successful `archive <name>` always creates or finalizes `metrics.json`, sets `archivedAt`, appends an Archiver session, collects the locked client (Cursor hook / Amp export+usage / Claude JSONL) in `[pending.startedAt, now]` plus leftover of the previous session, and prints the same human summary as `metrics <name>`. `--collect` still runs all three adapters. Leftover apply `## Metrics` that repeats the previous session is ignored so those tokens are not counted twice.
-- **`sessionEnd` leftover** — `scripts/cursor-spend-collect.cjs` also reads the newest `openspec/changes/archive/*-<name>/metrics.json` when the active change folder is gone, so a late hook after archive still attaches.
-- **Cursor `conversationId`** — restore writes `CURSOR_CONVERSATION_ID` into `pending.threadId`; Cursor collect skips rows whose `conversationId` does not match when a filter id is present.
-- **Canonical role** — `session.role` stores the first known token (`Explorer`, `Architect`, `Spec Reviewer`, `Implementer`, `Archiver`, `Design Intake`); Closed role in `handoff.md` MAY keep a sentence after `—`.
+- **`sessionEnd` leftover** — `scripts/cursor-spend-collect.cjs` also reads the newest `openspec/changes/archive/*-<name>/metrics.json` when the active change folder is gone, so a late hook after archive still attaches. `stop` / `afterAgentResponse` run the same leftover after a successful jsonl append. When `last.threadId` is non-empty, leftover keeps only rows whose `conversationId` matches that id (empty/`null` threadId stays time-only). In a multi-root window leftover walks every candidate that has `openspec/changes`, reading that root’s jsonl. Aggregates write `costUsdEstimated` with 4 decimal places. Each `phases.<phase>` stores `startedAt` / `endedAt` / `leadTimeMs` from that phase’s sessions; `durationMs` stays the work-time sum and does not clone `totals.leadTimeMs`.
+- **Leftover without `--collect`** — Scopes to `last.platform` and, for Amp, leftover **thread-scope**: the session thread id or the `T-…` prefix from `sources[].id` (`T-apply:8` → `T-apply`). An explicit `ampThreadId` does not also add the env thread. After `amp-usage`, leftover **token resync** sums tokens from all sources and keeps billed Cost (`spendSource: amp-usage`). `usageModels` stay unique to that thread.
+- **Cursor `conversationId`** — restore writes `CURSOR_CONVERSATION_ID` into `pending.threadId`; Cursor collect and sessionEnd leftover skip rows whose `conversationId` does not match when a filter id is present (`last.threadId` on leftover).
+- **Canonical role** — `session.role` and `pending.role` store the first known token (`Explorer`, `Architect`, `Spec Reviewer`, `Implementer`, `Archiver`, `Design Intake`); Closed role in `handoff.md` MAY keep a sentence after `—`.
 - **Platform** — `--platform` → `## Metrics: platform` → `AOK_PLATFORM` → **pending client from `--restore`** → host env (Amp / Cursor / Claude Code) → collected sources (`cursor|claude|amp` only). Invalid `--platform` fails before persist/move.
-- **Locked client** — `--restore` records `pending.platform` and Amp `pending.threadId` before phase work. Persist follows that client’s flow even if persist runs in another shell (no `AMP_*` / `CURSOR_*`). Amp: `amp threads export` plus `amp threads usage --details` (`AOK_AMP_BIN`) and local `threads/*.json`. Export supplies `model` / tokens / `agentMode`; usage supplies billed `$`. If Amp runs tools over a pipe (`/dev/null`), thread id comes from `amp threads list`, not stale `session.json` `lastThreadId`. Cursor: spend hook file. Claude: `~/.claude/projects`. `--collect` still runs all three adapters.
-- **Cursor spend hook (optional)** — Cursor never writes token usage to disk, so the kit can install `scripts/cursor-spend-hook.cjs` plus `.cursor/hooks.json` entries (`stop` / `subagentStop` / `afterAgentResponse`) in `init` / `update` / `sync` / `mcp-setup`: the hook appends each turn's tokens to gitignored `.agents/spend/cursor-usage.jsonl`. Persist auto-reads that file when the locked client is Cursor. Persist and restore do not self-heal the hook. `sessionEnd` still runs `scripts/cursor-spend-collect.cjs`. Restart Cursor once after the first install. `status` shows a `Spend capture` section. Claude JSONL remains a fallback. Amp web/CLI spend is taken from `amp threads export` (tokens, model, `agentMode`) and `amp threads usage` (billed USD).
+- **Locked client** — `--restore` records `pending.platform` and Amp `pending.threadId` before phase work. Persist follows that client’s flow even if persist runs in another shell (no `AMP_*` / `CURSOR_*`). Amp: `amp threads export` plus `amp threads usage --details` (`AOK_AMP_BIN`) and local `threads/*.json`. Export supplies `model` / tokens / `agentMode`; usage supplies billed `$`. If Amp runs tools over a pipe (`/dev/null`), thread id comes from `amp threads list`, not stale `session.json` `lastThreadId`. When env and Amp parent do not win, restore locks a fresh `session.json` `lastThreadId` as `amp-session-last`. Cursor: spend hook file. Claude: `~/.claude/projects`. `--collect` still runs all three adapters.
+- **Cursor spend hook (optional)** — Cursor never writes token usage to disk, so the kit can install `scripts/cursor-spend-hook.cjs` plus `.cursor/hooks.json` entries (`stop` / `subagentStop` / `afterAgentResponse`) in `init` / `update` / `sync` / `mcp-setup`: the hook appends each turn's tokens to gitignored `.agents/spend/cursor-usage.jsonl`. After a successful `stop` / `afterAgentResponse` append the hook runs leftover (fail-open, no stdout). Hook and collect resolve the consumer in a multi-root window (not the first cwd with `.agents` or `openspec`). Persist auto-reads that file when the locked client is Cursor. Persist and restore do not self-heal the hook. `sessionEnd` still runs `scripts/cursor-spend-collect.cjs`. Restart Cursor once after the first install. `status` shows a `Spend capture` section. Claude JSONL remains a fallback. Amp web/CLI spend is taken from `amp threads export` (tokens, model, `agentMode`) and `amp threads usage` (billed USD).
 
-Aggregates are recomputed on every write: per-phase totals (`durationMs`, tokens, `costUsd`, `sessions`, `roles`, `models`) plus overall `totals` (`sessions`, `cloudSessions`, `durationMs` = sum of session work time, `leadTimeMs` = wall clock from first session start to last session end), `spend` (USD only), and separate **by platform** / **by model** tables. Numbers are null-honest: a metric nobody reported stays `null`, never a fake `0`. No single total that adds Amp credits to USD.
+Aggregates are recomputed on every write: per-phase totals (`startedAt`, `endedAt`, `leadTimeMs` from that phase’s sessions, `durationMs` = sum of session work time — not `totals.leadTimeMs` and not `endedAt − startedAt`, tokens, `costUsd`, `costUsdEstimated` to 4 decimals, `sessions`, `roles`, `models`) plus overall `totals` (`sessions`, `cloudSessions`, `durationMs` = sum of session work time, `leadTimeMs` = wall clock from first session start to last session end), `spend` (USD only), and separate **by platform** / **by model** tables. Numbers are null-honest: a metric nobody reported stays `null`, never a fake `0`. No single total that adds Amp credits to USD.
 
 Fill `## Metrics` in `handoff.md` **before** persist (unknown is fine; do not invent `0`):
 
@@ -1006,6 +1007,16 @@ Phase bounds and non-goals: [`openspec/specs/agentic-factory-roadmap/spec.md`](o
 
 ## Changelog
 
+### 0.13.0
+- Amp Cost-once rollup: `Cost: $N` once per qualifying session into `spend` / `spendByPlatform.amp` / `phases` (not ×N sources; several sessions accumulate)
+- Restore without Amp parent locks a fresh `session.json` `lastThreadId` as `amp-session-last`
+- Leftover without `--collect` scopes to `last.platform` and Amp thread / `T-…` prefix; leftover after `amp-usage` resyncs tokens and keeps billed Cost
+
+### 0.12.0
+- Cursor leftover after `stop` / `afterAgentResponse` (fail-open, idempotent `sessionEnd`); leftover filters `last.threadId` when it is set
+- Multi-root hook/collect resolve the consumer window; leftover walks every candidate with `openspec/changes`
+- `costUsdEstimated` aggregates write 4 decimals; `phases.<phase>` stores `startedAt` / `endedAt` / `leadTimeMs` (work-time `durationMs` is not `totals.leadTimeMs`)
+
 ### 0.11.0
 - Session metrics attribution: persist collect is `[pending.startedAt, endedAt]`; a late hook stays leftover of that session; archive is `[pending.startedAt, now]` plus leftover of the previous session
 - Source product id wins for `session.model`; `--model` / `## Metrics` / `AOK_MODEL` apply only when sources have none

package/bin/agent-orchestrator.js

@@ -1615,6 +1615,11 @@ const METRICS_VERSION = 1;
 const METRICS_SPEND_KEYS = ['inputTokens', 'outputTokens', 'totalTokens', 'costUsd', 'costUsdEstimated'];
 const LEFTOVER_GRACE_MS = 120000;
 
+function roundUsd4(x) {
+  if (x == null) return null;
+  return Math.round(Number(x) * 10000) / 10000;
+}
+
 function metricsFilePath(projectDir, changeName) {
   return join(projectDir, 'openspec', 'changes', changeName, 'metrics.json');
 }
@@ -1783,12 +1788,64 @@ function leftoverTimestampInWindow(at, windowStart, leftoverEnd, exclusiveEnd) {
   return true;
 }
 
+function uniqueAmpSourceThreadPrefix(sources) {
+  const prefixes = [];
+  for (const src of sources || []) {
+    const id = src && src.id != null ? String(src.id) : '';
+    if (!id.startsWith('T-')) continue;
+    const prefix = id.split(':')[0];
+    if (!prefix) continue;
+    if (!prefixes.includes(prefix)) prefixes.push(prefix);
+  }
+  return prefixes.length === 1 ? prefixes[0] : null;
+}
+
+function leftoverAmpThreadId(session) {
+  if (!session) return null;
+  if (session.threadId) return String(session.threadId);
+  return uniqueAmpSourceThreadPrefix(session.sources);
+}
+
+function sessionAmpThreadKeys(session) {
+  const keys = new Set();
+  if (session && session.threadId) keys.add(String(session.threadId));
+  for (const src of (session && session.sources) || []) {
+    const id = src && src.id != null ? String(src.id) : '';
+    if (!id.startsWith('T-')) continue;
+    const prefix = id.split(':')[0];
+    if (prefix) keys.add(prefix);
+  }
+  return keys;
+}
+
+function usageModelTokenCount(row) {
+  const total = numOrNull(row && row.totalTokens);
+  if (total != null) return total;
+  return (numOrNull(row && row.inputTokens) ?? 0) + (numOrNull(row && row.outputTokens) ?? 0);
+}
+
+function usageModelsForSession(session, ampThreads) {
+  const allowed = sessionAmpThreadKeys(session);
+  const byModel = new Map();
+  for (const thread of ampThreads || []) {
+    const id = thread && thread.id != null ? String(thread.id) : '';
+    if (!allowed.has(id)) continue;
+    for (const row of (thread && thread.models) || []) {
+      if (!row || !row.model) continue;
+      const key = String(row.model);
+      const prev = byModel.get(key);
+      if (!prev || usageModelTokenCount(row) >= usageModelTokenCount(prev)) {
+        byModel.set(key, row);
+      }
+    }
+  }
+  return [...byModel.values()];
+}
+
 function sessionSpendIsFrozen(session) {
   if (!session) return false;
   if (session.spendSource === 'flag') return true;
-  if (!reportedHasSpendNumbers(session)) return false;
-  if (!session.spendSource || session.spendSource === 'adapter' || session.spendSource === 'unreported') return false;
-  return true;
+  return session.spendSource === 'self-report' && reportedHasSpendNumbers(session);
 }
 
 function existingSourceRecords(metrics) {
@@ -1902,7 +1959,7 @@ function sourceEstimatedUsd(sources) {
   for (const src of sources || []) {
     sum = addNullable(sum, numOrNull(src.costUsdEstimated));
   }
-  return sum;
+  return roundUsd4(sum);
 }
 
 function ampThreadTotals(threads) {
@@ -1989,41 +2046,90 @@ function sessionTotalsFromSources(sources) {
 function runCollectSpend(metrics, windowStart, windowEnd, extra = {}) {
   try {
     return collectSpend({
-      cwd: process.cwd(),
+      cwd: extra.cwd || process.cwd(),
       windowStart,
       windowEnd,
       existingSourceIds: existingSourceIdSet(metrics),
       existingSources: existingSourceRecords(metrics),
-      env: process.env,
-      homedir: process.env.HOME,
+      env: extra.env || process.env,
+      homedir: extra.homedir || process.env.HOME,
       platforms: extra.platforms,
       ampThreadId: extra.ampThreadId,
       ampCli: extra.ampCli === true,
       cursorConversationId: extra.cursorConversationId,
       exportAmpThread: extra.exportAmpThread,
       usageAmpThread: extra.usageAmpThread,
+      listRecentAmpThreads: extra.listRecentAmpThreads,
+      listAmpThreads: extra.listAmpThreads,
     });
   } catch {
     return { sources: [], byPlatform: defaultSpendByPlatform(), byModel: [], notes: [] };
   }
 }
 
+function leftoverCollectPlatforms(session, collectAll, ampThreadId) {
+  if (collectAll) return undefined;
+  if (session.platform === 'amp' || session.platform === 'cursor' || session.platform === 'claude') {
+    if (session.platform === 'amp' && !ampThreadId) return [];
+    return [session.platform];
+  }
+  if (session.platform == null && ampThreadId) return ['amp'];
+  return [];
+}
+
+function resyncLeftoverSessionSpend(session, priorCost, priorSource) {
+  const fromSources = sessionTotalsFromSources(session.sources || []);
+  session.inputTokens = fromSources.inputTokens;
+  session.outputTokens = fromSources.outputTokens;
+  let totalTokens = fromSources.totalTokens;
+  if (totalTokens == null && (fromSources.inputTokens != null || fromSources.outputTokens != null)) {
+    totalTokens = (fromSources.inputTokens ?? 0) + (fromSources.outputTokens ?? 0);
+  }
+  session.totalTokens = totalTokens;
+  if (fromSources.costUsd == null && priorCost != null) {
+    session.costUsd = priorCost;
+  }
+  if (priorSource === 'amp-usage' && numOrNull(session.costUsd) != null) {
+    session.spendSource = 'amp-usage';
+  }
+}
+
 function attachLeftoverSources(metrics, session, leftoverEnd, extra = {}) {
   if (!session || !session.endedAt || !leftoverEnd) return 0;
   const exclusiveEnd = extra.exclusiveEnd === true;
+  const collectAll = extra.collect === true;
+  const ampThreadId = leftoverAmpThreadId(session);
+  const platforms = leftoverCollectPlatforms(session, collectAll, ampThreadId);
+  if (!collectAll && (!Array.isArray(platforms) || platforms.length === 0)) return 0;
+  const collectAmp = collectAll || (Array.isArray(platforms) && platforms.includes('amp'));
+  const collectCursor = collectAll || (Array.isArray(platforms) && platforms.includes('cursor'));
   const collected = runCollectSpend(metrics, session.endedAt, leftoverEnd, {
-    platforms: extra.platforms,
-    ampThreadId: session.threadId || extra.ampThreadId || ampThreadIdFromEnv(process.env) || null,
-    ampCli: extra.ampCli === true || session.platform === 'amp',
+    platforms,
+    ...(ampThreadId ? { ampThreadId } : {}),
+    listRecentAmpThreads: false,
+    ampCli: extra.ampCli === true || collectAmp,
     cursorConversationId: extra.cursorConversationId
-      || (session.platform === 'cursor' ? session.threadId : undefined),
+      || (collectCursor && session.platform === 'cursor' ? session.threadId : undefined),
+    exportAmpThread: extra.exportAmpThread,
+    usageAmpThread: extra.usageAmpThread,
+    listAmpThreads: extra.listAmpThreads,
+    env: extra.env,
+    cwd: extra.cwd,
+    homedir: extra.homedir,
   });
-  const incoming = (collected.sources || []).filter((src) => leftoverTimestampInWindow(
+  let incoming = (collected.sources || []).filter((src) => leftoverTimestampInWindow(
     src.at,
     session.endedAt,
     leftoverEnd,
     exclusiveEnd,
   ));
+  if (ampThreadId) {
+    const prefix = `${ampThreadId}:`;
+    incoming = incoming.filter((src) => {
+      if (src && src.platform === 'amp') return String(src.id || '').startsWith(prefix);
+      return true;
+    });
+  }
   if (!incoming.length) return 0;
   const merged = [...(session.sources || []), ...incoming];
   if (sessionSpendIsFrozen(session)) {
@@ -2031,10 +2137,13 @@ function attachLeftoverSources(metrics, session, leftoverEnd, extra = {}) {
     const uniqueModels = uniqueSourceModels(merged);
     if (uniqueModels.length > 1) session.models = uniqueModels;
   } else {
+    const priorCost = numOrNull(session.costUsd);
+    const priorSource = session.spendSource;
     applyCollectedSessionFields(session, merged, session.model, {}, {
       model: session.model,
       platform: session.platform,
-    }, { ampThreads: collected.ampThreads });
+    }, { ampThreads: Array.isArray(extra.ampThreads) ? extra.ampThreads : collected.ampThreads });
+    resyncLeftoverSessionSpend(session, priorCost, priorSource);
   }
   return incoming.length;
 }
@@ -2065,13 +2174,10 @@ function applyCollectedSessionFields(session, sources, resolvedModel, opts, repo
   session.costUsdEstimated = spend.costUsdEstimated;
   session.spendSource = spend.spendSource;
   if (spend.agentMode) session.agentMode = spend.agentMode;
-  const usageModels = [];
-  for (const thread of extra.ampThreads || []) {
-    for (const row of thread.models || []) {
-      if (row && row.model) usageModels.push(row);
-    }
+  const usageModels = usageModelsForSession(session, extra.ampThreads);
+  if (usageModels.length || Array.isArray(session.usageModels)) {
+    session.usageModels = usageModels;
   }
-  if (usageModels.length) session.usageModels = usageModels;
 }
 
 function sessionTotalsLookOverridden(session) {
@@ -2194,6 +2300,14 @@ function recomputeSpendMaps(metrics) {
     const sources = session.sources || [];
     if (sources.length > 0) {
       for (const src of sources) addSourceRow(src);
+      let sourceCost = null;
+      for (const src of sources) sourceCost = addNullable(sourceCost, numOrNull(src.costUsd));
+      if (sourceCost == null && session.platform && byPlatform[session.platform]) {
+        byPlatform[session.platform].costUsd = addNullable(
+          byPlatform[session.platform].costUsd,
+          numOrNull(session.costUsd),
+        );
+      }
       continue;
     }
     const sessionNums = spendTuple(session);
@@ -2202,6 +2316,12 @@ function recomputeSpendMaps(metrics) {
     }
     addModelRow(session.model, session.platform, sessionNums);
   }
+  for (const key of Object.keys(byPlatform)) {
+    byPlatform[key].costUsdEstimated = roundUsd4(byPlatform[key].costUsdEstimated);
+  }
+  for (const row of byModel.values()) {
+    row.costUsdEstimated = roundUsd4(row.costUsdEstimated);
+  }
   metrics.spendByPlatform = byPlatform;
   metrics.spendByModel = [...byModel.values()];
 }
@@ -2214,20 +2334,51 @@ function recomputeMetricsAggregates(metrics) {
   let firstStart = null;
   let lastEnd = null;
   for (const session of metrics.sessions) {
+    session.costUsdEstimated = roundUsd4(session.costUsdEstimated);
     totals.sessions += 1;
     if (session.runtime === 'cloud') totals.cloudSessions += 1;
     totals.durationMs = addNullable(totals.durationMs, numOrNull(session.durationMs));
-    if (session.startedAt) firstStart = firstStart == null ? session.startedAt : earlierTimestamp(firstStart, session.startedAt);
-    if (session.endedAt) lastEnd = lastEnd == null ? session.endedAt : laterTimestamp(lastEnd, session.endedAt);
+    if (Number.isFinite(parseFlexibleIso(session.startedAt))) {
+      firstStart = firstStart == null ? session.startedAt : earlierTimestamp(firstStart, session.startedAt);
+    }
+    if (Number.isFinite(parseFlexibleIso(session.endedAt))) {
+      lastEnd = lastEnd == null ? session.endedAt : laterTimestamp(lastEnd, session.endedAt);
+    }
     const key = session.phase || 'other';
-    const phase = phases[key] || { sessions: 0, durationMs: null, ...emptySpendTotals(), agents: [], models: [] };
+    const phase = phases[key] || {
+      sessions: 0,
+      durationMs: null,
+      startedAt: null,
+      endedAt: null,
+      leadTimeMs: null,
+      ...emptySpendTotals(),
+      agents: [],
+      models: [],
+    };
     phase.sessions += 1;
     phase.durationMs = addNullable(phase.durationMs, numOrNull(session.durationMs));
+    if (Number.isFinite(parseFlexibleIso(session.startedAt))) {
+      phase.startedAt = phase.startedAt == null
+        ? session.startedAt
+        : earlierTimestamp(phase.startedAt, session.startedAt);
+    }
+    if (Number.isFinite(parseFlexibleIso(session.endedAt))) {
+      phase.endedAt = phase.endedAt == null
+        ? session.endedAt
+        : laterTimestamp(phase.endedAt, session.endedAt);
+    }
+    const sources = session.sources || [];
+    let sourceCost = null;
+    for (const src of sources) sourceCost = addNullable(sourceCost, numOrNull(src.costUsd));
     for (const spendKey of METRICS_SPEND_KEYS) {
       let value = null;
-      if ((session.sources || []).length > 0) {
-        for (const src of session.sources) {
-          value = addNullable(value, numOrNull(src[spendKey]));
+      if (sources.length > 0) {
+        if (spendKey === 'costUsd') {
+          value = sourceCost == null ? numOrNull(session.costUsd) : sourceCost;
+        } else {
+          for (const src of sources) {
+            value = addNullable(value, numOrNull(src[spendKey]));
+          }
         }
       } else {
         value = sessionFieldOrSources(session, spendKey);
@@ -2247,6 +2398,15 @@ function recomputeMetricsAggregates(metrics) {
   if (firstStart && lastEnd) {
     totals.leadTimeMs = Math.max(0, parseFlexibleIso(lastEnd) - parseFlexibleIso(firstStart));
   }
+  for (const phase of Object.values(phases)) {
+    const startMs = parseFlexibleIso(phase.startedAt);
+    const endMs = parseFlexibleIso(phase.endedAt);
+    phase.leadTimeMs = Number.isFinite(startMs) && Number.isFinite(endMs)
+      ? Math.max(0, endMs - startMs)
+      : null;
+    phase.costUsdEstimated = roundUsd4(phase.costUsdEstimated);
+  }
+  spend.costUsdEstimated = roundUsd4(spend.costUsdEstimated);
   metrics.phases = phases;
   metrics.totals = totals;
   metrics.spend = spend;
@@ -2259,7 +2419,7 @@ function metricsRecordSessionStart(projectDir, changeName, role, client = {}) {
   const metrics = loadMetricsFile(filePath, changeName, nowIso);
   metrics.pending = {
     startedAt: nowIso,
-    role: role || '',
+    role: canonicalRole(role) || role || '',
     platform: client.platform || null,
     threadId: client.threadId || null,
     clientSource: client.source || null,
@@ -2280,6 +2440,7 @@ function metricsRecordSessionEnd(projectDir, fields, opts = {}) {
     : leftoverGraceEnd(lastClosed && lastClosed.endedAt);
   attachLeftoverSources(metrics, lastClosed, leftoverEnd, {
     exclusiveEnd: Boolean(metrics.pending && metrics.pending.startedAt),
+    collect: opts.collect === true,
   });
   let startedAt = isoOrNull(opts.startedAt) || isoOrNull(metrics.pending && metrics.pending.startedAt) || null;
   const reported = opts.reported || fields.metrics || emptyMetricsFields();
@@ -2420,7 +2581,7 @@ function metricsFinalizeArchive(targetDir, changeName, opts = {}) {
   return filePath;
 }
 
-function metricsPrepareArchiveStart(changeRoot, changeName, client = {}) {
+function metricsPrepareArchiveStart(changeRoot, changeName, client = {}, extra = {}) {
   const filePath = join(changeRoot, 'metrics.json');
   if (!existsSync(filePath)) return;
   const nowIso = nowUtcIso();
@@ -2437,6 +2598,7 @@ function metricsPrepareArchiveStart(changeRoot, changeName, client = {}) {
   const leftoverEnd = metrics.pending && metrics.pending.startedAt;
   attachLeftoverSources(metrics, lastNonArchiverSession(metrics.sessions), leftoverEnd, {
     exclusiveEnd: true,
+    collect: extra.collect === true,
   });
   metrics.updatedAt = nowIso;
   recomputeMetricsAggregates(metrics);
@@ -3832,7 +3994,7 @@ program
       homedir: process.env.HOME,
       platform: opts.platform,
     });
-    metricsPrepareArchiveStart(changeRoot, name, archiveClient);
+    metricsPrepareArchiveStart(changeRoot, name, archiveClient, { collect: opts.collect === true });
     mkdirSync(dirname(targetDir), { recursive: true });
     renameSync(changeRoot, targetDir);
 
@@ -4403,4 +4565,13 @@ if (isDirectCliRun()) {
   program.parse();
 }
 
-export { formatMetricsCostLine, resolveSessionSpend, canonicalRole, phaseForRole };
+export {
+  formatMetricsCostLine,
+  resolveSessionSpend,
+  canonicalRole,
+  phaseForRole,
+  recomputeMetricsAggregates,
+  sessionSpendIsFrozen,
+  attachLeftoverSources,
+  runCollectSpend,
+};

package/bin/session-client.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readlinkSync } from 'fs';
+import { existsSync, readFileSync, readlinkSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir as osHomedir } from 'os';
 import { execFileSync } from 'child_process';
@@ -114,28 +114,68 @@ function isFreshTimestamp(value, now, maxAgeMs) {
   return now - n >= 0 && now - n <= maxAgeMs;
 }
 
+function isSessionFileFresh(updatedAt, filePath, now, maxAgeMs) {
+  if (updatedAt != null && updatedAt !== '') {
+    return isFreshTimestamp(updatedAt, now, maxAgeMs);
+  }
+  try {
+    return isFreshTimestamp(statSync(filePath).mtimeMs, now, maxAgeMs);
+  } catch {
+    return false;
+  }
+}
+
+function emptyAmpSessionHint(filePath, fileFresh, updatedAt) {
+  return {
+    threadId: '',
+    source: '',
+    lastThreadId: '',
+    filePath: filePath || '',
+    fileFresh: Boolean(fileFresh),
+    updatedAt: updatedAt == null ? '' : updatedAt,
+  };
+}
+
 export function readAmpSessionHint(options = {}) {
   const env = options.env || {};
   const homedir = options.homedir || env.HOME;
   const now = options.now != null ? Number(options.now) : Date.now();
   const maxAgeMs = options.maxAgeMs != null ? Number(options.maxAgeMs) : AMP_TTY_MAX_AGE_MS;
   const filePath = join(ampDataRoot(env, homedir), 'session.json');
-  if (!existsSync(filePath)) return { threadId: '', source: '' };
+  if (!existsSync(filePath)) return emptyAmpSessionHint(filePath, false, '');
   let data;
   try {
     data = JSON.parse(readFileSync(filePath, 'utf-8'));
   } catch {
-    return { threadId: '', source: '' };
+    return emptyAmpSessionHint(filePath, isSessionFileFresh('', filePath, now, maxAgeMs), '');
+  }
+  if (!data || typeof data !== 'object') {
+    return emptyAmpSessionHint(filePath, isSessionFileFresh('', filePath, now, maxAgeMs), '');
   }
-  if (!data || typeof data !== 'object') return { threadId: '', source: '', lastThreadId: '' };
   const lastThreadId = trim(data.lastThreadId);
+  const updatedAt = data.updatedAt;
+  const fileFresh = isSessionFileFresh(updatedAt, filePath, now, maxAgeMs);
   const rawTty = options.ttyKey != null ? options.ttyKey : currentTtyKey(env, options.readlink);
   const ttyKey = isUsableTtyPath(rawTty) ? (String(rawTty).startsWith('tty:') ? rawTty : `tty:${rawTty}`) : '';
   const byTty = data.lastThreadByTerminal && ttyKey ? data.lastThreadByTerminal[ttyKey] : null;
   if (byTty && trim(byTty.lastThreadId) && isFreshTimestamp(byTty.updatedAt, now, maxAgeMs)) {
-    return { threadId: trim(byTty.lastThreadId), source: 'amp-session-tty', lastThreadId };
+    return {
+      threadId: trim(byTty.lastThreadId),
+      source: 'amp-session-tty',
+      lastThreadId,
+      filePath,
+      fileFresh,
+      updatedAt,
+    };
   }
-  return { threadId: '', source: '', lastThreadId };
+  return {
+    threadId: '',
+    source: '',
+    lastThreadId,
+    filePath,
+    fileFresh,
+    updatedAt,
+  };
 }
 
 export function detectSessionClient(options = {}) {
@@ -168,6 +208,15 @@ export function detectSessionClient(options = {}) {
   if (hint.threadId) {
     return { platform: 'amp', threadId: hint.threadId, source: hint.source };
   }
+  if (hint.lastThreadId && hint.fileFresh) {
+    return { platform: 'amp', threadId: hint.lastThreadId, source: 'amp-session-last' };
+  }
+  if (hint.fileFresh) {
+    const listed = listRecentAmpThreadIds(options);
+    if (listed[0]) {
+      return { platform: 'amp', threadId: listed[0], source: 'amp-session-list' };
+    }
+  }
 
   return { platform: null, threadId: null, source: 'none' };
 }

package/bin/spend-collect.js

@@ -504,8 +504,10 @@ function collectAmpCli(ctx) {
     if (id && !ids.includes(id)) ids.push(id);
   };
   push(ampThreadId);
-  push(ampCurrentThreadId(env));
-  if (!ids.length) {
+  if (ctx.listRecentAmpThreads !== false) {
+    push(ampCurrentThreadId(env));
+  }
+  if (!ids.length && ctx.listRecentAmpThreads !== false) {
     for (const id of listRecentAmpThreadIds(ctx)) push(id);
   }
   const sources = [];
@@ -825,6 +827,7 @@ export function collectSpend(options = {}) {
     homedir,
     notes,
     ampThreadId: options.ampThreadId,
+    listRecentAmpThreads: options.listRecentAmpThreads,
     cursorConversationId: options.cursorConversationId,
     exportAmpThread: options.exportAmpThread,
     listAmpThreads: options.listAmpThreads,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-orchestrator-kit",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Universal AI agent orchestration kit for Cursor, Claude Code, and Amp Code — spec-driven OpenSpec pipeline, conductor subagents, durable session handoff, factory gates and MCP setup, cloud-agent handoff, and optional local Figma PAT setup",
   "keywords": [
     "ai-agent",

package/templates/scripts/cursor-spend-collect.cjs

@@ -5,7 +5,7 @@
 'use strict';
 
 const { existsSync, readdirSync, readFileSync, writeFileSync, statSync } = require('fs');
-const { join } = require('path');
+const { join, resolve } = require('path');
 
 function numOrNull(value) {
   if (value == null || value === '') return null;
@@ -18,6 +18,17 @@ function addNullable(a, b) {
   return (a ?? 0) + (b ?? 0);
 }
 
+function roundUsd4(x) {
+  if (x == null) return null;
+  return Math.round(Number(x) * 10000) / 10000;
+}
+
+function timestampMs(value) {
+  if (value == null || value === '') return NaN;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : NaN;
+}
+
 const GROK_46 = {
   inputPerM: 2,
   cachedPerM: 0.5,
@@ -85,14 +96,161 @@ function describeCursorCostEstimate(args) {
   };
 }
 
+function uniqueExistingAbsPaths(payload) {
+  const seen = new Set();
+  const out = [];
+  const add = (value) => {
+    if (value == null || value === '') return;
+    let abs;
+    try {
+      abs = resolve(String(value));
+    } catch {
+      return;
+    }
+    if (seen.has(abs)) return;
+    try {
+      if (!existsSync(abs)) return;
+    } catch {
+      return;
+    }
+    seen.add(abs);
+    out.push(abs);
+  };
+  add(process.cwd());
+  const roots = payload && Array.isArray(payload.workspace_roots) ? payload.workspace_roots : [];
+  for (const root of roots) add(root);
+  return out;
+}
+
+function leftoverCandidateRoots(payload) {
+  return uniqueExistingAbsPaths(payload).filter((root) => existsSync(join(root, 'openspec', 'changes')));
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function metricsHasConversationThread(metrics, conversationId) {
+  if (!metrics || typeof metrics !== 'object' || !conversationId) return false;
+  const pendingId = metrics.pending && metrics.pending.threadId != null && metrics.pending.threadId !== ''
+    ? String(metrics.pending.threadId).trim()
+    : '';
+  if (pendingId && pendingId === conversationId) return true;
+  const sessions = Array.isArray(metrics.sessions) ? metrics.sessions : [];
+  const last = sessions[sessions.length - 1];
+  const lastId = last && last.threadId != null && last.threadId !== ''
+    ? String(last.threadId).trim()
+    : '';
+  return Boolean(lastId && lastId === conversationId);
+}
+
+function activeChangeNames(changesDir) {
+  const names = [];
+  let entries;
+  try {
+    entries = readdirSync(changesDir);
+  } catch {
+    return names;
+  }
+  for (const name of entries) {
+    if (name === 'archive') continue;
+    const full = join(changesDir, name);
+    try {
+      if (statSync(full).isDirectory()) names.push(name);
+    } catch {
+      continue;
+    }
+  }
+  return names;
+}
+
+function rootHasMatchingThread(root, conversationId) {
+  const changesDir = join(root, 'openspec', 'changes');
+  if (!existsSync(changesDir)) return false;
+  for (const name of activeChangeNames(changesDir)) {
+    if (metricsHasConversationThread(readJsonSafe(join(changesDir, name, 'metrics.json')), conversationId)) {
+      return true;
+    }
+  }
+  const archiveDir = join(changesDir, 'archive');
+  if (!existsSync(archiveDir)) return false;
+  const seen = new Set();
+  let entries;
+  try {
+    entries = readdirSync(archiveDir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    const changeName = archivedChangeName(entry);
+    if (!changeName || seen.has(changeName)) continue;
+    seen.add(changeName);
+    const dir = newestArchiveDirForName(archiveDir, changeName);
+    if (!dir) continue;
+    if (metricsHasConversationThread(readJsonSafe(join(dir, 'metrics.json')), conversationId)) return true;
+  }
+  return false;
+}
+
+function rootHasActiveChange(root) {
+  return activeChangeNames(join(root, 'openspec', 'changes')).length > 0;
+}
+
+function jsonlHasConversationId(root, conversationId) {
+  if (!conversationId) return false;
+  const filePath = join(root, '.agents', 'spend', 'cursor-usage.jsonl');
+  if (!existsSync(filePath)) return false;
+  let text;
+  try {
+    text = readFileSync(filePath, 'utf-8');
+  } catch {
+    return false;
+  }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const id = row && row.conversationId != null && row.conversationId !== ''
+      ? String(row.conversationId).trim()
+      : '';
+    if (id && id === conversationId) return true;
+  }
+  return false;
+}
+
 function resolveBaseDir(payload) {
-  const cwd = process.cwd();
-  if (existsSync(join(cwd, 'openspec', 'changes'))) return cwd;
-  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots : [];
-  for (const root of roots) {
-    if (root && existsSync(join(String(root), 'openspec', 'changes'))) return String(root);
+  const candidates = uniqueExistingAbsPaths(payload && typeof payload === 'object' ? payload : {});
+  const conversationId = String((payload && payload.conversation_id) || '').trim();
+  if (conversationId) {
+    for (const root of candidates) {
+      if (rootHasMatchingThread(root, conversationId)) return root;
+    }
+  }
+  for (const root of candidates) {
+    if (rootHasActiveChange(root)) return root;
+  }
+  if (conversationId) {
+    for (const root of candidates) {
+      if (jsonlHasConversationId(root, conversationId)) return root;
+    }
+  }
+  const cwd = resolve(process.cwd());
+  if (
+    candidates.includes(cwd)
+    && (existsSync(join(cwd, 'openspec', 'changes')) || existsSync(join(cwd, '.agents')))
+  ) {
+    return cwd;
   }
-  return cwd;
+  if (!candidates.length) return cwd;
+  return [...candidates].sort()[0];
 }
 
 const CURSOR_LEFTOVER_GRACE_MS = 120000;
@@ -255,7 +413,7 @@ function sourceTotals(sources) {
     if (src.costUsd != null) costUsd = addNullable(costUsd, numOrNull(src.costUsd));
     costUsdEstimated = addNullable(costUsdEstimated, numOrNull(src.costUsdEstimated));
   }
-  return { inputTokens, outputTokens, totalTokens, costUsd, costUsdEstimated };
+  return { inputTokens, outputTokens, totalTokens, costUsd, costUsdEstimated: roundUsd4(costUsdEstimated) };
 }
 
 function looksOverridden(session) {
@@ -298,13 +456,22 @@ function recompute(metrics) {
     totals.sessions += 1;
     if (session.runtime === 'cloud') totals.cloudSessions += 1;
     totals.durationMs = addNullable(totals.durationMs, numOrNull(session.durationMs));
-    if (session.startedAt && (firstStart == null || session.startedAt < firstStart)) firstStart = session.startedAt;
-    if (session.endedAt && (lastEnd == null || session.endedAt > lastEnd)) lastEnd = session.endedAt;
+    const sessionStartMs = timestampMs(session.startedAt);
+    if (Number.isFinite(sessionStartMs) && (firstStart == null || sessionStartMs < timestampMs(firstStart))) {
+      firstStart = session.startedAt;
+    }
+    const sessionEndMs = timestampMs(session.endedAt);
+    if (Number.isFinite(sessionEndMs) && (lastEnd == null || sessionEndMs > timestampMs(lastEnd))) {
+      lastEnd = session.endedAt;
+    }
 
     const key = session.phase || 'other';
     const phase = phases[key] || {
       sessions: 0,
       durationMs: null,
+      startedAt: null,
+      endedAt: null,
+      leadTimeMs: null,
       inputTokens: null,
       outputTokens: null,
       totalTokens: null,
@@ -315,6 +482,12 @@ function recompute(metrics) {
     };
     phase.sessions += 1;
     phase.durationMs = addNullable(phase.durationMs, numOrNull(session.durationMs));
+    if (Number.isFinite(sessionStartMs) && (phase.startedAt == null || sessionStartMs < timestampMs(phase.startedAt))) {
+      phase.startedAt = session.startedAt;
+    }
+    if (Number.isFinite(sessionEndMs) && (phase.endedAt == null || sessionEndMs > timestampMs(phase.endedAt))) {
+      phase.endedAt = session.endedAt;
+    }
     for (const spendKey of ['inputTokens', 'outputTokens', 'totalTokens', 'costUsd', 'costUsdEstimated']) {
       const fromSession = numOrNull(session[spendKey]);
       let value = fromSession;
@@ -335,7 +508,9 @@ function recompute(metrics) {
     }
     phases[key] = phase;
 
+    let sessionSourceCostUsd = null;
     for (const src of session.sources || []) {
+      sessionSourceCostUsd = addNullable(sessionSourceCostUsd, numOrNull(src.costUsd));
       const platform = src.platform;
       if (platform && byPlatform[platform]) {
         const bucket = byPlatform[platform];
@@ -370,11 +545,31 @@ function recompute(metrics) {
         byModel.set(modelKey, row);
       }
     }
+    const sessionCostUsd = numOrNull(session.costUsd);
+    if (sessionSourceCostUsd == null && sessionCostUsd != null) {
+      const billedBucket = session.platform && byPlatform[session.platform];
+      if (billedBucket) billedBucket.costUsd = addNullable(billedBucket.costUsd, sessionCostUsd);
+    }
   }
 
   if (firstStart && lastEnd) {
     totals.leadTimeMs = Math.max(0, Date.parse(lastEnd) - Date.parse(firstStart));
   }
+  for (const phase of Object.values(phases)) {
+    const startMs = timestampMs(phase.startedAt);
+    const endMs = timestampMs(phase.endedAt);
+    phase.leadTimeMs = Number.isFinite(startMs) && Number.isFinite(endMs)
+      ? Math.max(0, endMs - startMs)
+      : null;
+    phase.costUsdEstimated = roundUsd4(phase.costUsdEstimated);
+  }
+  spend.costUsdEstimated = roundUsd4(spend.costUsdEstimated);
+  for (const bucket of Object.values(byPlatform)) {
+    bucket.costUsdEstimated = roundUsd4(bucket.costUsdEstimated);
+  }
+  for (const row of byModel.values()) {
+    row.costUsdEstimated = roundUsd4(row.costUsdEstimated);
+  }
   metrics.phases = phases;
   metrics.totals = totals;
   metrics.spend = spend;
@@ -382,12 +577,19 @@ function recompute(metrics) {
   metrics.spendByModel = [...byModel.values()];
 }
 
-function incomingCursorSources(cwd, existing, fingerprints, windowStart, windowEnd, byId, exclusiveEnd) {
+function incomingCursorSources(cwd, existing, fingerprints, windowStart, windowEnd, byId, exclusiveEnd, filterConversationId) {
   const startMs = windowStart ? Date.parse(windowStart) : NaN;
   const endMs = windowEnd ? Date.parse(windowEnd) : NaN;
+  const filterId = String(filterConversationId || '').trim();
   const bestById = new Map();
   for (const [id, row] of byId) {
     if (existing.has(id)) continue;
+    if (filterId) {
+      const rowConversationId = row.conversationId == null || row.conversationId === ''
+        ? ''
+        : String(row.conversationId).trim();
+      if (rowConversationId !== filterId) continue;
+    }
     const atMs = Date.parse(row.at);
     if (Number.isFinite(startMs) && Number.isFinite(atMs) && atMs < startMs) continue;
     if (Number.isFinite(endMs) && Number.isFinite(atMs)) {
@@ -527,6 +729,7 @@ function backfillMetricsFile(cwd, filePath) {
       leftoverEnd,
       byId,
       leftoverEndExclusive(metrics),
+      last.threadId,
     )
     : [];
   if (incoming.length) {
@@ -602,14 +805,7 @@ function newestArchiveDirForName(archiveDir, changeName) {
   return best;
 }
 
-function main(raw) {
-  let payload = {};
-  try {
-    payload = raw ? JSON.parse(raw) : {};
-  } catch {
-    payload = {};
-  }
-  const cwd = resolveBaseDir(payload && typeof payload === 'object' ? payload : {});
+function backfillRoot(cwd) {
   const changesDir = join(cwd, 'openspec', 'changes');
   if (!existsSync(changesDir)) return;
   const activeNames = new Set();
@@ -645,21 +841,48 @@ function main(raw) {
   }
 }
 
-if (process.stdin.isTTY) {
+function parsePayload(raw) {
+  if (raw && typeof raw === 'object') return raw;
   try {
-    main('');
-  } catch {}
-  process.exit(0);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
 }
 
-let input = '';
-process.stdin.on('data', (chunk) => {
-  input += chunk;
-});
-process.stdin.on('end', () => {
-  try {
-    main(input);
-  } catch {}
-  process.exit(0);
-});
-process.stdin.on('error', () => process.exit(0));
+function main(raw) {
+  const payload = parsePayload(raw);
+  const candidates = leftoverCandidateRoots(payload && typeof payload === 'object' ? payload : {});
+  for (const cwd of candidates) {
+    try {
+      backfillRoot(cwd);
+    } catch {}
+  }
+}
+
+if (require.main === module) {
+  if (process.stdin.isTTY) {
+    try {
+      main('');
+    } catch {}
+    process.exit(0);
+  }
+
+  let input = '';
+  process.stdin.on('data', (chunk) => {
+    input += chunk;
+  });
+  process.stdin.on('end', () => {
+    try {
+      main(input);
+    } catch {}
+    process.exit(0);
+  });
+  process.stdin.on('error', () => process.exit(0));
+}
+
+module.exports = {
+  main,
+  backfillLeftover: main,
+  resolveBaseDir,
+};

package/templates/scripts/cursor-spend-hook.cjs

@@ -5,7 +5,7 @@
 // must never block the agent loop, so every failure path exits 0 with no output.
 'use strict';
 
-const { existsSync, mkdirSync, appendFileSync } = require('fs');
+const { mkdirSync, appendFileSync } = require('fs');
 const { join } = require('path');
 
 function numOrNull(value) {
@@ -14,14 +14,24 @@ function numOrNull(value) {
   return Number.isFinite(n) ? n : null;
 }
 
+function loadCollect() {
+  return require('./cursor-spend-collect.cjs');
+}
+
 function resolveBaseDir(payload) {
-  const cwd = process.cwd();
-  if (existsSync(join(cwd, '.agents'))) return cwd;
-  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots : [];
-  for (const root of roots) {
-    if (root && existsSync(join(String(root), '.agents'))) return String(root);
-  }
-  return cwd;
+  try {
+    const collect = loadCollect();
+    if (typeof collect.resolveBaseDir === 'function') return collect.resolveBaseDir(payload);
+  } catch {}
+  return process.cwd();
+}
+
+function runLeftover(payload) {
+  try {
+    const collect = loadCollect();
+    const fn = collect.backfillLeftover || collect.main;
+    if (typeof fn === 'function') fn(payload);
+  } catch {}
 }
 
 function main(raw) {
@@ -65,6 +75,11 @@ function main(raw) {
   const spendDir = join(resolveBaseDir(payload), '.agents', 'spend');
   mkdirSync(spendDir, { recursive: true });
   appendFileSync(join(spendDir, 'cursor-usage.jsonl'), `${JSON.stringify(record)}\n`);
+
+  const event = payload.hook_event_name ? String(payload.hook_event_name) : '';
+  if (event === 'stop' || event === 'afterAgentResponse') {
+    runLeftover(payload);
+  }
 }
 
 let input = '';