@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/tools/workflows/run-workflow.test.ts

@@ -11,11 +11,9 @@ mock.module("../../util/logger.js", () => ({
 }));
 
 // ── Mutable mock state ────────────────────────────────────────────────
-// `flagEnabled` toggles the `workflows` feature flag; `configThrows`
-// simulates config not yet loaded (test-setup race). The run-manager mock
-// records the args of the last `start()` call for assertion.
+// `configThrows` simulates config not yet loaded (test-setup race). The
+// run-manager mock records the args of the last `start()` call for assertion.
 
-let flagEnabled = true;
 let configThrows = false;
 
 const realLoader = await import("../../config/loader.js");
@@ -35,13 +33,6 @@ mock.module("../../config/loader.js", () => ({
     }) as unknown as ReturnType<typeof realLoader.loadConfig>,
 }));
 
-const realFlags = await import("../../config/assistant-feature-flags.js");
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  ...realFlags,
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "workflows" ? flagEnabled : false,
-}));
-
 // No live conversation in tests — the tool falls back to a synthetic trust
 // context built from the tool context's trustClass.
 const realRegistry = await import("../../daemon/conversation-registry.js");
@@ -92,7 +83,6 @@ function makeContext(): Parameters<typeof executeRunWorkflow>[1] {
 }
 
 beforeEach(() => {
-  flagEnabled = true;
   configThrows = false;
   startThrows = null;
   lastStartArgs = null;
@@ -105,10 +95,10 @@ beforeEach(() => {
 });
 
 describe("workflow tools are served by the workflows skill", () => {
-  // The cutover moved run_workflow / manage_workflows out of the always-on tool
-  // manifest into the flag-gated `workflows` bundled skill (loaded via
-  // skill_load, invoked via skill_execute). The skill manifest is the
-  // source of truth; assert it declares both as in-process host tools.
+  // run_workflow / manage_workflows are served by the `workflows` bundled skill
+  // (loaded via skill_load, invoked via skill_execute), not the always-on tool
+  // manifest. The skill manifest is the source of truth; assert it declares both
+  // as in-process host tools.
   test("the workflows skill TOOLS.json declares both host-executed tools", async () => {
     const { readFileSync } = await import("node:fs");
     const { join } = await import("node:path");
@@ -211,13 +201,13 @@ describe("run_workflow launch", () => {
   });
 
   test("surfaces a run-manager start error as a tool error", async () => {
-    startThrows = new Error("Workflows are not enabled.");
+    startThrows = new Error("run manager exploded");
     const res = await executeRunWorkflow(
       { script: "export const meta = {};" },
       makeContext(),
     );
     expect(res.isError).toBe(true);
-    expect(res.content).toContain("Workflows are not enabled.");
+    expect(res.content).toContain("run manager exploded");
   });
 });
 

package/src/tools/workflows/run-workflow.ts

@@ -68,6 +68,7 @@ export async function executeRunWorkflow(
       args,
       manifest,
       conversationId: context.conversationId,
+      ...(context.toolUseId ? { toolUseId: context.toolUseId } : {}),
       ...(label ? { label } : {}),
       trustContext,
     });

package/src/util/disk-usage.ts

@@ -1,7 +1,11 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, statfsSync } from "node:fs";
 
-import { getMinikubeStorageSize } from "../config/env-registry.js";
+import {
+  getIsContainerized,
+  getIsPlatform,
+  getMinikubeStorageSize,
+} from "../config/env-registry.js";
 import { getWorkspaceDir } from "./platform.js";
 
 export interface DiskUsageInfo {
@@ -58,6 +62,57 @@ export function __resetDiskUsageCacheForTests(): void {
   duCachePaths = null;
 }
 
+/**
+ * How the workspace volume's capacity should be reported when statfsSync
+ * cannot see the volume directly.
+ *
+ * - `fixed-cap`: minikube hostPath PVC — the PVC request is the hard
+ *   capacity, so usage is measured with `du` and free space is whatever
+ *   remains within the quota.
+ * - `host-free`: local Docker named volume — the volume is backed by the
+ *   host (or Colima VM) filesystem and can grow into its free space, so
+ *   usage is measured with `du` and the effective capacity is current usage
+ *   plus the host's remaining headroom.
+ * - `none`: statfsSync already reports the volume accurately (bare metal, or
+ *   a platform-managed instance on a CSI-backed PVC), so use it directly.
+ */
+type WorkspaceVolumeReporting =
+  | { kind: "none" }
+  | { kind: "fixed-cap"; totalBytes: number }
+  | { kind: "host-free" };
+
+/**
+ * Decide how to report the workspace volume's capacity. Both minikube
+ * hostPath PVCs and local Docker named volumes are backed by the host
+ * filesystem, so statfsSync reports the host's entire disk rather than the
+ * workspace volume — in both cases we measure actual usage with `du` instead.
+ */
+function classifyWorkspaceVolume(
+  fsTotalBytes: number,
+): WorkspaceVolumeReporting {
+  // Minikube mode: the platform passes the PVC storage size so we can report
+  // accurate capacity. Detect the hostPath case by comparing filesystem size
+  // against the PVC size — if the filesystem is larger, statfsSync is seeing
+  // the host disk and we should measure the directory instead.
+  const storageSizeRaw = getMinikubeStorageSize();
+  if (storageSizeRaw) {
+    const pvcTotalBytes = parseK8sMemoryBytes(storageSizeRaw);
+    if (pvcTotalBytes !== null && fsTotalBytes > pvcTotalBytes * 1.1) {
+      return { kind: "fixed-cap", totalBytes: pvcTotalBytes };
+    }
+    return { kind: "none" };
+  }
+
+  // Local Docker hatch: the workspace is a Docker named volume backed by the
+  // host filesystem. Platform-managed remote instances run on CSI-backed PVCs
+  // where statfsSync already reports the volume, so they are excluded.
+  if (getIsContainerized() && !getIsPlatform()) {
+    return { kind: "host-free" };
+  }
+
+  return { kind: "none" };
+}
+
 export function getDiskUsageInfo(): DiskUsageInfo | null {
   try {
     const wsDir = getWorkspaceDir();
@@ -68,28 +123,28 @@ export function getDiskUsageInfo(): DiskUsageInfo | null {
     const bytesToMb = (b: number) =>
       Math.round((b / (1024 * 1024)) * 100) / 100;
 
-    // Minikube mode: the platform passes the PVC storage size so we can
-    // report accurate capacity. On hostPath-backed PVCs statfsSync reports
-    // the host's entire filesystem rather than the PVC. Detect this by
-    // comparing filesystem size against PVC size — if the filesystem is
-    // larger, measure actual directory usage with `du` instead.
-    const storageSizeRaw = getMinikubeStorageSize();
-    if (storageSizeRaw) {
-      const pvcTotalBytes = parseK8sMemoryBytes(storageSizeRaw);
-      if (pvcTotalBytes !== null && fsTotalBytes > pvcTotalBytes * 1.1) {
-        const volumePaths = [diskPath];
-        if (diskPath !== "/data" && existsSync("/data")) {
-          volumePaths.push("/data");
-        }
-        const usedBytes = getCachedDirectorySizeBytes(volumePaths);
-        if (usedBytes !== null) {
-          return {
-            path: diskPath,
-            totalMb: bytesToMb(pvcTotalBytes),
-            usedMb: bytesToMb(usedBytes),
-            freeMb: bytesToMb(Math.max(0, pvcTotalBytes - usedBytes)),
-          };
-        }
+    const reporting = classifyWorkspaceVolume(fsTotalBytes);
+    if (reporting.kind !== "none") {
+      const volumePaths = [diskPath];
+      if (diskPath !== "/data" && existsSync("/data")) {
+        volumePaths.push("/data");
+      }
+      const usedBytes = getCachedDirectorySizeBytes(volumePaths);
+      if (usedBytes !== null) {
+        const totalBytes =
+          reporting.kind === "fixed-cap"
+            ? reporting.totalBytes
+            : usedBytes + fsFreeBytes;
+        const freeBytes =
+          reporting.kind === "fixed-cap"
+            ? Math.max(0, reporting.totalBytes - usedBytes)
+            : fsFreeBytes;
+        return {
+          path: diskPath,
+          totalMb: bytesToMb(totalBytes),
+          usedMb: bytesToMb(usedBytes),
+          freeMb: bytesToMb(freeBytes),
+        };
       }
     }
 

package/src/util/logs-db-path.ts

@@ -0,0 +1,22 @@
+import { join } from "node:path";
+
+import { getDataDir } from "./platform.js";
+
+/**
+ * Path to the secondary SQLite file that houses heavy append-only tables
+ * (LLM request logs, and other log/event tables over time). It lives in the
+ * same `data/db` directory as the main DB and is ATTACHed to the daemon's
+ * connection as the `logs` schema (see `memory/db-connection.ts`). Splitting
+ * these tables into their own file keeps the main DB — and its WAL — small and
+ * lets the two files VACUUM/checkpoint independently.
+ *
+ * Kept in its own leaf module rather than alongside `getDbPath()` in
+ * `platform.ts`: `platform.ts` is imported very early and widely, and adding an
+ * export to it that low-level consumers (e.g. `db-connection.ts`) pull in
+ * across the daemon's large, cyclic import graph trips a Bun link-order bug
+ * ("Export named 'getLogsDbPath' not found"). Isolating it here keeps
+ * `platform.ts`'s module shape stable.
+ */
+export function getLogsDbPath(): string {
+  return join(getDataDir(), "db", "assistant-logs.db");
+}

package/src/util/platform.ts

@@ -314,7 +314,14 @@ export function getWorkspaceToolsDir(): string {
   return join(getWorkspaceDir(), "tools");
 }
 
-/** Returns $VELLUM_WORKSPACE_DIR/routes — user-defined HTTP route handlers. */
+/**
+ * Returns $VELLUM_WORKSPACE_DIR/routes — user-defined HTTP route handlers.
+ *
+ * Handler modules under this directory are dynamic-imported by the user-route
+ * dispatcher and their exported HTTP-method functions are executed on the
+ * next matching request, so the file risk classifier escalates writes under
+ * this path to High for the same reason `plugins/` and `tools/` are escalated.
+ */
 export function getWorkspaceRoutesDir(): string {
   return join(getWorkspaceDir(), "routes");
 }
@@ -402,8 +409,8 @@ export function getSkillRuntimePath(
  *
  * Resolution order:
  *
- *   1. macOS `.app` bundle: `Contents/Resources/bun` — shipped by
- *      `clients/macos/build.sh` at a version that matches `.tool-versions`.
+ *   1. macOS `.app` bundle: `Contents/Resources/bun` — bundled at a version
+ *      that matches `.tool-versions`.
  *   2. Next-to-binary: `<execDir>/bun` for Docker/generic compiled layouts
  *      that stage a bun binary alongside the daemon (PR 29 wires this up).
  *

package/src/watcher/telemetry.ts

@@ -4,8 +4,8 @@
  * ahead of the planned watcher → skills-and-schedules migration.
  *
  * Both event shapes ship through the existing lifecycle-event telemetry
- * pipeline, so they inherit its `collectUsageData` opt-out gate and need
- * no wire-contract or platform-side changes:
+ * pipeline, so they inherit its platform `share_analytics` consent gate and
+ * need no wire-contract or platform-side changes:
  *
  * - `watcher_enabled:<providerId>` — one per enabled watcher, at most
  *   once per 24h per daemon. Counts devices that have watchers

package/src/workflows/capabilities.ts

@@ -29,9 +29,8 @@
  *   (If host execution is ever wanted, the deliberate path is to thread the
  *   originating tool context through the engine — not to relax this gate.)
  *
- * This module is pure logic: it performs no feature-flag checks and no I/O
- * beyond the synchronous tool-registry lookup. The `workflows` flag gates the
- * callers, not this code.
+ * This module is pure logic: it performs no I/O beyond the synchronous
+ * tool-registry lookup.
  */
 
 import { z } from "zod";

package/src/workflows/engine.test.ts

@@ -16,7 +16,11 @@ import type { TrustContext } from "../daemon/trust-context.js";
 import { getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { ResolvedCapabilities } from "./capabilities.js";
-import { executeWorkflow, extractWorkflowMeta } from "./engine.js";
+import {
+  executeWorkflow,
+  extractWorkflowMeta,
+  type WorkflowLeafEvent,
+} from "./engine.js";
 import * as journalStore from "./journal-store.js";
 import type { LeafResult, RunLeafOptions } from "./leaf-runner.js";
 
@@ -677,6 +681,21 @@ describe("executeWorkflow — resume", () => {
     );
     expect(journalA.map((e) => e.seq)).toEqual([0, 1, 2]);
   });
+
+  test("a completed leaf persists its per-leaf token usage in the journal", async () => {
+    const runner = makeFakeRunner();
+    await execute("wf-leaf-tokens", `return agent("alpha");`, runner.runner);
+
+    const journal = journalStore.getJournal("wf-leaf-tokens");
+    expect(journal).toHaveLength(1);
+    // The fake runner reports 10/5 per leaf; the completed entry carries them.
+    expect(journal[0]).toMatchObject({
+      seq: 0,
+      status: "completed",
+      inputTokens: 10,
+      outputTokens: 5,
+    });
+  });
 });
 
 describe("executeWorkflow — schema vs tool leaf tool forwarding", () => {
@@ -1142,3 +1161,158 @@ describe("executeWorkflow — nested workflow()", () => {
     expect(second.prompts).toEqual([]);
   });
 });
+
+describe("executeWorkflow — onLeaf observe-only hook", () => {
+  beforeEach(resetTables);
+
+  /** Run a workflow, collecting every onLeaf event. */
+  function executeWithLeafEvents(
+    runId: string,
+    scriptSource: string,
+    runner: typeof import("./leaf-runner.js").runLeaf,
+    config: WorkflowsConfig = configWith(),
+    signal?: AbortSignal,
+  ): {
+    promise: ReturnType<typeof executeWorkflow>;
+    events: WorkflowLeafEvent[];
+  } {
+    const events: WorkflowLeafEvent[] = [];
+    const promise = executeWorkflow({
+      runId,
+      scriptSource: META + scriptSource,
+      args: null,
+      capabilities: CAPABILITIES,
+      config,
+      journal: journalStore,
+      leafRunner: runner,
+      trustContext: TRUST,
+      onLeaf: (e) => events.push(e),
+      ...(signal ? { signal } : {}),
+    });
+    return { promise, events };
+  }
+
+  test("a single agent() emits leaf_started then leaf_finished:completed at seq 0", async () => {
+    const fake = makeFakeRunner();
+    const { promise, events } = executeWithLeafEvents(
+      "wf-leaf-single",
+      `return agent("solo");`,
+      fake.runner,
+    );
+    const res = await promise;
+    expect(res.status).toBe("completed");
+
+    expect(events).toEqual([
+      { type: "leaf_started", seq: 0, promptSummary: "solo" },
+      {
+        type: "leaf_finished",
+        seq: 0,
+        status: "completed",
+        inputTokens: 10,
+        outputTokens: 5,
+        resultSummary: "out:solo",
+      },
+    ]);
+  });
+
+  test("a 3-spec parallel() emits 3 started + 3 finished across seqs 0,1,2", async () => {
+    const fake = makeFakeRunner();
+    const { promise, events } = executeWithLeafEvents(
+      "wf-leaf-parallel",
+      `return parallel([leaf("a"), leaf("b"), leaf("c")]);`,
+      fake.runner,
+    );
+    const res = await promise;
+    expect(res.status).toBe("completed");
+
+    const started = events.filter((e) => e.type === "leaf_started");
+    const finished = events.filter((e) => e.type === "leaf_finished");
+    expect(started.map((e) => e.seq).sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    expect(finished.map((e) => e.seq).sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    expect(finished.every((e) => e.status === "completed")).toBe(true);
+  });
+
+  test("a throwing (non-abort) leaf emits leaf_started then leaf_finished:failed", async () => {
+    const fake = makeFakeRunner({ failOn: (p) => p === "boom" });
+    const { promise, events } = executeWithLeafEvents(
+      "wf-leaf-fail",
+      `return parallel([leaf("boom")]);`,
+      fake.runner,
+    );
+    await promise;
+
+    expect(events).toEqual([
+      { type: "leaf_started", seq: 0, promptSummary: "boom" },
+      {
+        type: "leaf_finished",
+        seq: 0,
+        status: "failed",
+        inputTokens: 0,
+        outputTokens: 0,
+        resultSummary: "leaf failed: boom",
+      },
+    ]);
+  });
+
+  test("an aborted in-flight leaf emits leaf_started but NO leaf_finished", async () => {
+    const controller = new AbortController();
+    let started = false;
+    const runner = (async (): Promise<
+      import("./leaf-runner.js").LeafResult
+    > => {
+      started = true;
+      await new Promise<void>((resolve) => {
+        if (controller.signal.aborted) return resolve();
+        controller.signal.addEventListener("abort", () => resolve(), {
+          once: true,
+        });
+      });
+      const err = new Error("The operation was aborted");
+      err.name = "AbortError";
+      throw err;
+    }) as unknown as typeof import("./leaf-runner.js").runLeaf;
+
+    const { promise, events } = executeWithLeafEvents(
+      "wf-leaf-abort",
+      `return agent("long-running");`,
+      runner,
+      configWith(),
+      controller.signal,
+    );
+
+    await waitUntil(() => started);
+    controller.abort();
+
+    const res = await promise;
+    expect(res.status).toBe("aborted");
+    expect(events).toEqual([
+      { type: "leaf_started", seq: 0, promptSummary: "long-running" },
+    ]);
+  });
+
+  test("a journal-replayed leaf emits neither leaf_started nor leaf_finished", async () => {
+    const script = `return agent("alpha");`;
+
+    // First run journals the leaf as completed.
+    const first = makeFakeRunner();
+    const res1 = await executeWithLeafEvents(
+      "wf-leaf-replay",
+      script,
+      first.runner,
+    ).promise;
+    expect(res1.status).toBe("completed");
+    expect(first.prompts).toEqual(["alpha"]);
+
+    // Resume: the leaf replays from the journal, so no onLeaf events fire.
+    const second = makeFakeRunner();
+    const { promise, events } = executeWithLeafEvents(
+      "wf-leaf-replay",
+      script,
+      second.runner,
+    );
+    const res2 = await promise;
+    expect(res2.status).toBe("completed");
+    expect(second.prompts).toEqual([]);
+    expect(events).toEqual([]);
+  });
+});

package/src/workflows/engine.ts

@@ -73,6 +73,30 @@ export type WorkflowProgressEvent =
   | { type: "phase"; title: string }
   | { type: "log"; message: string };
 
+/**
+ * An observe-only lifecycle event for a single leaf — the source of a live leaf
+ * tree. Emitted once when a leaf STARTS (after the cap check + spawn increment)
+ * and once when it FINISHES (completed or failed). A journal-replayed leaf and
+ * an aborted in-flight leaf emit neither.
+ */
+export type WorkflowLeafEvent =
+  | {
+      type: "leaf_started";
+      seq: number;
+      label?: string;
+      phase?: string;
+      promptSummary: string;
+    }
+  | {
+      type: "leaf_finished";
+      seq: number;
+      status: "completed" | "failed";
+      label?: string;
+      inputTokens: number;
+      outputTokens: number;
+      resultSummary: string;
+    };
+
 /** The journal-store surface the engine depends on (injectable for tests). */
 export interface WorkflowJournal {
   appendJournalEntry: typeof JournalStore.appendJournalEntry;
@@ -108,6 +132,13 @@ export interface ExecuteWorkflowOptions {
   trustContext: TrustContext;
   /** Receives `phase`/`log` progress events from the script. */
   onProgress?: (event: WorkflowProgressEvent) => void;
+  /**
+   * Observe-only per-leaf lifecycle hook. Emits once on START (after the cap
+   * check + spawn increment; NEVER on a journal-replay short-circuit) and once
+   * on FINISH (completed or failed). An aborted in-flight leaf emits NEITHER a
+   * finish nor a spurious failed.
+   */
+  onLeaf?: (event: WorkflowLeafEvent) => void;
   /** Cooperative cancellation for the whole run. */
   signal?: AbortSignal;
 }
@@ -451,6 +482,26 @@ function skipRegexLiteral(source: string, start: number): number {
   return source.length - 1;
 }
 
+/**
+ * A bounded string summary of a leaf prompt or result, for an observe-only
+ * {@link WorkflowLeafEvent}. Strings pass through; everything else is
+ * JSON-serialized (falling back to `String(value)` if it cannot be). Truncated
+ * to `max` chars with a trailing ellipsis.
+ */
+function summarizeForLeafEvent(value: unknown, max = 200): string {
+  let text: string;
+  if (typeof value === "string") {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+
 function callHashOf(prompt: string, opts: LeafCallOptions): string {
   return createHash("sha256")
     .update(deterministicStringify({ prompt, opts }))
@@ -542,6 +593,7 @@ export async function executeWorkflow(
     leafRunner,
     trustContext,
     onProgress,
+    onLeaf,
     signal,
   } = opts;
 
@@ -630,6 +682,14 @@ export async function executeWorkflow(
     }
     agentsSpawned += 1;
 
+    onLeaf?.({
+      type: "leaf_started",
+      seq,
+      ...(leafOpts.label !== undefined ? { label: leafOpts.label } : {}),
+      ...(leafOpts.phase !== undefined ? { phase: leafOpts.phase } : {}),
+      promptSummary: summarizeForLeafEvent(prompt),
+    });
+
     try {
       // A leaf is EITHER a schema leaf (structured output via forced
       // tool-choice — `schema` set, no tools) OR a tool leaf (free-form with
@@ -666,6 +726,17 @@ export async function executeWorkflow(
         request: { prompt, opts: leafOpts },
         result: result.output,
         status: "completed",
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+      });
+      onLeaf?.({
+        type: "leaf_finished",
+        seq,
+        status: "completed",
+        ...(leafOpts.label !== undefined ? { label: leafOpts.label } : {}),
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        resultSummary: summarizeForLeafEvent(result.output),
       });
       return { output: result.output, failed: false };
     } catch (err) {
@@ -693,6 +764,17 @@ export async function executeWorkflow(
         { err, runId, seq, label: leafOpts.label },
         "Workflow leaf failed",
       );
+      onLeaf?.({
+        type: "leaf_finished",
+        seq,
+        status: "failed",
+        ...(leafOpts.label !== undefined ? { label: leafOpts.label } : {}),
+        inputTokens: 0,
+        outputTokens: 0,
+        resultSummary: summarizeForLeafEvent(
+          err instanceof Error ? err.message : String(err),
+        ),
+      });
       return { output: null, failed: true };
     }
   };

package/src/workflows/journal-store.test.ts

@@ -197,6 +197,76 @@ describe("workflow journal store", () => {
     });
   });
 
+  test("appendJournalEntry round-trips per-leaf token usage", () => {
+    createRun({ id: "wf-tok", scriptSource: "s", scriptHash: "h" });
+
+    appendJournalEntry({
+      runId: "wf-tok",
+      seq: 0,
+      callHash: "c0",
+      kind: "agent",
+      request: { prompt: "with tokens" },
+      result: { text: "r" },
+      status: "completed",
+      inputTokens: 120,
+      outputTokens: 45,
+    });
+    // A leaf with no recorded usage stores NULL → reads back as undefined.
+    appendJournalEntry({
+      runId: "wf-tok",
+      seq: 1,
+      callHash: "c1",
+      kind: "agent",
+      request: { prompt: "no tokens" },
+      result: { error: "boom" },
+      status: "failed",
+    });
+
+    const journal = getJournal("wf-tok");
+    expect(journal[0]).toMatchObject({
+      seq: 0,
+      inputTokens: 120,
+      outputTokens: 45,
+    });
+    expect(journal[1].inputTokens).toBeUndefined();
+    expect(journal[1].outputTokens).toBeUndefined();
+  });
+
+  test("appendJournalEntry upserts token usage on a changed-hash re-run", () => {
+    createRun({ id: "wf-tok-resume", scriptSource: "s", scriptHash: "h" });
+
+    appendJournalEntry({
+      runId: "wf-tok-resume",
+      seq: 0,
+      callHash: "hash-old",
+      kind: "agent",
+      result: { text: "old" },
+      status: "completed",
+      inputTokens: 10,
+      outputTokens: 5,
+    });
+    // Resume re-runs the leaf with new usage; the upsert overwrites the tokens.
+    appendJournalEntry({
+      runId: "wf-tok-resume",
+      seq: 0,
+      callHash: "hash-new",
+      kind: "agent",
+      result: { text: "new" },
+      status: "completed",
+      inputTokens: 30,
+      outputTokens: 12,
+    });
+
+    const journal = getJournal("wf-tok-resume");
+    expect(journal).toHaveLength(1);
+    expect(journal[0]).toMatchObject({
+      seq: 0,
+      callHash: "hash-new",
+      inputTokens: 30,
+      outputTokens: 12,
+    });
+  });
+
   test("appendJournalEntry is idempotent on (run_id, seq)", () => {
     createRun({ id: "wf-dup", scriptSource: "s", scriptHash: "h" });