@sweny-ai/core 0.1.198 → 0.1.200

package/dist/harness/prompts.d.ts

@@ -4,8 +4,16 @@
  * `ClaudeClient.ask` / `ClaudeClient.evaluate` built before the harness seam
  * (#330); prompts.test.ts pins them against the old builders.
  */
-import type { Claude, JSONSchema, Logger } from "../types.js";
+import type { Claude, JSONSchema, Logger, NodeUsage } from "../types.js";
 import type { AgentHarness } from "./types.js";
+/**
+ * Hand a completion's usage to the caller's `onUsage`, once, before the
+ * adapter looks at whether the completion succeeded (a failed one was still
+ * billed). A hook that throws is logged and ignored: it never changes the
+ * completion's result, so a good answer is never turned into a failure (and
+ * a judge or route call is never repeated because of it).
+ */
+export declare function reportCompletionUsage(onUsage: ((usage: NodeUsage) => void) | undefined, usage: NodeUsage | undefined, logger?: Logger): void;
 /** @internal Registers the legacy object behind a compat harness. */
 export declare function registerLegacyClaude(harness: AgentHarness, claude: Claude): void;
 /** @internal The legacy `Claude` behind a compat harness, if any. */
@@ -48,6 +56,7 @@ export declare function ask(harness: AgentHarness, opts: {
     model?: string;
     timeoutMs?: number;
     signal?: AbortSignal;
+    onUsage?: (usage: NodeUsage) => void;
 }): Promise<string>;
 /**
  * Route evaluation: pick one of N choices. Fails closed: null when the
@@ -62,4 +71,5 @@ export declare function evaluate(harness: AgentHarness, opts: {
     }[];
     timeoutMs?: number;
     signal?: AbortSignal;
+    onUsage?: (usage: NodeUsage) => void;
 }, logger?: Logger): Promise<string | null>;

package/dist/harness/prompts.js

@@ -6,6 +6,23 @@
  */
 import { consoleLogger } from "../types.js";
 import { fenceUntrustedJson } from "../untrusted.js";
+/**
+ * Hand a completion's usage to the caller's `onUsage`, once, before the
+ * adapter looks at whether the completion succeeded (a failed one was still
+ * billed). A hook that throws is logged and ignored: it never changes the
+ * completion's result, so a good answer is never turned into a failure (and
+ * a judge or route call is never repeated because of it).
+ */
+export function reportCompletionUsage(onUsage, usage, logger) {
+    if (!onUsage || !usage)
+        return;
+    try {
+        onUsage(usage);
+    }
+    catch (err) {
+        (logger ?? consoleLogger).warn(`usage hook failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /** Legacy `Claude` objects wrapped by `claudeCompat()`, so their own ask/evaluate still win. */
 const LEGACY = new WeakMap();
 /** @internal Registers the legacy object behind a compat harness. */
@@ -76,13 +93,14 @@ export async function ask(harness, opts) {
     const legacy = legacyClaudeOf(harness);
     if (legacy)
         return legacy.ask(opts);
-    const { instruction, context, model, timeoutMs, signal } = opts;
+    const { instruction, context, model, timeoutMs, signal, onUsage } = opts;
     const response = await harness.complete({
         prompt: buildAskPrompt(instruction, context),
         model,
         timeoutMs,
         signal,
         purpose: "ask",
+        ...(onUsage ? { onUsage } : {}),
     });
     return (response ?? "").trim();
 }
@@ -95,12 +113,13 @@ export async function evaluate(harness, opts, logger) {
     if (legacy)
         return legacy.evaluate(opts);
     const log = logger ?? harness.logger ?? consoleLogger;
-    const { question, context, choices, timeoutMs, signal } = opts;
+    const { question, context, choices, timeoutMs, signal, onUsage } = opts;
     const response = await harness.complete({
         prompt: buildEvaluatePrompt(question, context, choices),
         timeoutMs,
         signal,
         purpose: "evaluate",
+        ...(onUsage ? { onUsage } : {}),
     });
     // The adapter already logged why; fail closed with no decision.
     if (response === null)

package/dist/harness/sandbox-wrapper.d.ts

@@ -107,11 +107,22 @@ export interface SrtSettings {
  * each with an optional `:port`. Dropping an entry only narrows egress.
  */
 export declare function isSrtDomainPattern(entry: string): boolean;
+/**
+ * Credential files an agent env points at outside `credentialHome`: the
+ * {@link CREDENTIAL_PATHS} under its `HOME` when that is another directory (a
+ * harness `env` overlay), `$CLAUDE_CONFIG_DIR/.credentials.json` and
+ * `$CODEX_HOME/auth.json`. A relative value resolves against the agent's
+ * `cwd`, where the agent would resolve it, never sweny's. Absolute paths.
+ */
+export declare function envCredentialPaths(env: Record<string, string> | undefined, credentialHome: string, cwd: string): string[];
 /**
  * The srt settings for one wrapped spawn. Pure apart from `exists`.
- * `credentialHome` is the operator's real HOME (not the scratch HOME).
+ * `credentialHome` is the operator's real HOME (not the scratch HOME); the
+ * login files `req.env` selects elsewhere are denied too ({@link envCredentialPaths}).
  */
-export declare function buildSrtSettings(req: Pick<SandboxWrapRequest, "cwd" | "egress" | "readOnly" | "denyRead">, opts: {
+export declare function buildSrtSettings(req: Pick<SandboxWrapRequest, "cwd" | "egress" | "readOnly" | "denyRead"> & {
+    env?: Record<string, string>;
+}, opts: {
     home: string;
     credentialHome: string;
     exists?: (p: string) => boolean;

package/dist/harness/sandbox-wrapper.js

@@ -116,16 +116,41 @@ function real(p) {
         return p;
     }
 }
+/**
+ * Credential files an agent env points at outside `credentialHome`: the
+ * {@link CREDENTIAL_PATHS} under its `HOME` when that is another directory (a
+ * harness `env` overlay), `$CLAUDE_CONFIG_DIR/.credentials.json` and
+ * `$CODEX_HOME/auth.json`. A relative value resolves against the agent's
+ * `cwd`, where the agent would resolve it, never sweny's. Absolute paths.
+ */
+export function envCredentialPaths(env, credentialHome, cwd) {
+    if (!env)
+        return [];
+    const at = (dir, ...rest) => path.resolve(cwd, dir, ...rest);
+    const out = [];
+    if (env.HOME && at(env.HOME) !== path.resolve(credentialHome)) {
+        out.push(...CREDENTIAL_PATHS.map((rel) => at(env.HOME, rel)));
+    }
+    if (env.CLAUDE_CONFIG_DIR)
+        out.push(at(env.CLAUDE_CONFIG_DIR, ".credentials.json"));
+    if (env.CODEX_HOME)
+        out.push(at(env.CODEX_HOME, "auth.json"));
+    return out;
+}
 /**
  * The srt settings for one wrapped spawn. Pure apart from `exists`.
- * `credentialHome` is the operator's real HOME (not the scratch HOME).
+ * `credentialHome` is the operator's real HOME (not the scratch HOME); the
+ * login files `req.env` selects elsewhere are denied too ({@link envCredentialPaths}).
  */
 export function buildSrtSettings(req, opts) {
     const exists = opts.exists ?? existsSync;
     const allowedDomains = [...new Set(req.egress.map((d) => d.trim()).filter(isSrtDomainPattern))];
-    const denyRead = (opts.credentialPaths ?? CREDENTIAL_PATHS)
-        .map((rel) => (path.isAbsolute(rel) ? rel : path.join(opts.credentialHome, rel)))
-        .filter((p) => exists(p));
+    const denyRead = [
+        ...new Set([
+            ...(opts.credentialPaths ?? CREDENTIAL_PATHS).map((rel) => path.isAbsolute(rel) ? rel : path.join(opts.credentialHome, rel)),
+            ...envCredentialPaths(req.env, opts.credentialHome, req.cwd),
+        ]),
+    ].filter((p) => exists(p));
     // Deny the parent, not a snapshot of sibling homes: later-created runs
     // must stay hidden too. srt allowRead carves out only our own HOME.
     if (opts.isolationRoot)

package/dist/harness/types.d.ts

@@ -9,7 +9,7 @@
  * Browser-safe: types only, no runtime imports.
  */
 import type { AgentAccess } from "../agent-env.js";
-import type { Claude, Logger, NodeResult } from "../types.js";
+import type { Claude, Logger, NodeResult, NodeUsage } from "../types.js";
 export type HarnessId = "claude-code" | "mock" | "codex" | "pi" | "hermes" | "gemini" | `acp:${string}`;
 /** Portable tool vocabulary for node policy. */
 export type ToolClass = "shell" | "write" | "edit" | "net" | "subagent";
@@ -163,6 +163,14 @@ export interface HarnessCompleteRequest {
      * logs ("claude.ask: ..." vs "claude.evaluate: ..."); it never changes the query.
      */
     purpose?: "ask" | "evaluate";
+    /**
+     * Called at most once per completion with that completion's total usage
+     * (not cumulative, unlike the run request's `onUsage`), before any failure
+     * check: a failed completion was still billed. An adapter that cannot report
+     * usage never calls it. Guard the call so a throwing hook never changes the
+     * result or repeats the completion (in-tree adapters use `reportCompletionUsage`).
+     */
+    onUsage?: (usage: NodeUsage) => void;
 }
 export interface AgentHarness {
     readonly id: HarnessId;

package/dist/index.d.ts

@@ -29,14 +29,14 @@ export { execute, RouteEvaluationError } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
 export { systemOneProvider } from "./decider.js";
 export type { DeciderConfig, DeciderOperatorConfig } from "./decider.js";
-export { BudgetGuard, describeOverrun, minLimits, toLimits } from "./budget.js";
-export type { Budget, BudgetOverrun, BudgetUnit, SpendLimits } from "./budget.js";
+export { BudgetGuard, SPEND_KINDS, describeOverrun, minLimits, toLimits } from "./budget.js";
+export type { Budget, BudgetOverrun, BudgetUnit, KindSpend, SeedSpend, SpendBreakdown, SpendKind, SpendLimits, } from "./budget.js";
 export { resolveNodePermissions, buildNodePolicy } from "./node-policy.js";
 export type { ResolvedPermissions } from "./node-policy.js";
 export { applySafeOutputs, createEmitOutputTool, resolveActor, EMIT_OUTPUT_TOOL } from "./safe-outputs.js";
 export type { SafeOutputIntent, ActorInfo, WriteStageState } from "./safe-outputs.js";
-export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness, CodexHarness, PiHarness, SUPPORTED_AGENTS, } from "./harness/index.js";
-export type { AgentHarness, HarnessCapabilities, HarnessId, HarnessInfo, HarnessRunRequest, HarnessRunResult, NodePolicy, PolicyGateResult, PolicyWrappers, ToolClass, ClaudeCodeHarnessOptions, CodexHarnessOptions, PiHarnessOptions, } from "./harness/index.js";
+export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness, CodexHarness, PiHarness, SUPPORTED_AGENTS, reportCompletionUsage, } from "./harness/index.js";
+export type { AgentHarness, HarnessCapabilities, HarnessCompleteRequest, HarnessId, HarnessInfo, HarnessRunRequest, HarnessRunResult, NodePolicy, PolicyGateResult, PolicyWrappers, ToolClass, ClaudeCodeHarnessOptions, CodexHarnessOptions, PiHarnessOptions, } from "./harness/index.js";
 export { ClaudeClient, resolveAuthEnv } from "./harness/claude-code.js";
 export type { ClaudeClientOptions, SwenyAuthMode, ResolveAuthEnvOpts } from "./harness/claude-code.js";
 export { resolveExecutionModel } from "./model.js";

package/dist/index.js

@@ -30,11 +30,11 @@ export { execute, RouteEvaluationError } from "./executor.js";
 // Decision models (#357): config types and the provider adapter only
 export { systemOneProvider } from "./decider.js";
 // Least-privilege nodes and safe outputs (#365)
-export { BudgetGuard, describeOverrun, minLimits, toLimits } from "./budget.js";
+export { BudgetGuard, SPEND_KINDS, describeOverrun, minLimits, toLimits } from "./budget.js";
 export { resolveNodePermissions, buildNodePolicy } from "./node-policy.js";
 export { applySafeOutputs, createEmitOutputTool, resolveActor, EMIT_OUTPUT_TOOL } from "./safe-outputs.js";
 // Agent harness (the seam) and its adapters: Claude Code, Codex and pi
-export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness, CodexHarness, PiHarness, SUPPORTED_AGENTS, } from "./harness/index.js";
+export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness, CodexHarness, PiHarness, SUPPORTED_AGENTS, reportCompletionUsage, } from "./harness/index.js";
 // Claude client (back-compat: ClaudeClient is ClaudeCodeHarness, @deprecated)
 export { ClaudeClient, resolveAuthEnv } from "./harness/claude-code.js";
 // Execution model resolution

package/dist/journal.d.ts

@@ -53,6 +53,9 @@
  *   route            the edge taken after the visit (null = the run ended), and the rung that chose it
  *   usage            spend of one agent attempt (cumulative; one per model turn that raised it, written
  *                    synchronously, and the final figure when the attempt returns)
+ *   meter            spend of one of the executor's own completions (judge, route, reflect, screen),
+ *                    with a unique call id, written when it is counted. Judge, reflect and screen
+ *                    sit inside the visit; route sits after its node:end, before its route record
  *   agent:unsandboxed the visit's agent ran without an enforced sandbox
  *   run:end          success | failed | crashed
  *
@@ -61,8 +64,9 @@
  * the node with the reason, so a resume never under-counts spend or repeats a
  * write the journal did not see.
  *
- * Spend: a resume seeds the run budget with every attempt's journaled usage,
- * from authenticated records only, so a crash never resets the whole-run ceiling.
+ * Spend: a resume seeds the run budget with every attempt's journaled usage
+ * and every metered completion, by kind, from authenticated records only, so
+ * a crash never resets the whole-run ceiling.
  *
  * Recovery: an unterminated tail that is not complete JSON (power loss
  * mid-append) is truncated. An unterminated tail that IS complete JSON is
@@ -99,9 +103,9 @@
  * `--allow-repeat-writes` does not override a refusal: its outcome is known,
  * not unconfirmed.
  */
-import type { Logger, NodeResult, NodeUsage, RouteRung, Skill, Workflow } from "./types.js";
+import type { Logger, NodeResult, NodeUsage, RouteRung, Skill, ToolContext, Workflow } from "./types.js";
 import type { SafeOutputIntent, WriteStageState } from "./safe-outputs.js";
-import { type Spend } from "./budget.js";
+import { type SeedSpend, type Spend, type SpendKind } from "./budget.js";
 import type { DeciderCounters } from "./decider.js";
 /**
  * v3: each record's HMAC chains the run id and the previous record's HMAC.
@@ -386,8 +390,14 @@ export interface ResumePlan {
     receipts: Map<string, OutputRecord>;
     /** Writes whose handler refused (`output:refused`, #544): replayed on resume, never taken for applied. */
     refusals: Map<string, OutputRecord>;
-    /** Spend every earlier attempt journaled: the run budget starts here on resume. */
-    priorSpend: Spend;
+    /** Spend every earlier attempt and metered completion journaled, by kind: the run budget starts here on resume. */
+    priorSpend: SeedSpend;
+    /**
+     * Spend journaled per visit (`node#iteration`): its agent attempts and its
+     * judge, reflect and screen calls, every segment. A checkpointed visit's
+     * node budget resumes from it.
+     */
+    visitSpend: Map<string, Spend>;
     /**
      * Nodes whose agent ran without an enforced sandbox in an earlier attempt.
      * Such an agent could read the run key, so the journal's spend and write
@@ -402,7 +412,10 @@ export interface ResumePlan {
  * first; nothing but run:resume after run:end; a visit starts only where the
  * last route pointed (or the entry), or re-starts an unfinished or failed
  * visit after a resume; checkpoints, writes, usage and node:end only inside
- * the open visit; one route per finished visit, from that visit's node.
+ * the open visit; one route per finished visit, from that visit's node. A
+ * judge, reflect or screen meter record sits inside the open visit; a route
+ * meter record after the visit's node:end and before its route record (the
+ * route call is made then). Every meter record has its own call id.
  * Throws {@link JournalIntegrityError}.
  */
 export declare function checkRecordSequence(records: JournalRecord[]): void;
@@ -463,6 +476,7 @@ export type JournalReplay = {
     rung?: RouteRung;
 } | ({
     kind: "checkpoint";
+    spent?: Spend;
 } & JournalCheckpoint);
 /**
  * The executor's view of a journal (`ExecuteOptions.journal`). A hook that
@@ -477,6 +491,15 @@ export interface ExecutionJournal {
     checkpoint(node: string, iteration: number, cp: JournalCheckpoint): void;
     /** The skill map the write stage applies through: write tools journaled and made idempotent. */
     wrapWrites(node: string, iteration: number, skills: Map<string, Skill>): Map<string, Skill>;
+    /** Spend an earlier segment journaled for this visit (resume): its node budget starts there. */
+    visitSpent?(node: string, iteration: number): Spend | undefined;
+    /**
+     * Resume: whether this write was applied before the crash, from its receipt
+     * or, for an outstanding intent, the provider's read-only probes (a found
+     * write is recorded as recovered). `unknown` when the probe could not tell
+     * and repeat writes are not allowed.
+     */
+    reconcile?(node: string, iteration: number, skill: Skill, tool: string, args: unknown, ctx: ToolContext): Promise<"applied" | "unknown" | "absent">;
     nodeEnd(node: string, iteration: number, result: NodeResult, writeState: WriteStageState): void;
     /** The edge taken after a visit, and for a decision the rung that chose it (#357), so resume replays it. */
     route(from: string, to: string | null, rung?: RouteRung, decider?: DeciderCounters): void;
@@ -485,10 +508,16 @@ export interface ExecutionJournal {
      * attempt returned, otherwise a live report (written at once when it raises the spend).
      */
     usage?(node: string, iteration: number, attempt: number, usage: NodeUsage, final: boolean): void;
+    /**
+     * Spend of one of the executor's own completions (judge, route, reflect,
+     * screen), written when it is counted. `node`/`iteration` name the visit it
+     * belongs to; for a route call, the visit being routed from.
+     */
+    meter?(kind: Exclude<SpendKind, "node">, node: string, iteration: number, usage: NodeUsage): void;
     /** The visit's agent ran without an enforced sandbox: recorded so a resume can say so. */
     uncontained?(node: string, iteration: number): void;
-    /** Spend earlier attempts of this run already journaled (resume); the run budget starts from it. */
-    priorSpend?(): Spend | undefined;
+    /** Spend earlier attempts of this run already journaled (resume), by kind when known; the run budget starts from it. */
+    priorSpend?(): SeedSpend | undefined;
     /** Receipt `degraded` entries this journal adds to the run (e.g. `journal_unsandboxed`). */
     degraded?(): string[];
     /** The decider state earlier attempts of this run journaled (resume); undefined otherwise. */
@@ -607,12 +636,21 @@ export declare class RunJournal implements ExecutionJournal {
      * at most the turn it was in.
      */
     usage(node: string, iteration: number, attempt: number, usage: NodeUsage, final: boolean): void;
+    /** Journal one metered completion, synchronously, before the executor acts on it. */
+    meter(kind: Exclude<SpendKind, "node">, node: string, iteration: number, usage: NodeUsage): void;
     uncontained(node: string, iteration: number): void;
     degraded(): string[];
-    priorSpend(): Spend | undefined;
+    priorSpend(): SeedSpend | undefined;
     /** Close the run: `run:end` (when the journal still works), then release the lock. Never throws. */
     end(status: "success" | "failed" | "crashed"): void;
     wrapWrites(node: string, iteration: number, skills: Map<string, Skill>): Map<string, Skill>;
+    visitSpent(node: string, iteration: number): Spend | undefined;
+    /** Outputs of writes {@link reconcile} found on the provider, replayed by the write handler. */
+    private recoveredOutputs;
+    /** Provider probes already made for a write key: the handler reuses reconcile's, never probes twice. */
+    private probes;
+    reconcile(node: string, iteration: number, skill: Skill, tool: string, args: unknown, ctx: ToolContext): Promise<"applied" | "unknown" | "absent">;
+    private probe;
     private wrapTool;
 }
 export {};

package/dist/journal.js

@@ -53,6 +53,9 @@
  *   route            the edge taken after the visit (null = the run ended), and the rung that chose it
  *   usage            spend of one agent attempt (cumulative; one per model turn that raised it, written
  *                    synchronously, and the final figure when the attempt returns)
+ *   meter            spend of one of the executor's own completions (judge, route, reflect, screen),
+ *                    with a unique call id, written when it is counted. Judge, reflect and screen
+ *                    sit inside the visit; route sits after its node:end, before its route record
  *   agent:unsandboxed the visit's agent ran without an enforced sandbox
  *   run:end          success | failed | crashed
  *
@@ -61,8 +64,9 @@
  * the node with the reason, so a resume never under-counts spend or repeats a
  * write the journal did not see.
  *
- * Spend: a resume seeds the run budget with every attempt's journaled usage,
- * from authenticated records only, so a crash never resets the whole-run ceiling.
+ * Spend: a resume seeds the run budget with every attempt's journaled usage
+ * and every metered completion, by kind, from authenticated records only, so
+ * a crash never resets the whole-run ceiling.
  *
  * Recovery: an unterminated tail that is not complete JSON (power loss
  * mid-append) is truncated. An unterminated tail that IS complete JSON is
@@ -917,9 +921,12 @@ const RECORD_TYPES = new Set([
     "node:end",
     "route",
     "usage",
+    "meter",
     "agent:unsandboxed",
     "run:end",
 ]);
+/** The executor's own completions a `meter` record can name. */
+const METER_KINDS = new Set(["judge", "route", "reflect", "screen"]);
 const isPosInt = (v) => typeof v === "number" && Number.isInteger(v) && v > 0;
 const isName = (v) => typeof v === "string" && v.length > 0;
 const isAmount = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
@@ -935,7 +942,10 @@ const isCounters = (v) => typeof v === "object" &&
  * first; nothing but run:resume after run:end; a visit starts only where the
  * last route pointed (or the entry), or re-starts an unfinished or failed
  * visit after a resume; checkpoints, writes, usage and node:end only inside
- * the open visit; one route per finished visit, from that visit's node.
+ * the open visit; one route per finished visit, from that visit's node. A
+ * judge, reflect or screen meter record sits inside the open visit; a route
+ * meter record after the visit's node:end and before its route record (the
+ * route call is made then). Every meter record has its own call id.
  * Throws {@link JournalIntegrityError}.
  */
 export function checkRecordSequence(records) {
@@ -949,6 +959,7 @@ export function checkRecordSequence(records) {
     const visits = new Map();
     const checkpointed = new Set();
     const intentKeys = new Set();
+    const meterCalls = new Set();
     const inVisit = (r) => {
         if (!cur || cur.ended)
             bad(r, "is outside any open node visit");
@@ -1029,6 +1040,25 @@ export function checkRecordSequence(records) {
                     bad(r, "has invalid amounts");
                 }
                 break;
+            case "meter": {
+                if (!METER_KINDS.has(r.kind))
+                    bad(r, "has an unknown kind");
+                if (!isAmount(r.tokens) || !isAmount(r.cost_usd))
+                    bad(r, "has invalid amounts");
+                if (!isName(r.call) || meterCalls.has(r.call))
+                    bad(r, "has no call id, or one already used");
+                meterCalls.add(r.call);
+                if (r.kind !== "route") {
+                    inVisit(r);
+                    break;
+                }
+                if (!cur || !cur.ended || cur.routed)
+                    bad(r, "meters a route call outside a finished, unrouted visit");
+                if (r.node !== cur.node || r.iteration !== cur.iteration) {
+                    bad(r, `names ${String(r.node)}#${String(r.iteration)}, but the visit being routed is ${cur.node}#${cur.iteration}`);
+                }
+                break;
+            }
             case "agent:unsandboxed":
                 inVisit(r);
                 break;
@@ -1102,10 +1132,18 @@ export function checkJournalAgainstWorkflow(records, workflow) {
  */
 function journaledSpend(records) {
     const perAttempt = new Map();
+    const metered = new Map();
     let segment = 1;
     for (const r of records) {
         if (r.type === "run:resume")
             segment++;
+        if (r.type === "meter") {
+            // One record per completion, each counted once (call ids are unique).
+            const kind = r.kind;
+            const prev = metered.get(kind) ?? { tokens: 0, costUsd: 0 };
+            metered.set(kind, { tokens: prev.tokens + r.tokens, costUsd: prev.costUsd + r.cost_usd });
+            continue;
+        }
         if (r.type !== "usage")
             continue;
         const k = `${segment}|${visitKey(r.node, r.iteration)}|${String(r.attempt)}`;
@@ -1115,12 +1153,50 @@ function journaledSpend(records) {
             costUsd: Math.max(prev.costUsd, r.cost_usd),
         });
     }
-    const total = { tokens: 0, costUsd: 0 };
+    const node = { tokens: 0, costUsd: 0 };
     for (const s of perAttempt.values()) {
-        total.tokens += s.tokens;
-        total.costUsd += s.costUsd;
+        node.tokens += s.tokens;
+        node.costUsd += s.costUsd;
+    }
+    if (metered.size === 0)
+        return node;
+    const byKind = { node: { ...node } };
+    const total = { ...node };
+    for (const [k, v] of metered) {
+        byKind[k] = v;
+        total.tokens += v.tokens;
+        total.costUsd += v.costUsd;
+    }
+    return { ...total, byKind };
+}
+/** Per visit: the largest usage of each agent attempt (per segment) plus its own judge, reflect and screen meters. */
+function visitSpendOf(records) {
+    const attempts = new Map();
+    const out = new Map();
+    const add = (visit, s) => {
+        const prev = out.get(visit) ?? { tokens: 0, costUsd: 0 };
+        out.set(visit, { tokens: prev.tokens + s.tokens, costUsd: prev.costUsd + s.costUsd });
+    };
+    let segment = 1;
+    for (const r of records) {
+        if (r.type === "run:resume")
+            segment++;
+        const visit = visitKey(r.node, r.iteration);
+        if (r.type === "meter" && r.kind !== "route") {
+            add(visit, { tokens: r.tokens, costUsd: r.cost_usd });
+        }
+        else if (r.type === "usage") {
+            const k = `${segment}|${visit}|${String(r.attempt)}`;
+            const prev = attempts.get(k)?.s ?? { tokens: 0, costUsd: 0 };
+            attempts.set(k, {
+                visit,
+                s: { tokens: Math.max(prev.tokens, r.tokens), costUsd: Math.max(prev.costUsd, r.cost_usd) },
+            });
+        }
     }
-    return total;
+    for (const { visit, s } of attempts.values())
+        add(visit, s);
+    return out;
 }
 /** Work out what a resume replays and where it picks up. Throws {@link JournalIntegrityError} for an impossible sequence. */
 export function buildResumePlan(records) {
@@ -1268,6 +1344,7 @@ export function buildResumePlan(records) {
         receipts,
         refusals,
         priorSpend: journaledSpend(records),
+        visitSpend: visitSpendOf(records),
         unsandboxed: [...new Set(records.filter((r) => r.type === "agent:unsandboxed").map((r) => String(r.node)))],
         ...(start.decider
             ? { decider: { ...start.decider, ...(deciderCounters ? { counters: { ...deciderCounters } } : {}) } }
@@ -1394,13 +1471,19 @@ async function probeProvider(toolName, args, key, skill, ctx, since) {
                 return { state: "applied", output: toolName === "github_create_issue" ? hit : {} };
             }
             case "linear_create_issue": {
-                const out = (await callRead(skill, "linear_search_issues", { query: token, limit: 5 }, ctx));
+                const out = (await callRead(skill, "linear_search_issues", { query: token, limit: 5, withDescription: true }, ctx));
                 const nodes = out?.searchIssues?.nodes;
                 if (!Array.isArray(nodes))
                     return { state: "unknown", reason: "search returned no result list" };
-                return nodes.length > 0
-                    ? { state: "applied", output: { issueCreate: { issue: nodes[0] } } }
-                    : { state: "absent" };
+                // Search is fuzzy: only an issue whose description carries this write's marker is ours.
+                const hit = nodes.find((n) => typeof n?.description === "string" && n.description.includes(token));
+                if (hit)
+                    return { state: "applied", output: { issueCreate: { issue: hit } } };
+                // A hit without a description cannot be checked for the marker: unknown, never assumed either way.
+                if (nodes.some((n) => typeof n?.description !== "string")) {
+                    return { state: "unknown", reason: "search hits carry no description to check for the marker" };
+                }
+                return { state: "absent" };
             }
             case "linear_add_comment": {
                 const out = (await callRead(skill, "linear_list_comments", { issueId: args.issueId }, ctx));
@@ -1791,6 +1874,7 @@ export class RunJournal {
                 intents: structuredClone(cp.intents),
                 agentRunFailed: cp.agent_failed,
                 attempt: cp.attempt,
+                ...(plan.visitSpend.has(k) ? { spent: { ...plan.visitSpend.get(k) } } : {}),
             };
         }
         return undefined;
@@ -1845,6 +1929,20 @@ export class RunJournal {
         });
         this.append("usage", { node, iteration, attempt, tokens, cost_usd: costUsd, final });
     }
+    /** Journal one metered completion, synchronously, before the executor acts on it. */
+    meter(kind, node, iteration, usage) {
+        const s = spendOf(usage);
+        if (s.tokens === undefined && s.costUsd === undefined)
+            return;
+        this.append("meter", {
+            kind,
+            call: crypto.randomUUID(),
+            node,
+            iteration,
+            tokens: s.tokens ?? 0,
+            cost_usd: s.costUsd ?? 0,
+        });
+    }
     uncontained(node, iteration) {
         const k = visitKey(node, iteration);
         if (this.uncontainedVisits.has(k))
@@ -1862,7 +1960,16 @@ export class RunJournal {
         ];
     }
     priorSpend() {
-        return this.resume ? { ...this.resume.plan.priorSpend } : undefined;
+        if (!this.resume)
+            return undefined;
+        const p = this.resume.plan.priorSpend;
+        return {
+            tokens: p.tokens,
+            costUsd: p.costUsd,
+            ...(p.byKind
+                ? { byKind: Object.fromEntries(Object.entries(p.byKind).map(([k, v]) => [k, { ...v }])) }
+                : {}),
+        };
     }
     /** Close the run: `run:end` (when the journal still works), then release the lock. Never throws. */
     end(status) {
@@ -1888,12 +1995,56 @@ export class RunJournal {
         }
         return out;
     }
+    visitSpent(node, iteration) {
+        const s = this.resume?.plan.visitSpend.get(visitKey(node, iteration));
+        return s ? { ...s } : undefined;
+    }
+    /** Outputs of writes {@link reconcile} found on the provider, replayed by the write handler. */
+    recoveredOutputs = new Map();
+    /** Provider probes already made for a write key: the handler reuses reconcile's, never probes twice. */
+    probes = new Map();
+    async reconcile(node, iteration, skill, tool, args, ctx) {
+        const plan = this.resume?.plan;
+        if (!plan)
+            return "absent";
+        const key = canonicalHash({ node, iteration, tool, args });
+        if (plan.receipts.has(key) || this.recoveredOutputs.has(key))
+            return "applied";
+        const refusal = plan.refusals.get(key);
+        if (refusal && refusal.retry !== true)
+            return "absent";
+        const pending = plan.intents.has(key);
+        if (!pending && !plan.checkpoints.has(visitKey(node, iteration)))
+            return "absent";
+        const probe = await this.probe(key, tool, args, skill, ctx);
+        if (probe.state === "applied") {
+            const output = slimOutput(probe.output);
+            this.append("output:applied", { node, iteration, key, tool, output, recovered: true });
+            this.recoveredOutputs.set(key, output);
+            this.logger.info(`  run journal: ${tool} found on the provider; not re-sent`, { node });
+            return "applied";
+        }
+        return probe.state === "unknown" && pending && !this.resume?.allowRepeatWrites ? "unknown" : "absent";
+    }
+    probe(key, tool, args, skill, ctx) {
+        const cached = this.probes.get(key);
+        if (cached)
+            return cached;
+        // Look back from a little before the intent (clock skew between this host and the provider).
+        const intentAt = Date.parse(String(this.resume?.plan.intents.get(key)?.at ?? ""));
+        const since = Number.isFinite(intentAt) ? new Date(intentAt - 5 * 60_000).toISOString() : undefined;
+        const p = probeProvider(tool, (args ?? {}), key, skill, ctx, since);
+        this.probes.set(key, p);
+        return p;
+    }
     wrapTool(node, iteration, skill, tool) {
         return {
             ...tool,
             handler: async (args, ctx) => {
                 const key = canonicalHash({ node, iteration, tool: tool.name, args });
                 const plan = this.resume?.plan;
+                if (this.recoveredOutputs.has(key))
+                    return this.recoveredOutputs.get(key) ?? null;
                 const receipt = plan?.receipts.get(key);
                 if (receipt) {
                     this.logger.info(`  run journal: ${tool.name} already applied before the crash; not re-sent`, { node });
@@ -1908,10 +2059,7 @@ export class RunJournal {
                 const replayingStage = !!plan?.checkpoints.has(visitKey(node, iteration));
                 const pending = plan?.intents.has(key) === true;
                 if (pending || replayingStage) {
-                    // Look back from a little before the intent (clock skew between this host and the provider).
-                    const intentAt = Date.parse(String(plan?.intents.get(key)?.at ?? ""));
-                    const since = Number.isFinite(intentAt) ? new Date(intentAt - 5 * 60_000).toISOString() : undefined;
-                    const probe = await probeProvider(tool.name, (args ?? {}), key, skill, ctx, since);
+                    const probe = await this.probe(key, tool.name, args, skill, ctx);
                     if (probe.state === "applied") {
                         const output = slimOutput(probe.output);
                         this.append("output:applied", { node, iteration, key, tool: tool.name, output, recovered: true });