@arcadeai/hypotenuse 0.19.0 → 0.21.0

package/dist/hypotenuse.js

@@ -343,7 +343,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@arcadeai/hypotenuse",
-  version: "0.19.0",
+  version: "0.21.0",
   description: "Hypotenuse \u2014 run coding agents on your machine for Linear agent sessions",
   type: "module",
   license: "Apache-2.0",
@@ -1097,172 +1097,55 @@ var RunnerLimits = z2.strictObject({
   agents: z2.record(identifier, cap).optional()
 });
 // ../protocol/src/complete.ts
-import { z as z3 } from "zod";
-var COMPLETE_OUTCOMES = ["completed", "failed", "cancelled"];
-var CompleteRequest = z3.strictObject({
-  workItemId: z3.number().int().positive(),
-  outcome: z3.enum(COMPLETE_OUTCOMES),
-  error: z3.string().max(4096).nullable().optional(),
-  acpSessionId: z3.string().max(255).nullable().optional(),
-  branch: z3.string().max(255).nullable().optional(),
-  answersConsumed: z3.array(z3.number().int().positive()).max(100).optional().describe("The activity ids of delivered answers the turn took as answers; any other answer becomes the session's next prompt")
-});
-var CompleteResponse = z3.looseObject({
-  alreadyTerminal: z3.boolean()
-});
-// ../protocol/src/connect.ts
-import { z as z5 } from "zod";
-
-// ../protocol/src/heartbeat.ts
 import { z as z4 } from "zod";
-var ACTIVE_STATES = ["starting", "running", "cancelling"];
-var ActiveItem = z4.strictObject({
-  workItemId: z4.number().int().positive(),
-  agentSessionId: z4.number().int().positive(),
-  role: RunnerRole,
-  agentId: z4.string().min(1).max(64),
-  state: z4.enum(ACTIVE_STATES)
-});
-var MachineId = z4.string().regex(/^sha256:[0-9a-f]{1,64}$/, "sha256:<hex>").describe("A stable hash of the OS machine id, `sha256:<hex>`");
-var HeartbeatRequest = z4.strictObject({
-  protocolVersion: z4.number().int().positive(),
-  daemonVersion: z4.string().trim().min(1).max(64),
-  platform: z4.string().trim().min(1).max(64),
-  hostname: z4.string().trim().min(1).max(256),
-  draining: z4.boolean(),
-  machineId: MachineId,
-  limits: RunnerLimits,
-  active: z4.array(ActiveItem).max(1000),
-  capabilities: RunnerCapabilities,
-  dryRun: z4.boolean().optional().describe("Validate and answer without recording anything: no presence, no capabilities, no leases, no offers")
-});
-var DryRunRunner = z4.looseObject({
-  id: z4.number().int().positive(),
-  name: z4.string(),
-  projectId: z4.number().int().positive(),
-  projectSlug: z4.string()
-});
-var OFFER_KINDS = [
-  "session_created",
-  "prompt",
-  "dispatch",
-  "review"
-];
-var Offer = z4.looseObject({
-  workItemId: z4.number().int().positive(),
-  agentSessionId: z4.number().int().positive(),
-  kind: z4.enum(OFFER_KINDS),
-  role: RunnerRole,
-  offerExpiresAt: z4.number().int()
-});
-var CANCEL_REASONS = [
-  "stop",
-  "dashboard",
-  "delegate_removed",
-  "issue_closed",
-  "unassigned",
-  "integration_revoked",
-  "superseded"
-];
-var Cancel = z4.looseObject({
-  workItemId: z4.number().int().positive(),
-  reason: z4.union([z4.enum(CANCEL_REASONS), z4.string().min(1).max(64)]),
-  by: z4.string().min(1).max(200).optional(),
-  said: z4.string().min(1).max(2000).optional()
-});
-var STOP_QUOTE_MAX = 500;
-function stopQuote(said) {
-  const text = said?.trim();
-  if (!text || /^stop[.!]*$/i.test(text))
-    return "";
-  const cut = text.length > STOP_QUOTE_MAX ? `${text.slice(0, STOP_QUOTE_MAX)}\u2026` : text;
-  return `
 
-> You said: ${cut.split(`
-`).join(`
-> `)}`;
-}
-var Answer = z4.looseObject({
-  workItemId: z4.number().int().positive(),
-  activityId: z4.number().int().positive(),
-  body: z4.string()
-});
-var HeartbeatResponse = z4.looseObject({
-  serverTime: z4.number().int(),
-  heartbeatIntervalMs: z4.number().int().positive(),
-  leaseMs: z4.number().int().positive(),
-  offers: z4.array(Offer),
-  cancels: z4.array(Cancel),
-  unknownActive: z4.array(z4.number().int().positive()),
-  answers: z4.array(Answer).default([]).describe("Replies to questions held turns are waiting on, oldest first"),
-  runner: DryRunRunner.optional().describe("A dry run only: the runner the token is"),
-  unknownSubscriptions: z4.looseObject({ teams: z4.array(z4.string()) }).nullable().optional().describe("A dry run only: subscribed team keys the project's Linear connection cannot see; null when it could not be asked")
-});
-
-// ../protocol/src/connect.ts
-var ConnectRequest = z5.strictObject({
-  machineId: MachineId
-});
-var ConnectResponse = z5.looseObject({
-  runnerId: z5.number().int().positive(),
-  channel: z5.string().regex(/^runner:\d+$/),
-  heartbeatIntervalMs: z5.number().int().positive(),
-  leaseMs: z5.number().int().positive(),
-  serverTime: z5.number().int()
-});
-var MACHINE_IN_USE = "MACHINE_IN_USE";
-var RUNNER_FRAME_EVENTS = ["work", "cancel", "revoked"];
-var RunnerFrame = z5.object({ event: z5.enum(RUNNER_FRAME_EVENTS) });
-function runnerChannel(runnerId) {
-  return `runner:${runnerId}`;
-}
 // ../protocol/src/events.ts
-import { z as z6 } from "zod";
+import { z as z3 } from "zod";
 var MAX_EVENTS_PER_BATCH = 100;
 var MAX_EVENTS_BATCH_BYTES = 256 * 1024;
 var NOT_YOUR_WORK = "NOT_YOUR_WORK";
 var SEQ_REGRESSION = "SEQ_REGRESSION";
-var body = z6.string().trim().min(1).max(64 * 1024);
+var body = z3.string().trim().min(1).max(64 * 1024);
 var envelope = {
-  eventId: z6.uuid({ version: "v4" }).describe("Generated by the daemon; the idempotency key end to end (the Linear activity's client id)"),
-  seq: z6.number().int().positive().describe("Per work item, from 1, never going backwards"),
-  at: z6.number().int().describe("When the daemon saw it, epoch ms")
+  eventId: z3.uuid({ version: "v4" }).describe("Generated by the daemon; the idempotency key end to end (the Linear activity's client id)"),
+  seq: z3.number().int().positive().describe("Per work item, from 1, never going backwards"),
+  at: z3.number().int().describe("When the daemon saw it, epoch ms")
 };
-var SelectMetadata = z6.strictObject({
-  options: z6.array(z6.strictObject({
-    label: z6.string().trim().min(1).max(255).optional(),
-    value: z6.string().trim().min(1).max(1024)
+var SelectMetadata = z3.strictObject({
+  options: z3.array(z3.strictObject({
+    label: z3.string().trim().min(1).max(255).optional(),
+    value: z3.string().trim().min(1).max(1024)
   })).min(1).max(25)
 });
-var AuthProvider = z6.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/).describe("An agent id, `github`, or a git host");
-var AuthMetadata = z6.strictObject({
-  url: z6.url().optional(),
+var AuthProvider = z3.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/).describe("An agent id, `github`, or a git host");
+var AuthMetadata = z3.strictObject({
+  url: z3.url().optional(),
   provider: AuthProvider.optional(),
-  userId: z6.string().max(255).optional(),
-  providerName: z6.string().max(255).optional()
+  userId: z3.string().max(255).optional(),
+  providerName: z3.string().max(255).optional()
 }).refine((m) => m.url !== undefined || m.provider !== undefined, {
   message: "an auth elicitation needs a url or a provider"
 });
-var ThoughtEvent = z6.strictObject({
+var ThoughtEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("thought"),
+  type: z3.literal("thought"),
   body,
-  ephemeral: z6.boolean().default(false)
+  ephemeral: z3.boolean().default(false)
 });
-var ActionEvent = z6.strictObject({
+var ActionEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("action"),
-  action: z6.string().trim().min(1).max(255),
-  parameter: z6.string().trim().min(1).max(4096),
-  result: z6.string().max(64 * 1024).optional(),
-  ephemeral: z6.boolean().default(false)
+  type: z3.literal("action"),
+  action: z3.string().trim().min(1).max(255),
+  parameter: z3.string().trim().min(1).max(4096),
+  result: z3.string().max(64 * 1024).optional(),
+  ephemeral: z3.boolean().default(false)
 });
-var ElicitationEvent = z6.strictObject({
+var ElicitationEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("elicitation"),
+  type: z3.literal("elicitation"),
   body,
-  signal: z6.enum(["select", "auth"]).optional(),
-  signalMetadata: z6.record(z6.string(), z6.unknown()).optional()
+  signal: z3.enum(["select", "auth"]).optional(),
+  signalMetadata: z3.record(z3.string(), z3.unknown()).optional()
 }).superRefine((event, ctx) => {
   if (!event.signal) {
     if (event.signalMetadata) {
@@ -1284,14 +1167,14 @@ var ElicitationEvent = z6.strictObject({
     });
   }
 });
-var ResponseEvent = z6.strictObject({
+var ResponseEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("response"),
+  type: z3.literal("response"),
   body
 });
-var ErrorEvent = z6.strictObject({
+var ErrorEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("error"),
+  type: z3.literal("error"),
   body
 });
 var PLAN_ENTRY_STATUSES = [
@@ -1300,33 +1183,36 @@ var PLAN_ENTRY_STATUSES = [
   "completed",
   "canceled"
 ];
-var PlanEvent = z6.strictObject({
+var PlanEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("plan"),
-  entries: z6.array(z6.strictObject({
-    content: z6.string().trim().min(1).max(1024),
-    status: z6.enum(PLAN_ENTRY_STATUSES)
+  type: z3.literal("plan"),
+  entries: z3.array(z3.strictObject({
+    content: z3.string().trim().min(1).max(1024),
+    status: z3.enum(PLAN_ENTRY_STATUSES)
   })).max(100)
 });
-var SummaryEvent = z6.strictObject({
+var SummaryEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("summary"),
-  title: z6.string().min(1).max(255).regex(/^[^\r\n\0]*$/, "one line").refine((t) => t.trim().length > 0, "not blank")
+  type: z3.literal("summary"),
+  title: z3.string().min(1).max(255).regex(/^[^\r\n\0]*$/, "one line").refine((t) => t.trim().length > 0, "not blank")
 });
-var ExternalUrlEvent = z6.strictObject({
+var ExternalUrlEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("external_url"),
-  label: z6.string().trim().min(1).max(255),
-  url: z6.url()
+  type: z3.literal("external_url"),
+  label: z3.string().trim().min(1).max(255),
+  url: z3.url()
 });
-var UsageEvent = z6.strictObject({
+var TurnUsage = z3.strictObject({
+  inputTokens: z3.number().int().min(0).optional(),
+  outputTokens: z3.number().int().min(0).optional(),
+  costUsd: z3.number().min(0).optional().describe("This turn's cost in US dollars, as the agent reported it")
+});
+var UsageEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("usage"),
-  inputTokens: z6.number().int().min(0).optional(),
-  outputTokens: z6.number().int().min(0).optional(),
-  costUsd: z6.number().min(0).optional(),
-  contextUsed: z6.number().int().min(0).optional(),
-  contextSize: z6.number().int().min(0).optional()
+  type: z3.literal("usage"),
+  ...TurnUsage.shape,
+  contextUsed: z3.number().int().min(0).optional(),
+  contextSize: z3.number().int().min(0).optional()
 });
 var STATUS_EVENT_STATES = [
   "starting",
@@ -1334,12 +1220,12 @@ var STATUS_EVENT_STATES = [
   "waiting_permission",
   "finishing"
 ];
-var StatusEvent = z6.strictObject({
+var StatusEvent = z3.strictObject({
   ...envelope,
-  type: z6.literal("status"),
-  state: z6.enum(STATUS_EVENT_STATES)
+  type: z3.literal("status"),
+  state: z3.enum(STATUS_EVENT_STATES)
 });
-var SessionEvent = z6.discriminatedUnion("type", [
+var SessionEvent = z3.discriminatedUnion("type", [
   ThoughtEvent,
   ActionEvent,
   ElicitationEvent,
@@ -1351,16 +1237,137 @@ var SessionEvent = z6.discriminatedUnion("type", [
   UsageEvent,
   StatusEvent
 ]);
-var EventsRequest = z6.strictObject({
-  workItemId: z6.number().int().positive(),
-  events: z6.array(SessionEvent).min(1).max(MAX_EVENTS_PER_BATCH)
+var EventsRequest = z3.strictObject({
+  workItemId: z3.number().int().positive(),
+  events: z3.array(SessionEvent).min(1).max(MAX_EVENTS_PER_BATCH)
+});
+var EventsResponse = z3.looseObject({
+  accepted: z3.number().int().min(0),
+  duplicates: z3.number().int().min(0),
+  dropped: z3.number().int().min(0),
+  cancelRequested: z3.boolean()
+});
+
+// ../protocol/src/complete.ts
+var COMPLETE_OUTCOMES = ["completed", "failed", "cancelled"];
+var CompleteRequest = z4.strictObject({
+  workItemId: z4.number().int().positive(),
+  outcome: z4.enum(COMPLETE_OUTCOMES),
+  error: z4.string().max(4096).nullable().optional(),
+  acpSessionId: z4.string().max(255).nullable().optional(),
+  branch: z4.string().max(255).nullable().optional(),
+  answersConsumed: z4.array(z4.number().int().positive()).max(100).optional().describe("The activity ids of delivered answers the turn took as answers; any other answer becomes the session's next prompt"),
+  usage: TurnUsage.optional().describe("What the turn spent, in full; recorded even when the turn was stopped and its events were dropped")
+});
+var CompleteResponse = z4.looseObject({
+  alreadyTerminal: z4.boolean()
+});
+// ../protocol/src/connect.ts
+import { z as z6 } from "zod";
+
+// ../protocol/src/heartbeat.ts
+import { z as z5 } from "zod";
+var ACTIVE_STATES = ["starting", "running", "cancelling"];
+var ActiveItem = z5.strictObject({
+  workItemId: z5.number().int().positive(),
+  agentSessionId: z5.number().int().positive(),
+  role: RunnerRole,
+  agentId: z5.string().min(1).max(64),
+  state: z5.enum(ACTIVE_STATES)
+});
+var MachineId = z5.string().regex(/^sha256:[0-9a-f]{1,64}$/, "sha256:<hex>").describe("A stable hash of the OS machine id, `sha256:<hex>`");
+var HeartbeatRequest = z5.strictObject({
+  protocolVersion: z5.number().int().positive(),
+  daemonVersion: z5.string().trim().min(1).max(64),
+  platform: z5.string().trim().min(1).max(64),
+  hostname: z5.string().trim().min(1).max(256),
+  draining: z5.boolean(),
+  machineId: MachineId,
+  limits: RunnerLimits,
+  active: z5.array(ActiveItem).max(1000),
+  capabilities: RunnerCapabilities,
+  dryRun: z5.boolean().optional().describe("Validate and answer without recording anything: no presence, no capabilities, no leases, no offers")
+});
+var DryRunRunner = z5.looseObject({
+  id: z5.number().int().positive(),
+  name: z5.string(),
+  projectId: z5.number().int().positive(),
+  projectSlug: z5.string()
+});
+var OFFER_KINDS = [
+  "session_created",
+  "prompt",
+  "dispatch",
+  "review"
+];
+var Offer = z5.looseObject({
+  workItemId: z5.number().int().positive(),
+  agentSessionId: z5.number().int().positive(),
+  kind: z5.enum(OFFER_KINDS),
+  role: RunnerRole,
+  offerExpiresAt: z5.number().int()
+});
+var CANCEL_REASONS = [
+  "stop",
+  "dashboard",
+  "delegate_removed",
+  "issue_closed",
+  "unassigned",
+  "integration_revoked",
+  "superseded"
+];
+var Cancel = z5.looseObject({
+  workItemId: z5.number().int().positive(),
+  reason: z5.union([z5.enum(CANCEL_REASONS), z5.string().min(1).max(64)]),
+  by: z5.string().min(1).max(200).optional(),
+  said: z5.string().min(1).max(2000).optional()
 });
-var EventsResponse = z6.looseObject({
-  accepted: z6.number().int().min(0),
-  duplicates: z6.number().int().min(0),
-  dropped: z6.number().int().min(0),
-  cancelRequested: z6.boolean()
+var STOP_QUOTE_MAX = 500;
+function stopQuote(said) {
+  const text = said?.trim();
+  if (!text || /^stop[.!]*$/i.test(text))
+    return "";
+  const cut = text.length > STOP_QUOTE_MAX ? `${text.slice(0, STOP_QUOTE_MAX)}\u2026` : text;
+  return `
+
+> You said: ${cut.split(`
+`).join(`
+> `)}`;
+}
+var Answer = z5.looseObject({
+  workItemId: z5.number().int().positive(),
+  activityId: z5.number().int().positive(),
+  body: z5.string()
+});
+var HeartbeatResponse = z5.looseObject({
+  serverTime: z5.number().int(),
+  heartbeatIntervalMs: z5.number().int().positive(),
+  leaseMs: z5.number().int().positive(),
+  offers: z5.array(Offer),
+  cancels: z5.array(Cancel),
+  unknownActive: z5.array(z5.number().int().positive()),
+  answers: z5.array(Answer).default([]).describe("Replies to questions held turns are waiting on, oldest first"),
+  runner: DryRunRunner.optional().describe("A dry run only: the runner the token is"),
+  unknownSubscriptions: z5.looseObject({ teams: z5.array(z5.string()) }).nullable().optional().describe("A dry run only: subscribed team keys the project's Linear connection cannot see; null when it could not be asked")
+});
+
+// ../protocol/src/connect.ts
+var ConnectRequest = z6.strictObject({
+  machineId: MachineId
 });
+var ConnectResponse = z6.looseObject({
+  runnerId: z6.number().int().positive(),
+  channel: z6.string().regex(/^runner:\d+$/),
+  heartbeatIntervalMs: z6.number().int().positive(),
+  leaseMs: z6.number().int().positive(),
+  serverTime: z6.number().int()
+});
+var MACHINE_IN_USE = "MACHINE_IN_USE";
+var RUNNER_FRAME_EVENTS = ["work", "cancel", "revoked"];
+var RunnerFrame = z6.object({ event: z6.enum(RUNNER_FRAME_EVENTS) });
+function runnerChannel(runnerId) {
+  return `runner:${runnerId}`;
+}
 // ../protocol/src/otlp.ts
 import protobuf from "protobufjs/light.js";
 var SPAN_KIND = {
@@ -3922,9 +3929,9 @@ async function socketAnswers(socketPath, timeoutMs = 1500) {
 import { spawn as spawn3 } from "child_process";
 import {
   closeSync as closeSync3,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   openSync as openSync3,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readSync,
   rmSync as rmSync9,
   statSync as statSync5
@@ -4159,8 +4166,8 @@ class DaemonLog {
 
 // src/daemon/main.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync10, rmSync as rmSync8, writeFileSync as writeFileSync5 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync11, rmSync as rmSync8, writeFileSync as writeFileSync5 } from "fs";
 import { join as join10 } from "path";
 
 // src/acp/host.ts
@@ -5740,6 +5747,11 @@ class TurnMapper {
   lastPlan = "";
   unknown = new Set;
   lastActionSummary = null;
+  costBaseline = null;
+  replayedCost = null;
+  costChecked = false;
+  sessionCost = null;
+  usage = {};
   recorded = {};
   constructor(options) {
     this.options = options;
@@ -5751,8 +5763,14 @@ class TurnMapper {
     return [...this.messages.values()].some((m) => m.trim());
   }
   update(update) {
-    if (this.replaying)
+    if (this.replaying) {
+      if (update.sessionUpdate === "usage_update") {
+        const cost = usdCost(update.cost);
+        if (cost !== null)
+          this.replayedCost = cost;
+      }
       return [];
+    }
     const kind = update.sessionUpdate;
     switch (update.sessionUpdate) {
       case "agent_thought_chunk": {
@@ -5838,14 +5856,10 @@ class TurnMapper {
         return [{ type: "summary", title: truncate(title, 255) }];
       }
       case "usage_update": {
-        return [
-          {
-            type: "usage",
-            contextUsed: Math.max(0, Math.round(update.used)),
-            contextSize: Math.max(0, Math.round(update.size)),
-            ...update.cost && update.cost.currency.toUpperCase() === "USD" ? { costUsd: Math.max(0, update.cost.amount) } : {}
-          }
-        ];
+        this.usage.contextUsed = Math.max(0, Math.round(update.used));
+        this.usage.contextSize = Math.max(0, Math.round(update.size));
+        this.recordCost(usdCost(update.cost));
+        return [{ type: "usage", ...this.usage }];
       }
       case "current_mode_update":
         this.recorded.mode = update.currentModeId;
@@ -5861,6 +5875,47 @@ class TurnMapper {
         return [];
     }
   }
+  acceptReplay() {
+    if (this.replayedCost !== null)
+      this.costBaseline = this.replayedCost;
+    this.replayedCost = null;
+  }
+  recordCost(cumulative) {
+    if (cumulative === null)
+      return;
+    if (!this.costChecked) {
+      this.costChecked = true;
+      if (this.costBaseline !== null && cumulative < this.costBaseline)
+        this.costBaseline = 0;
+    }
+    this.sessionCost = cumulative;
+    if (this.costBaseline !== null)
+      this.usage.costUsd = roundUsd(Math.max(0, cumulative - this.costBaseline));
+  }
+  tokens(tokens) {
+    const count = (n) => typeof n === "number" && Number.isFinite(n) ? Math.max(0, Math.round(n)) : undefined;
+    const input = count(tokens?.inputTokens);
+    const output = count(tokens?.outputTokens);
+    if (input === undefined && output === undefined)
+      return [];
+    if (input !== undefined)
+      this.usage.inputTokens = input;
+    if (output !== undefined)
+      this.usage.outputTokens = output;
+    return [{ type: "usage", ...this.usage }];
+  }
+  turnUsage() {
+    const { inputTokens, outputTokens, costUsd } = this.usage;
+    const usage = {
+      ...inputTokens !== undefined ? { inputTokens } : {},
+      ...outputTokens !== undefined ? { outputTokens } : {},
+      ...costUsd !== undefined ? { costUsd } : {}
+    };
+    return Object.keys(usage).length ? usage : undefined;
+  }
+  sessionCostUsd() {
+    return this.sessionCost ?? this.costBaseline;
+  }
   tick() {
     if (!this.thought)
       return [];
@@ -5963,6 +6018,14 @@ function callText(call) {
   return parts.join(`
 `);
 }
+function usdCost(cost) {
+  if (!cost || cost.currency.toUpperCase() !== "USD")
+    return null;
+  return Number.isFinite(cost.amount) ? Math.max(0, cost.amount) : null;
+}
+function roundUsd(usd) {
+  return Math.round(usd * 1e6) / 1e6;
+}
 
 // src/acp/mcp-servers.ts
 import { isAbsolute as isAbsolute7 } from "path";
@@ -6706,7 +6769,9 @@ class Turn {
       outcome,
       error: error ? error.slice(0, 4000) : null,
       acpSessionId: this.acpSessionId,
-      branch: this.branch
+      branch: this.branch,
+      usage: this.mapper.turnUsage(),
+      acpCostUsd: this.acpSessionId ? this.mapper.sessionCostUsd() : null
     };
   }
   async start() {
@@ -6881,6 +6946,7 @@ class Turn {
     const directories = extra.length && caps.sessionCapabilities?.additionalDirectories ? { additionalDirectories: extra } : {};
     const mcpServers = this.mcpServers(caps);
     this.resumed = false;
+    this.mapper.costBaseline = this.ctx.previousAcpCostUsd ?? null;
     if (previousAcpSessionId && !assignment.fresh && assignment.kind === "prompt") {
       try {
         if (caps.sessionCapabilities?.resume) {
@@ -6905,6 +6971,7 @@ class Turn {
               mcpServers,
               ...directories
             }), 0, ""));
+            this.mapper.acceptReplay();
             this.resumed = true;
             await this.applyMode(answer);
             return;
@@ -6922,6 +6989,7 @@ class Turn {
     }
     const created = await this.otel.around("acp.session.new", { "hypotenuse.mcp.servers": mcpServers.length }, () => this.guard(conn.newSession({ cwd: this.cwd, mcpServers, ...directories }), 0, ""));
     this.acpSessionId = created.sessionId;
+    this.mapper.costBaseline = 0;
     await this.applyMode(created);
   }
   resumed = false;
@@ -7038,6 +7106,7 @@ class Turn {
       throw new TurnFailure(`${this.agentId} failed the turn: ${errorMessage(error)}${quoteTail(this.log.tail())}`);
     });
     const usage = answer.usage;
+    this.emitAll(this.mapper.tokens(usage));
     this.otel.promptEnded({
       "gen_ai.response.finish_reasons": answer.stopReason,
       "gen_ai.usage.input_tokens": usage?.inputTokens,
@@ -7308,9 +7377,131 @@ function registrationHeartbeat() {
   };
 }
 
+// src/daemon/config-restart.ts
+class ConfigRestart {
+  deps;
+  timeoutMs;
+  pending = null;
+  generation = 0;
+  takenOver = false;
+  constructor(deps, timeoutMs) {
+    this.deps = deps;
+    this.timeoutMs = timeoutMs;
+  }
+  get isPending() {
+    return this.pending !== null;
+  }
+  get isTakenOver() {
+    return this.takenOver;
+  }
+  saved(outcome, path) {
+    if (this.takenOver)
+      return null;
+    if (this.pending !== null) {
+      if (!outcome.needsRestart) {
+        this.callOff(outcome.invalid ? `${path} is not valid now; the running config stays` : "the change that needed it was undone");
+      }
+      return null;
+    }
+    if (!outcome.needsRestart)
+      return null;
+    const problem = this.deps.startProblem();
+    if (problem) {
+      this.deps.log(`config restart not started: the daemon would not start on ${path} as it is now (${problem}); the running config stays`);
+      return null;
+    }
+    const generation = ++this.generation;
+    this.pending = generation;
+    this.deps.pauseClaims();
+    return this.wait(generation, path);
+  }
+  takeOver() {
+    this.takenOver = true;
+    if (this.pending === null)
+      return;
+    this.pending = null;
+    this.deps.log("config restart called off: a stop or restart was asked for");
+  }
+  async wait(generation, path) {
+    const idle = await this.deps.waitIdle(this.timeoutMs);
+    if (!this.current(generation))
+      return;
+    const problem = this.deps.startProblem();
+    if (problem) {
+      this.callOff(`the daemon would not start on ${path} as it is now (${problem}); the running config stays`);
+      return;
+    }
+    if (!idle)
+      await this.deps.stopTurns();
+    if (!this.current(generation))
+      return;
+    this.pending = null;
+    this.deps.restart();
+  }
+  current(generation) {
+    return this.pending === generation && !this.takenOver && !this.deps.exiting();
+  }
+  callOff(reason) {
+    if (this.pending === null)
+      return;
+    this.pending = null;
+    this.deps.resumeClaims();
+    this.deps.log(`config restart called off: ${reason}`);
+  }
+}
+
+// src/daemon/config-watch.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync9, watch } from "fs";
+import { basename as basename3, dirname as dirname8 } from "path";
+var CONFIG_WATCH_DEBOUNCE_MS = 300;
+function digest(path) {
+  if (!existsSync13(path))
+    return null;
+  try {
+    return createHash2("sha256").update(readFileSync9(path)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function watchConfigFile(path, onChange, options = {}) {
+  const name = basename3(path);
+  let last = digest(path);
+  let timer = null;
+  let watcher;
+  const settle = () => {
+    timer = null;
+    const now = digest(path);
+    if (now === null || now === last)
+      return;
+    last = now;
+    onChange();
+  };
+  try {
+    watcher = watch(dirname8(path), (_event, file) => {
+      if (file !== null && file !== name)
+        return;
+      if (timer)
+        clearTimeout(timer);
+      timer = setTimeout(settle, options.debounceMs ?? CONFIG_WATCH_DEBOUNCE_MS);
+    });
+  } catch (error) {
+    options.onError?.(error);
+    return null;
+  }
+  watcher.on("error", (error) => options.onError?.(error));
+  return {
+    close() {
+      if (timer)
+        clearTimeout(timer);
+      watcher.close();
+    }
+  };
+}
+
 // src/daemon/control-socket.ts
-import { chmodSync as chmodSync4, existsSync as existsSync13, mkdirSync as mkdirSync8, rmSync as rmSync5 } from "fs";
-import { dirname as dirname8 } from "path";
+import { chmodSync as chmodSync4, existsSync as existsSync14, mkdirSync as mkdirSync8, rmSync as rmSync5 } from "fs";
+import { dirname as dirname9 } from "path";
 var METHOD_NOT_FOUND = -32601;
 var INVALID_PARAMS = -32602;
 var INTERNAL_ERROR = -32603;
@@ -7335,8 +7526,8 @@ class ControlServer {
     this.onError = onError;
   }
   listen() {
-    mkdirSync8(dirname8(this.path), { recursive: true, mode: 448 });
-    if (existsSync13(this.path))
+    mkdirSync8(dirname9(this.path), { recursive: true, mode: 448 });
+    if (existsSync14(this.path))
       rmSync5(this.path, { force: true });
     const previous = process.umask(127);
     try {
@@ -7502,11 +7693,11 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync9,
   openSync as openSync2,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   rmSync as rmSync6,
   writeSync
 } from "fs";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 var STARTING_WINDOW_MS = 30000;
 function looksLikeDaemon(args) {
   const program = args.findIndex((arg) => {
@@ -7518,7 +7709,7 @@ function looksLikeDaemon(args) {
 function processArgs(pid) {
   try {
     if (process.platform === "linux") {
-      return readFileSync9(`/proc/${pid}/cmdline`, "utf8").split("\x00").filter(Boolean);
+      return readFileSync10(`/proc/${pid}/cmdline`, "utf8").split("\x00").filter(Boolean);
     }
     if (process.platform === "win32") {
       const out = Bun.spawnSync([
@@ -7553,7 +7744,7 @@ var realProbe = {
 function readLock(path) {
   let text;
   try {
-    text = readFileSync9(path, "utf8");
+    text = readFileSync10(path, "utf8");
   } catch {
     return;
   }
@@ -7577,7 +7768,7 @@ async function inspectLock(path, probe = realProbe, now = Date.now) {
   return now() - record.startedAt < STARTING_WINDOW_MS ? { kind: "starting", record } : { kind: "hung", record };
 }
 function writeExclusive(path, record) {
-  mkdirSync9(dirname9(path), { recursive: true, mode: 448 });
+  mkdirSync9(dirname10(path), { recursive: true, mode: 448 });
   let fd;
   try {
     fd = openSync2(path, "wx", 384);
@@ -7655,8 +7846,8 @@ function childArgs(args) {
 
 // src/daemon/state.ts
 import { Database } from "bun:sqlite";
-import { chmodSync as chmodSync5, existsSync as existsSync14, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname10 } from "path";
+import { chmodSync as chmodSync5, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname11 } from "path";
 var LIVE_LOCAL_STATES = [
   "claimed",
   "running"
@@ -7714,7 +7905,8 @@ var MIGRATIONS = [
    ALTER TABLE worktrees ADD COLUMN removed_at INTEGER;
    ALTER TABLE local_sessions ADD COLUMN last_answer TEXT;
    ALTER TABLE local_sessions ADD COLUMN ended_at INTEGER;
-   ALTER TABLE local_sessions ADD COLUMN pull_requests TEXT NOT NULL DEFAULT '[]';`
+   ALTER TABLE local_sessions ADD COLUMN pull_requests TEXT NOT NULL DEFAULT '[]';`,
+  `ALTER TABLE local_sessions ADD COLUMN acp_cost_usd REAL;`
 ];
 function toSession(row) {
   return {
@@ -7728,6 +7920,7 @@ function toSession(row) {
     nextSeq: row.next_seq,
     acpAgentId: row.acp_agent_id ?? null,
     acpSessionId: row.acp_session_id ?? null,
+    acpCostUsd: row.acp_cost_usd ?? null,
     pid: row.pid ?? null,
     worktreeId: row.worktree_id ?? null,
     createdAt: row.created_at,
@@ -7778,9 +7971,9 @@ class StateDb {
     this.path = path;
     this.now = now;
     if (path !== ":memory:") {
-      mkdirSync10(dirname10(path), { recursive: true, mode: 448 });
+      mkdirSync10(dirname11(path), { recursive: true, mode: 448 });
     }
-    const fresh = path === ":memory:" || !existsSync14(path);
+    const fresh = path === ":memory:" || !existsSync15(path);
     this.db = new Database(path, { create: true, strict: true });
     if (fresh && path !== ":memory:")
       chmodSync5(path, 384);
@@ -7837,7 +8030,8 @@ class StateDb {
   setSessionState(agentSessionId, state, extra = {}) {
     this.db.query(`UPDATE local_sessions SET state = $state, updated_at = $now,
            pid = CASE WHEN $setPid THEN $pid ELSE pid END,
-           acp_session_id = CASE WHEN $setAcp THEN $acp ELSE acp_session_id END
+           acp_session_id = CASE WHEN $setAcp THEN $acp ELSE acp_session_id END,
+           acp_cost_usd = CASE WHEN $setCost THEN $cost ELSE acp_cost_usd END
          WHERE agent_session_id = $id`).run({
       state,
       now: this.now(),
@@ -7845,7 +8039,9 @@ class StateDb {
       setPid: extra.pid !== undefined ? 1 : 0,
       pid: extra.pid ?? null,
       setAcp: extra.acpSessionId !== undefined ? 1 : 0,
-      acp: extra.acpSessionId ?? null
+      acp: extra.acpSessionId ?? null,
+      setCost: extra.acpCostUsd !== undefined ? 1 : 0,
+      cost: extra.acpCostUsd ?? null
     });
   }
   session(agentSessionId) {
@@ -8598,7 +8794,7 @@ function resolvedConfigSecrets(config, env) {
 }
 
 // src/worktree/cleanup.ts
-import { existsSync as existsSync15, readdirSync, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync16, readdirSync, rmSync as rmSync7 } from "fs";
 import { join as join9, relative as relative5, resolve as resolve4 } from "path";
 
 // src/worktree/merge-state.ts
@@ -8736,14 +8932,14 @@ class WorktreeCleaner {
     if (this.inUse(wt))
       return { reason: "in use", overridable: [] };
     const reasons = [];
-    if (wt.kind === "worktree" && existsSync15(wt.path)) {
+    if (wt.kind === "worktree" && existsSync16(wt.path)) {
       const status = await this.git(["status", "--porcelain", "--", ".", `:(exclude)${KEEP_FILE}`], { cwd: wt.path });
       if (status.code !== 0 || status.stdout.trim())
         reasons.push("uncommitted changes");
       if (await this.hasUnpushed(wt))
         reasons.push("unpushed commits");
     }
-    if (existsSync15(join9(wt.path, KEEP_FILE)))
+    if (existsSync16(join9(wt.path, KEEP_FILE)))
       reasons.push("kept by request");
     return { reason: reasons[0] ?? null, overridable: reasons };
   }
@@ -8800,7 +8996,7 @@ class WorktreeCleaner {
       }
     }
     const scratch = join9(root, SCRATCH);
-    if (existsSync15(scratch)) {
+    if (existsSync16(scratch)) {
       for (const name of readdirSync(scratch)) {
         const path = join9(scratch, name);
         const id = Number(name);
@@ -8854,7 +9050,7 @@ class WorktreeCleaner {
       if (!options.dryRun)
         this.state.updateWorktree(wt.id, { keptReason: reason });
     };
-    if (!existsSync15(wt.path)) {
+    if (!existsSync16(wt.path)) {
       if (!options.dryRun) {
         if (wt.repoPath)
           await this.git(["worktree", "prune"], { cwd: wt.repoPath });
@@ -10104,7 +10300,9 @@ class Supervisor {
       ...assignment,
       agentId: assignment.agentId ?? this.agentFor(assignment.role)
     }, this.config).agentId;
-    const previousAcpSessionId = state.session(assignment.agentSessionId)?.acpSessionId ?? null;
+    const local = state.session(assignment.agentSessionId);
+    const previousAcpSessionId = local?.acpSessionId ?? null;
+    const previousAcpCostUsd = local?.acpCostUsd ?? null;
     state.claimSession({
       agentSessionId: assignment.agentSessionId,
       linearSessionId: assignment.externalSessionId,
@@ -10200,6 +10398,7 @@ class Supervisor {
       stateDir: this.options.stateDir,
       env: this.options.env,
       previousAcpSessionId,
+      previousAcpCostUsd,
       onReply: (handler) => {
         slot.onReply = handler;
       },
@@ -10260,9 +10459,11 @@ class Supervisor {
     this.slots.delete(slot.workItemId);
     if (slot.nonce)
       this.broker.end(slot.nonce);
+    const acp = acpSessionAfterTurn(result, slot.silent, this.options.state.session(slot.agentSessionId)?.acpSessionId ?? null);
     if (slot.silent) {
       this.options.state.setSessionState(slot.agentSessionId, "interrupted", {
-        pid: null
+        pid: null,
+        ...acp
       });
     } else {
       this.sink.complete({
@@ -10272,6 +10473,7 @@ class Supervisor {
           error: result.error ?? null,
           acpSessionId: result.acpSessionId ?? null,
           branch: result.branch ?? null,
+          ...result.usage ? { usage: result.usage } : {},
           ...slot.consumed.length ? { answersConsumed: slot.consumed.slice(0, 100) } : {}
         },
         active: {
@@ -10283,10 +10485,7 @@ class Supervisor {
         }
       });
       this.options.state.recordTurnEnd(slot.agentSessionId, slot.lastAnswer);
-      this.options.state.setSessionState(slot.agentSessionId, result.outcome === "completed" ? "idle" : result.outcome === "cancelled" ? "cancelled" : "failed", {
-        pid: null,
-        ...result.acpSessionId ? { acpSessionId: result.acpSessionId } : {}
-      });
+      this.options.state.setSessionState(slot.agentSessionId, result.outcome === "completed" ? "idle" : result.outcome === "cancelled" ? "cancelled" : "failed", { pid: null, ...acp });
     }
     this.options.log.info(`turn ended: ${slot.silent ? "taken away" : result.outcome}`, {
       session: slot.agentSessionId,
@@ -10368,6 +10567,14 @@ class Supervisor {
     this.link.beatNow();
     return { drained: this.slots.size === 0 && flushed, cancelled };
   }
+  pauseClaims() {
+    this.draining = true;
+    this.link.beatNow();
+  }
+  resumeClaims() {
+    this.draining = false;
+    this.link.beatNow();
+  }
   async waitIdle(timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (this.slots.size > 0) {
@@ -10525,6 +10732,17 @@ class Supervisor {
     this.telemetryQueue.stop();
   }
 }
+function acpSessionAfterTurn(result, silent, recordedAcpSessionId) {
+  if (!result.acpSessionId)
+    return {};
+  if (!silent) {
+    return {
+      acpSessionId: result.acpSessionId,
+      acpCostUsd: result.acpCostUsd ?? null
+    };
+  }
+  return result.acpSessionId === recordedAcpSessionId ? { acpCostUsd: result.acpCostUsd ?? null } : {};
+}
 function changedKeys(a, b, prefix = "") {
   const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
   if (isObject(a) && isObject(b)) {
@@ -10593,18 +10811,19 @@ function revokedMarker(stateDir) {
   return join10(stateDir, "revoked.json");
 }
 function fingerprint(token) {
-  return createHash2("sha256").update(token).digest("hex");
+  return createHash3("sha256").update(token).digest("hex");
 }
 function wasRevoked(stateDir, token) {
   const file = revokedMarker(stateDir);
-  if (!existsSync16(file))
+  if (!existsSync17(file))
     return false;
   try {
-    return JSON.parse(readFileSync10(file, "utf8")).token === fingerprint(token);
+    return JSON.parse(readFileSync11(file, "utf8")).token === fingerprint(token);
   } catch {
     return false;
   }
 }
+var CONFIG_RESTART_DRAIN_MS = 10 * 60000;
 function readDaemonConfig(options, env) {
   const path = resolveConfigPath(options.config, env);
   const checked = checkConfig(path, { env, offline: true });
@@ -10677,19 +10896,55 @@ async function runDaemon(options) {
   const machine = realMachine(env);
   const api = new DaemonApi(origin, runner.token, (line) => log.debug(line));
   let exiting = false;
+  let restartScheduled = false;
+  let configHandOff = null;
   let supervisor;
   let control;
+  let watcher = null;
   const teardown = async (drain) => {
     if (drain) {
       await supervisor.drain({ timeoutMs: 1e4, cancel: false });
     } else {
       await supervisor.sink.drain(2000);
     }
+    watcher?.close();
     supervisor.close();
     control.close();
     releaseLock(paths.pidfile);
     state.close();
   };
+  const restartSelf = (fromConfig = false) => {
+    const service = env.HYPOTENUSE_SERVICE === "1";
+    const answer = {
+      restarting: true,
+      mode: service ? "service" : "re-exec"
+    };
+    if (restartScheduled)
+      return answer;
+    restartScheduled = true;
+    const handOff = setTimeout(() => {
+      configHandOff = null;
+      if (exiting)
+        return;
+      exiting = true;
+      log.info(service ? "exiting for the service manager to restart" : "re-executing");
+      teardown(false).then(() => {
+        if (service)
+          process.exit(EXIT_RESTART);
+        const [command, ...prefix] = selfCommand();
+        const child = spawn2(command, [...prefix, ...childArgs(process.argv.slice(2))], {
+          detached: true,
+          stdio: "ignore",
+          env
+        });
+        child.unref();
+        process.exit(0);
+      });
+    }, 50);
+    if (fromConfig)
+      configHandOff = handOff;
+    return answer;
+  };
   const requestExit = (exit) => {
     if (exiting)
       return;
@@ -10725,6 +10980,31 @@ async function runDaemon(options) {
       ...Object.values(credentials.servers).flatMap((s) => s.login ? [s.login.token] : [])
     ]
   });
+  const configRestart = new ConfigRestart({
+    pauseClaims: () => supervisor.pauseClaims(),
+    resumeClaims: () => supervisor.resumeClaims(),
+    waitIdle: (ms) => supervisor.waitIdle(ms),
+    stopTurns: async () => {
+      await supervisor.drain({ timeoutMs: 0, cancel: true });
+    },
+    startProblem: () => {
+      const read = readDaemonConfig(options, env);
+      if (!read.config)
+        return "the config is not valid";
+      const file = credentialsPath(env);
+      try {
+        resolveDaemonRunner(read.config, loadCredentials(file), file);
+      } catch (error) {
+        return error instanceof Error ? error.message : String(error);
+      }
+      return null;
+    },
+    exiting: () => exiting,
+    restart: () => {
+      restartSelf(true);
+    },
+    log: (message) => log.info(message)
+  }, CONFIG_RESTART_DRAIN_MS);
   control = new ControlServer(paths.socket, {
     status: () => supervisor.status({ pid: process.pid, configPath: paths.config }),
     "agents.list": (params) => supervisor.agents(Boolean(params.all)),
@@ -10742,30 +11022,23 @@ async function runDaemon(options) {
       const report = await supervisor.cleaner.run(cleanupParams(params));
       return report;
     },
-    drain: (params) => supervisor.drain({
-      timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : 600000,
-      cancel: params.cancel === true
-    }),
+    drain: (params) => {
+      configRestart.takeOver();
+      if (configHandOff) {
+        clearTimeout(configHandOff);
+        configHandOff = null;
+        restartScheduled = false;
+        log.info("config restart called off: a stop or restart was asked for");
+      }
+      return supervisor.drain({
+        timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : 600000,
+        cancel: params.cancel === true
+      });
+    },
     reload: () => supervisor.reload(),
     restart: () => {
-      const service = env.HYPOTENUSE_SERVICE === "1";
-      setTimeout(() => {
-        exiting = true;
-        log.info(service ? "exiting for the service manager to restart" : "re-executing");
-        teardown(false).then(() => {
-          if (service)
-            process.exit(EXIT_RESTART);
-          const [command, ...prefix] = selfCommand();
-          const child = spawn2(command, [...prefix, ...childArgs(process.argv.slice(2))], {
-            detached: true,
-            stdio: "ignore",
-            env
-          });
-          child.unref();
-          process.exit(0);
-        });
-      }, 50);
-      return { restarting: true, mode: service ? "service" : "re-exec" };
+      configRestart.takeOver();
+      return restartSelf();
     },
     "mcp.hello": (params) => supervisor.broker.hello(params),
     "mcp.call": (params) => supervisor.broker.call(params)
@@ -10801,6 +11074,19 @@ async function runDaemon(options) {
   });
   report({ ready: true, pid: process.pid });
   rmSync8(revokedMarker(paths.stateDir), { force: true });
+  watcher = watchConfigFile(paths.config, () => {
+    if (exiting || restartScheduled || configRestart.isTakenOver)
+      return;
+    log.info(`${paths.config} changed; reloading`);
+    const result = supervisor.reload();
+    const needsRestart = !result.error && result.requiresRestart.length > 0;
+    if (needsRestart && !configRestart.isPending) {
+      log.info("restarting to apply the config change once running turns finish", { keys: result.requiresRestart.join(",") });
+    }
+    configRestart.saved({ needsRestart, invalid: Boolean(result.error) }, paths.config);
+  }, {
+    onError: (error) => log.warn(`not watching ${paths.config} for changes (\`hypotenuse daemon reload\` still applies them): ${error instanceof Error ? error.message : String(error)}`)
+  });
 }
 
 // src/commands/daemon.ts
@@ -10962,22 +11248,22 @@ async function stopDaemon(ctx, options) {
 }
 async function tailLog(file, options) {
   const keep = (line) => !options.session || line.includes(` session=${options.session}`);
-  if (!existsSync17(file)) {
+  if (!existsSync18(file)) {
     if (!options.follow)
       throw new Error(`${file} does not exist yet`);
   } else {
-    const all = readFileSync11(file, "utf8").split(`
+    const all = readFileSync12(file, "utf8").split(`
 `).filter(Boolean).filter(keep);
     for (const line of all.slice(-options.lines))
       console.log(paintLogLine(line));
   }
   if (!options.follow)
     return;
-  let offset = existsSync17(file) ? statSync5(file).size : 0;
+  let offset = existsSync18(file) ? statSync5(file).size : 0;
   let partial = "";
   for (;; ) {
     await Bun.sleep(500);
-    if (!existsSync17(file))
+    if (!existsSync18(file))
       continue;
     const size = statSync5(file).size;
     if (size < offset)
@@ -11072,7 +11358,7 @@ function registerDaemonCommands(program) {
       const opts = this.opts();
       const located = locateDaemon(ctx);
       const sessionLog = opts.session && /^\d+$/.test(opts.session) ? sessionLogPath(located.stateDir, Number(opts.session)) : null;
-      if (sessionLog && existsSync17(sessionLog)) {
+      if (sessionLog && existsSync18(sessionLog)) {
         await tailLog(sessionLog, {
           lines: Number(opts.lines) || 200,
           follow: Boolean(opts.follow)
@@ -11538,9 +11824,9 @@ function registerCheckUpdateCommand(program) {
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "fs";
 import { hostname as hostname5 } from "os";
-import { dirname as dirname11, resolve as resolve5 } from "path";
+import { dirname as dirname12, resolve as resolve5 } from "path";
 
 // src/config/template.toml
 var template_default = `#:schema https://www.hypotenuse.cloud/schemas/config-v1.json
@@ -11687,7 +11973,7 @@ function registerConfigCommands(program) {
     await runCommand(this, async (ctx) => {
       const opts = this.opts();
       const path = ctx.configPath;
-      if (existsSync18(path) && !opts.force) {
+      if (existsSync19(path) && !opts.force) {
         throw new Error(`${path} already exists; pass --force to overwrite it`);
       }
       const machine = realMachine(ctx.env);
@@ -11704,7 +11990,7 @@ function registerConfigCommands(program) {
         repositories: repositoryBlocks(repos, ctx.env),
         cpus: navigator.hardwareConcurrency || 1
       });
-      mkdirSync11(dirname11(resolve5(path)), { recursive: true, mode: 448 });
+      mkdirSync11(dirname12(resolve5(path)), { recursive: true, mode: 448 });
       writeFileSync6(path, text);
       if (!ctx.json)
         console.log(`Wrote ${tildify(path, ctx.env)}.`);
@@ -11744,15 +12030,118 @@ function registerConfigCommands(program) {
   });
 }
 
+// src/commands/cost.ts
+var COST_DIMENSIONS = [
+  "session",
+  "root-session",
+  "issue",
+  "runner",
+  "owner",
+  "issuer",
+  "role",
+  "agent",
+  "repository",
+  "day"
+];
+function usd(usd) {
+  if (usd === null)
+    return "-";
+  if (usd !== 0 && Math.abs(usd) < 0.01)
+    return `$${usd.toPrecision(2)}`;
+  return `$${usd.toFixed(2)}`;
+}
+function describeTotals(totals) {
+  const turns = `${totals.turns} turn${totals.turns === 1 ? "" : "s"}`;
+  const unpriced = totals.unpricedTurns ? ` (${totals.unpricedTurns} unpriced)` : "";
+  const tokens = `${totals.inputTokens.toLocaleString("en-US")} in / ${totals.outputTokens.toLocaleString("en-US")} out`;
+  return `${usd(totals.costUsd)} over ${turns}${unpriced}, ${tokens}`;
+}
+function withFilters(command) {
+  return command.option("--session <id>", "only this agent session's turns").option("--root-session <id>", "only this manager session's turns and its dispatched workers'").option("--runner <id>", "only turns this runner ran").option("--owner <userId>", "only turns on runners this user owns").option("--issuer <userId>", "only turns this user asked for").option("--role <role>", "only turns in this role: manager or worker").option("--since <time>", "only turns that ended since: ISO-8601, epoch ms, or 7d / 12h / 30m").option("--until <time>", "only turns that ended before: ISO-8601, epoch ms, or 7d / 12h / 30m");
+}
+function filterQuery(command) {
+  const opts = command.opts();
+  return {
+    agentSessionId: opts.session,
+    rootAgentSessionId: opts.rootSession,
+    runnerId: opts.runner,
+    runnerUserId: opts.owner,
+    issuerUserId: opts.issuer,
+    role: opts.role,
+    since: opts.since ? String(parseTime(opts.since)) : undefined,
+    until: opts.until ? String(parseTime(opts.until)) : undefined
+  };
+}
+function registerCostCommands(program) {
+  const cost = program.command("cost").description("What the selected project's agent sessions cost, and whom it is attributed to");
+  withPaging(withFilters(cost.command("list").description("List each turn's cost, newest first, with its session, runner, and role"))).action(async function() {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("GET", "/costs", {
+        query: { projectId, ...filterQuery(this), ...pageQuery(this) }
+      });
+      emit(ctx, result, () => `${table(result.costRecords.map((r) => ({
+        ended: when(r.endedAt),
+        issue: r.issueIdentifier ?? "-",
+        session: r.agentSessionId,
+        role: r.role ?? "-",
+        kind: r.kind,
+        runner: r.runnerName,
+        agent: r.agentId ?? "-",
+        ending: r.ending,
+        tokens: `${r.inputTokens ?? "-"} / ${r.outputTokens ?? "-"}`,
+        cost: usd(r.costUsd)
+      })), [
+        { key: "ended" },
+        { key: "issue" },
+        { key: "session" },
+        { key: "role" },
+        { key: "kind" },
+        { key: "runner" },
+        { key: "agent" },
+        { key: "ending" },
+        { key: "tokens" },
+        { key: "cost" }
+      ])}
+total ${describeTotals(result.total)}${pageFooter(result.pagination)}`);
+    });
+  });
+  withPaging(withFilters(cost.command("summary").description("Total the turns' cost by one dimension, most expensive first").option("--by <dimension>", `what to group by: ${COST_DIMENSIONS.join(", ")}`, "session"))).action(async function() {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const { by } = this.opts();
+      const result = await ctx.signedInClient().request("GET", "/costs/summary", {
+        query: { projectId, by, ...filterQuery(this), ...pageQuery(this) }
+      });
+      emit(ctx, result, () => `${table(result.groups.map((g) => ({
+        [result.by]: g.label ?? g.key ?? "(none)",
+        turns: g.turns,
+        unpriced: g.unpricedTurns,
+        "input tokens": g.inputTokens,
+        "output tokens": g.outputTokens,
+        cost: usd(g.costUsd)
+      })), [
+        { key: result.by, maxWidth: 50 },
+        { key: "turns" },
+        { key: "unpriced" },
+        { key: "input tokens" },
+        { key: "output tokens" },
+        { key: "cost" }
+      ])}
+total ${describeTotals(result.total)}${pageFooter(result.pagination)}`);
+    });
+  });
+}
+
 // src/commands/doctor.ts
-import { existsSync as existsSync20, statfsSync as statfsSync2, statSync as statSync6 } from "fs";
+import { existsSync as existsSync21, statfsSync as statfsSync2, statSync as statSync6 } from "fs";
 import { hostname as hostname6 } from "os";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 
 // src/commands/service.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir3, userInfo } from "os";
-import { dirname as dirname12, join as join11 } from "path";
+import { dirname as dirname13, join as join11 } from "path";
 
 // src/daemon/units/launchd.plist
 var launchd_default = `<?xml version="1.0" encoding="UTF-8"?>
@@ -11888,7 +12277,7 @@ function registerServiceCommands(program) {
         console.log(text);
         return;
       }
-      mkdirSync12(dirname12(path), { recursive: true });
+      mkdirSync12(dirname13(path), { recursive: true });
       mkdirSync12(paths.stateDir, { recursive: true, mode: 448 });
       writeFileSync7(path, text);
       if (platform === "darwin") {
@@ -11909,7 +12298,7 @@ function registerServiceCommands(program) {
   service.command("uninstall").description("Stop the service and remove its unit file").action(async function() {
     await runCommand(this, async (ctx) => {
       const path = unitPath(process.platform, ctx.env);
-      if (!path || !existsSync19(path)) {
+      if (!path || !existsSync20(path)) {
         emit(ctx, { removed: false }, () => "No service is installed.");
         return;
       }
@@ -11927,7 +12316,7 @@ function registerServiceCommands(program) {
   service.command("status").description("Show whether the service is installed and loaded, and the daemon's status").action(async function() {
     await runCommand(this, async (ctx) => {
       const path = unitPath(process.platform, ctx.env);
-      const installed = Boolean(path && existsSync19(path));
+      const installed = Boolean(path && existsSync20(path));
       let manager = "not installed";
       if (installed && process.platform === "darwin") {
         manager = run(["launchctl", "print", `gui/${userInfo().uid}/${LAUNCHD_LABEL}`], true).includes("state = running") ? "running" : "loaded, not running";
@@ -12015,7 +12404,7 @@ async function runDoctor(ctx, options) {
     return list.checks;
   }
   let runner = null;
-  if (!existsSync20(ctx.credentialsPath)) {
+  if (!existsSync21(ctx.credentialsPath)) {
     list.fail("credentials", `${tildify(ctx.credentialsPath, ctx.env)} does not exist \u2014 \`hypotenuse login\`, then \`hypotenuse runner register\``);
   } else {
     try {
@@ -12078,7 +12467,7 @@ async function runDoctor(ctx, options) {
     list.warn("daemon", "not running \u2014 `hypotenuse daemon start` or `hypotenuse service install`");
   }
   const unit = unitPath(process.platform, ctx.env);
-  if (unit && existsSync20(unit))
+  if (unit && existsSync21(unit))
     list.ok("daemon", `service unit ${tildify(unit, ctx.env)}`);
   else if (unit)
     list.warn("daemon", "no service unit \u2014 `hypotenuse service install` starts the daemon at login");
@@ -12146,8 +12535,8 @@ async function runDoctor(ctx, options) {
 `).at(-1) ?? ""}`);
   }
   let probePath = config.sessions.worktree_root;
-  while (!existsSync20(probePath) && dirname13(probePath) !== probePath)
-    probePath = dirname13(probePath);
+  while (!existsSync21(probePath) && dirname14(probePath) !== probePath)
+    probePath = dirname14(probePath);
   try {
     const fs = statfsSync2(probePath);
     const free = fs.bavail * fs.bsize;
@@ -13511,6 +13900,11 @@ function describeSession(session, activities, tree = {}) {
   if (tree.issuer?.user) {
     lines.push(`issuer     ${tree.issuer.user.name}`);
   }
+  if (tree.cost?.turns)
+    lines.push(`cost       ${describeTotals(tree.cost)}`);
+  if (tree.treeCost && tree.treeCost.turns > (tree.cost?.turns ?? 0)) {
+    lines.push(`tree cost  ${describeTotals(tree.treeCost)} with its workers`);
+  }
   if (session.summary)
     lines.push(`summary    ${session.summary}`);
   if (session.externalUrl)
@@ -13737,7 +14131,7 @@ function registerSessionCommands(program) {
 }
 
 // src/commands/skill.ts
-import { existsSync as existsSync21, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync13 } from "fs";
 import { join as join13 } from "path";
 var SKILL_FILE = "hypotenuse.md";
 async function readSkill() {
@@ -13746,8 +14140,8 @@ async function readSkill() {
     return embedded.text();
   for (const up of [[".."], ["..", ".."]]) {
     const path = join13(import.meta.dir, ...up, "skills", SKILL_FILE);
-    if (existsSync21(path))
-      return readFileSync12(path, "utf8");
+    if (existsSync22(path))
+      return readFileSync13(path, "utf8");
   }
   throw new Error(`This install has no skills/${SKILL_FILE}; reinstall hypotenuse.`);
 }
@@ -14245,6 +14639,7 @@ function buildProgram() {
   registerIntegrationCommands(program);
   registerSessionCommands(program);
   registerEventCommands(program);
+  registerCostCommands(program);
   registerRunnerCommands(program);
   registerRoutingCommands(program);
   registerTelemetryCommands(program);