tines 0.0.214 → 0.0.215

package/dist/index.js

@@ -3407,8 +3407,8 @@ var STATE_CATEGORIES = [
   "awaiting_human",
   "done"
 ];
-function runRefLabel(run2) {
-  return run2.issue_ref ? `run on ${run2.issue_ref.project_name}/${run2.issue_ref.number}` : `run ${run2.run_id}`;
+function runRefLabel(run3) {
+  return run3.issue_ref ? `run on ${run3.issue_ref.project_name}/${run3.issue_ref.number}` : `run ${run3.run_id}`;
 }
 function actorLabel(actor) {
   if (actor.run) {
@@ -3531,13 +3531,13 @@ function ageLabel(at, now = Date.now()) {
 function prUrlOf(v) {
   return v.pr_repo_url && v.pr_number !== null ? `${v.pr_repo_url}/pull/${v.pr_number}` : null;
 }
-function runDurationLabel(run2, now = Date.now()) {
-  if (!run2.started_at) return "\u2014";
-  const seconds = Math.max(0, Math.round(((run2.ended_at ?? now) - run2.started_at) / 1e3));
+function runDurationLabel(run3, now = Date.now()) {
+  if (!run3.started_at) return "\u2014";
+  const seconds = Math.max(0, Math.round(((run3.ended_at ?? now) - run3.started_at) / 1e3));
   return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m`;
 }
-function runCostLabel(run2) {
-  const usage2 = run2.usage;
+function runCostLabel(run3) {
+  const usage2 = run3.usage;
   if (!usage2) return null;
   if (usage2.cost_usd !== void 0) {
     const dollars = usage2.cost_usd === 0 ? "$0" : usage2.cost_usd < 0.01 ? "<$0.01" : `$${usage2.cost_usd.toFixed(2)}`;
@@ -3560,13 +3560,13 @@ function utilizationLabel(quota, activeRuns, stateName = (id2) => id2) {
     return `${activeRuns.length}/${quota.limit} global slot${quota.limit === 1 ? "" : "s"} in use`;
   }
   const counts = /* @__PURE__ */ new Map();
-  for (const run2 of activeRuns) {
-    const entry = counts.get(run2.state_id_at_start) ?? {
-      name: run2.state_at_start_name ?? stateName(run2.state_id_at_start),
+  for (const run3 of activeRuns) {
+    const entry = counts.get(run3.state_id_at_start) ?? {
+      name: run3.state_at_start_name ?? stateName(run3.state_id_at_start),
       n: 0
     };
     entry.n += 1;
-    counts.set(run2.state_id_at_start, entry);
+    counts.set(run3.state_id_at_start, entry);
   }
   for (const stateId of Object.keys(quota.overrides)) {
     if (!counts.has(stateId)) counts.set(stateId, { name: stateName(stateId), n: 0 });
@@ -4799,7 +4799,7 @@ var schedule = shape({
 });
 function validateLibraryV3Shape(value) {
   const envelope = { format: oneOf(["tines.library"]), version: oneOf([3]), exported_at: integer };
-  const digest = (v, p) => {
+  const digest2 = (v, p) => {
     text2(71)(v, p);
     if (v !== "" && !/^sha256:[0-9a-f]{64}$/.test(v))
       invalid(p, "invalid_digest", "Expected sha256 and 64 lowercase hex digits");
@@ -4839,7 +4839,7 @@ function validateLibraryV3Shape(value) {
           })
         )
       },
-      { digest }
+      { digest: digest2 }
     ),
     library: shape(
       {
@@ -4865,7 +4865,7 @@ function validateLibraryV3Shape(value) {
         ),
         labels: array(shape({ id, name: labelName, color: oneOf(LABEL_COLORS) }))
       },
-      { digest }
+      { digest: digest2 }
     )
   })(value, "");
 }
@@ -5504,6 +5504,14 @@ function usageCostLabel(cost, finalized = 1) {
   });
 }
 
+// ../shared/src/effort.ts
+var EFFORT_CAPABILITIES_MAX_BYTES = 64 * 1024;
+function supportedEfforts(capabilities, model) {
+  if (!capabilities || capabilities.version !== 1 || !("models" in capabilities) || !model)
+    return null;
+  return capabilities.models.find((entry) => entry.model === model)?.efforts ?? null;
+}
+
 // src/format.ts
 function timestamp(ms) {
   return new Date(ms).toISOString().replace("T", " ").slice(0, 19);
@@ -5618,10 +5626,10 @@ function runnerStatusLabel(runner) {
 function ruleTargetsLabel(rule) {
   if (rule.targets.length === 0) return "(no targets)";
   if (rule.targets.length === 1 && rule.targets[0]?.runner_id === "*") {
-    return `*:${rule.targets[0].tier} (inherited runners)`;
+    return `1. *:${rule.targets[0].tier}${rule.targets[0].effort ? ` effort=${rule.targets[0].effort}` : ""} (inherited runners)`;
   }
   return rule.targets.map(
-    (t) => `${t.runner_name}${t.tier ? `:${t.tier}` : ""}${t.runner_status === "paused" ? " (paused)" : ""}`
+    (t, index) => `${index + 1}. ${t.runner_name}${t.tier ? `:${t.tier}` : ""}${t.effort ? ` effort=${t.effort}` : ""}${t.runner_status === "paused" ? " (paused)" : ""}`
   ).join(" \u2192 ");
 }
 function quotaLabel(quota, stateName) {
@@ -5667,7 +5675,7 @@ function roundLines(round, now = Date.now()) {
     if (latest.artifacts.length > 0) {
       lines2.push(`    ${latest.artifacts.map(artifactChangeLabel).join(" \xB7 ")}`);
     }
-    for (const run2 of earlier) lines2.push(`    ${earlierAttemptLine(run2, now)}`);
+    for (const run3 of earlier) lines2.push(`    ${earlierAttemptLine(run3, now)}`);
     if (latest.summary_comment) {
       lines2.push(`    summary (${latest.summary_comment.id}):`);
       for (const line of latest.summary_comment.body.split("\n")) lines2.push(`      ${line}`);
@@ -5681,20 +5689,20 @@ function roundLines(round, now = Date.now()) {
   }
   return lines2;
 }
-function runHeadline(run2, now) {
-  const cost = runCostLabel(run2);
+function runHeadline(run3, now) {
+  const cost = runCostLabel(run3);
   return [
-    `${run2.run_id} on ${run2.runner_name}`,
-    runDurationLabel(run2, now),
-    run2.outcome ?? run2.status,
+    `${run3.run_id} on ${run3.runner_name}`,
+    runDurationLabel(run3, now),
+    run3.outcome ?? run3.status,
     ...cost ? [cost] : [],
-    run2.transition ? `"${run2.transition.action ?? "moved directly"}" \u2192 ${run2.transition.to_state.name}` : "no transition"
+    run3.transition ? `"${run3.transition.action ?? "moved directly"}" \u2192 ${run3.transition.to_state.name}` : "no transition"
   ].join(" \xB7 ");
 }
-function earlierAttemptLine(run2, now) {
-  const back = run2.returned_via;
+function earlierAttemptLine(run3, now) {
+  const back = run3.returned_via;
   const how = back ? back.action ? `sent back by ${back.from_state.name} ("${back.action}")` : "moved directly back" : "never came back";
-  return `${run2.run_id} \xB7 ${runDurationLabel(run2, now)} \xB7 ${run2.outcome ?? run2.status} \xB7 ${how}`;
+  return `${run3.run_id} \xB7 ${runDurationLabel(run3, now)} \xB7 ${run3.outcome ?? run3.status} \xB7 ${how}`;
 }
 function artifactChangeLabel(a) {
   const versions = a.from_version === null ? `v${a.to_version}` : `v${a.from_version} \u2192 v${a.to_version}`;
@@ -5713,16 +5721,16 @@ function roundSummaryLabel(summary) {
   ];
   return parts.length > 0 ? parts.join(" \xB7 ") : "\u2014";
 }
-function runRow(run2) {
+function runRow(run3) {
   return [
-    run2.id,
-    run2.issue_ref ? issueRef(run2.issue_ref) : run2.issue_id,
-    run2.runner_name,
-    `${run2.tier}${run2.model ? ` (${run2.model})` : ""}`,
-    `${run2.status}${run2.resumed_from_run_id ? ` \xB7 resumed run ${run2.resumed_from_run_id}` : ""}`,
-    runDurationLabel(run2),
-    runCostLabel(run2) ?? "\u2014",
-    timestamp(run2.created_at)
+    run3.id,
+    run3.issue_ref ? issueRef(run3.issue_ref) : run3.issue_id,
+    run3.runner_name,
+    `${run3.tier}${run3.model ? ` (${run3.model})` : ""}${run3.resolved_effort ? ` \xB7 effort ${run3.resolved_effort} \xB7 ${run3.effort_application_status}` : ""}`,
+    `${run3.status}${run3.resumed_from_run_id ? ` \xB7 resumed run ${run3.resumed_from_run_id}` : ""}`,
+    runDurationLabel(run3),
+    runCostLabel(run3) ?? "\u2014",
+    timestamp(run3.created_at)
   ];
 }
 function byteSize(bytes2) {
@@ -8485,6 +8493,23 @@ function isBlank(starter) {
 }
 
 // src/commands/routing.ts
+function applyTargetEfforts(targets, specs) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    const match = /^(\d+)=(.+)$/.exec(spec);
+    if (!match) die(`invalid --effort ${JSON.stringify(spec)}; expected <target-number=value>`);
+    const index = Number(match[1]);
+    const value = match[2];
+    if (!Number.isSafeInteger(index) || index < 1 || index > targets.length)
+      die(`--effort target ${index} is out of range (1-${targets.length})`);
+    if (seen.has(index)) die(`--effort target ${index} is specified more than once`);
+    if (!/^[a-z][a-z0-9_-]{0,31}$/.test(value))
+      die(`invalid effort ${JSON.stringify(value)}; use a lowercase token of 1-32 characters`);
+    seen.add(index);
+    targets[index - 1] = { ...targets[index - 1], effort: value };
+  }
+  return targets;
+}
 async function resolveRoutingScope(api, opts) {
   const projectId = opts.project !== void 0 ? (await resolveProject(api, opts.project)).id : null;
   const stateId = opts.state !== void 0 ? (await resolveStateFlag(api, opts.state)).state.id : null;
@@ -8513,7 +8538,12 @@ function register7(program3) {
   withCommon(
     routing.command("set <target...>").description(
       "Create or replace a rule with <runner>[:tier] targets, or scoped '*:smartest' tier inheritance"
-    ).option("-p, --project <name>", "scope: project name or id").option("-s, --state <workflow/state>", "scope: workflow-qualified state").option("-l, --label <name>", "scope: issue label name or id")
+    ).option("-p, --project <name>", "scope: project name or id").option("-s, --state <workflow/state>", "scope: workflow-qualified state").option("-l, --label <name>", "scope: issue label name or id").option(
+      "--effort <target-number=value>",
+      "set routed effort for a 1-based target (repeatable)",
+      (value, values) => [...values, value],
+      []
+    )
   ).action(async (targetSpecs, opts) => {
     const parsed = targetSpecs.map(parseTargetSpec);
     const wildcard = parsed.filter((target) => target.name === INHERIT_RUNNER_ID);
@@ -8525,15 +8555,20 @@ function register7(program3) {
         die("a tier-only rule requires --project, --state, or --label");
       }
     }
+    applyTargetEfforts(parsed, opts.effort ?? []);
     const api = client(opts);
     const scope = await resolveRoutingScope(api, opts);
     const targets = [];
-    for (const { name: name2, tier } of parsed) {
+    for (const { name: name2, tier, effort } of parsed) {
       if (name2 === INHERIT_RUNNER_ID) {
-        targets.push({ runner_id: INHERIT_RUNNER_ID, tier });
+        targets.push({ runner_id: INHERIT_RUNNER_ID, tier, ...effort ? { effort } : {} });
       } else {
         const runner = await resolveRunner(api, name2);
-        targets.push(tier ? { runner_id: runner.id, tier } : { runner_id: runner.id });
+        targets.push({
+          runner_id: runner.id,
+          ...tier ? { tier } : {},
+          ...effort ? { effort } : {}
+        });
       }
     }
     const { items } = await api.listRoutingRules();
@@ -8568,7 +8603,7 @@ function register7(program3) {
 }
 
 // src/daemon/daemon.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import {
   createWriteStream,
   existsSync as existsSync5,
@@ -9133,8 +9168,8 @@ async function readCodexRolloutRecords(stream, timeoutMs) {
       pending += decoder.write(chunk);
       let newline;
       while ((newline = pending.indexOf("\n")) >= 0) {
-        const failure = consume(pending.slice(0, newline));
-        if (failure) return failure;
+        const failure2 = consume(pending.slice(0, newline));
+        if (failure2) return failure2;
         pending = pending.slice(newline + 1);
       }
       if (Buffer.byteLength(pending) > CODEX_ROLLOUT_MAX_LINE_BYTES)
@@ -9142,8 +9177,8 @@ async function readCodexRolloutRecords(stream, timeoutMs) {
     }
     pending += decoder.end();
     if (pending.length) {
-      const failure = consume(pending);
-      if (failure) return failure;
+      const failure2 = consume(pending);
+      if (failure2) return failure2;
     }
     return { records };
   } catch {
@@ -9392,8 +9427,213 @@ var RateLimitDetector = class {
   }
 };
 
+// src/daemon/effort-capabilities.ts
+import { createHash } from "node:crypto";
+import { execFile, spawn } from "node:child_process";
+var MAX_STDOUT = 1024 * 1024;
+var DEADLINE_MS = 5e3;
+var EFFORT_CAPABILITIES_TTL_MS = 10 * 6e4;
+var MIN_CLAUDE_EFFORT_VERSION = [2, 1, 258];
+function claudeEffortVersionSupported(version) {
+  const parsed = version.match(/(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
+  if (!parsed) return false;
+  for (let i = 0; i < MIN_CLAUDE_EFFORT_VERSION.length; i++) {
+    if (parsed[i] > MIN_CLAUDE_EFFORT_VERSION[i]) return true;
+    if (parsed[i] < MIN_CLAUDE_EFFORT_VERSION[i]) return false;
+  }
+  return true;
+}
+function assignmentEffortRejection(assignment, capabilities, harness) {
+  if (!assignment.effort) return null;
+  if (!capabilities || capabilities.version !== 1 || !("models" in capabilities))
+    return "effort assignment requires a compatible V1 daemon capability report";
+  if (capabilities.harness !== harness)
+    return `effort assignment requires ${capabilities.harness}, but this daemon runs ${harness}`;
+  if (capabilities.catalog_digest !== assignment.effort.capability_digest)
+    return "effort capability catalog changed after assignment delivery";
+  const allowed = supportedEfforts(capabilities, assignment.run.model);
+  if (!allowed?.includes(assignment.effort.value))
+    return `${assignment.run.model ?? "the assigned model"} does not support effort ${assignment.effort.value}`;
+  return null;
+}
+function digest(models) {
+  return createHash("sha256").update(JSON.stringify(models)).digest("hex");
+}
+function failure(harness, daemonVersion, reason) {
+  return {
+    version: 1,
+    daemon_version: daemonVersion.slice(0, 100),
+    harness,
+    harness_version: "unknown",
+    catalog_digest: digest([]),
+    models: [],
+    discovery_error: reason.slice(0, 200)
+  };
+}
+function run(file, args) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      file,
+      args,
+      { timeout: DEADLINE_MS, maxBuffer: MAX_STDOUT },
+      (error, stdout) => error ? reject(error) : resolve2(stdout)
+    );
+  });
+}
+var CLAUDE_MODELS = {
+  "claude-fable-5-1": ["low", "medium", "high", "xhigh", "max"],
+  "claude-fable-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-8": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-7": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-6": ["low", "medium", "high", "max"],
+  "claude-sonnet-4-6": ["low", "medium", "high", "max"]
+};
+async function discoverClaude(daemonVersion) {
+  try {
+    const [version, help] = await Promise.all([
+      run("claude", ["--version"]),
+      run("claude", ["--help"])
+    ]);
+    if (!help.includes("--effort"))
+      return failure("claude_code", daemonVersion, "installed Claude CLI has no --effort option");
+    if (!claudeEffortVersionSupported(version))
+      return failure(
+        "claude_code",
+        daemonVersion,
+        `installed Claude CLI ${version.trim()} predates verified --effort support 2.1.258`
+      );
+    const models = Object.entries(CLAUDE_MODELS).map(([model, efforts]) => ({ model, efforts }));
+    return {
+      version: 1,
+      daemon_version: daemonVersion,
+      harness: "claude_code",
+      harness_version: version.trim().slice(0, 100),
+      catalog_revision: "claude-effort-v1",
+      catalog_digest: digest(models),
+      models
+    };
+  } catch (error) {
+    return failure(
+      "claude_code",
+      daemonVersion,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function discoverCodex(daemonVersion) {
+  let harnessVersion;
+  try {
+    harnessVersion = (await run("codex", ["--version"])).trim().slice(0, 100);
+  } catch (error) {
+    return failure("codex", daemonVersion, error instanceof Error ? error.message : String(error));
+  }
+  return new Promise((resolve2) => {
+    const child = spawn("codex", ["app-server"], { stdio: ["pipe", "pipe", "ignore"] });
+    let buffer = "";
+    let bytes2 = 0;
+    let settled = false;
+    let requestId = 2;
+    const models = [];
+    const finish = (report) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      resolve2(report);
+    };
+    const fail = (reason) => finish(failure("codex", daemonVersion, reason));
+    const sendList = (cursor) => {
+      requestId += 1;
+      child.stdin.write(
+        `${JSON.stringify({ id: requestId, method: "model/list", params: { includeHidden: true, ...cursor ? { cursor } : {} } })}
+`
+      );
+    };
+    const timer = setTimeout(() => fail("Codex model discovery timed out"), DEADLINE_MS);
+    child.on("error", (error) => fail(error.message));
+    child.stdout.on("data", (chunk) => {
+      bytes2 += chunk.length;
+      if (bytes2 > MAX_STDOUT) return fail("Codex model discovery exceeded 1 MiB");
+      buffer += chunk.toString("utf8");
+      for (; ; ) {
+        const newline = buffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        let message3;
+        try {
+          message3 = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message3.id === 1 && message3.result) {
+          child.stdin.write(`${JSON.stringify({ method: "initialized", params: {} })}
+`);
+          sendList();
+        } else if (typeof message3.id === "number" && message3.id >= 3 && message3.result) {
+          for (const entry of message3.result.data ?? []) {
+            const efforts = (entry.supportedReasoningEfforts ?? []).map((item) => item.reasoningEffort).filter((item) => typeof item === "string");
+            if (typeof entry.model === "string" && efforts.length)
+              models.push({ model: entry.model, efforts: [...new Set(efforts)] });
+          }
+          if (message3.result.nextCursor) sendList(message3.result.nextCursor);
+          else
+            finish({
+              version: 1,
+              daemon_version: daemonVersion,
+              harness: "codex",
+              harness_version: harnessVersion,
+              catalog_digest: digest(models),
+              models
+            });
+        }
+      }
+    });
+    child.stdin.write(
+      `${JSON.stringify({ id: 1, method: "initialize", params: { clientInfo: { name: "tines", version: daemonVersion } } })}
+`
+    );
+  });
+}
+async function discoverEffortCapabilities(harness, daemonVersion) {
+  if (harness === "custom") return void 0;
+  return harness === "codex" ? discoverCodex(daemonVersion) : discoverClaude(daemonVersion);
+}
+var EffortCapabilityRefresher = class {
+  constructor(harness, daemonVersion, discover = discoverEffortCapabilities, now = Date.now) {
+    this.harness = harness;
+    this.daemonVersion = daemonVersion;
+    this.discover = discover;
+    this.now = now;
+  }
+  harness;
+  daemonVersion;
+  discover;
+  now;
+  value;
+  refreshedAt = 0;
+  pending = null;
+  async get(force = false) {
+    if (!force && this.refreshedAt && this.now() - this.refreshedAt < EFFORT_CAPABILITIES_TTL_MS)
+      return this.value;
+    if (this.pending) return this.pending;
+    this.pending = this.discover(this.harness, this.daemonVersion).then((value) => {
+      this.value = value;
+      this.refreshedAt = this.now();
+      return value;
+    });
+    try {
+      return await this.pending;
+    } finally {
+      this.pending = null;
+    }
+  }
+};
+
 // src/daemon/cli-refresh.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
 
@@ -9417,7 +9657,7 @@ function buildHarnessInvocation(spec, input2) {
         file: "sh",
         args: [
           "-c",
-          `claude -p${input2.resumeSessionId ? ` --resume ${shellQuote(input2.resumeSessionId)}` : ""} --output-format stream-json --verbose${input2.model ? ` --model ${shellQuote(input2.model)}` : ""} < ${shellQuote(input2.promptFile)}`
+          `claude -p${input2.resumeSessionId ? ` --resume ${shellQuote(input2.resumeSessionId)}` : ""} --output-format stream-json --verbose${input2.model ? ` --model ${shellQuote(input2.model)}` : ""}${input2.effort ? ` --effort ${shellQuote(input2.effort)}` : ""} < ${shellQuote(input2.promptFile)}`
         ]
       };
     case "codex":
@@ -9428,6 +9668,7 @@ function buildHarnessInvocation(spec, input2) {
           "--json",
           "--skip-git-repo-check",
           ...input2.model ? ["--model", input2.model] : [],
+          ...input2.effort ? ["-c", `model_reasoning_effort=${JSON.stringify(input2.effort)}`] : [],
           input2.prompt
         ]
       };
@@ -9453,6 +9694,7 @@ function formatLaunchBanner(invocation, input2, meta) {
   const fields = [
     `harness=${meta.harness}`,
     `model=${input2.model ?? "(fixed)"}`,
+    `effort=${input2.effort ?? "(provider-default)"}`,
     `timeout=${meta.timeoutMinutes}m`,
     `cli=${meta.cliVersion}`,
     `workspace=${input2.workspace}`,
@@ -9477,9 +9719,9 @@ function formatExitLine(exit) {
   return `# tines runner: exit ${parts.join(" ")} after ${formatDuration(exit.durationMs)}
 `;
 }
-function exitLineForRun(run2, exit) {
-  if (run2.settled) return null;
-  return formatExitLine({ ...exit, timedOut: run2.timedOut });
+function exitLineForRun(run3, exit) {
+  if (run3.settled) return null;
+  return formatExitLine({ ...exit, timedOut: run3.timedOut });
 }
 var RunTable = class {
   constructor(effects, opts = {}) {
@@ -9502,8 +9744,8 @@ var RunTable = class {
   has(runId) {
     return this.runs.has(runId);
   }
-  track(run2) {
-    this.runs.set(run2.runId, run2);
+  track(run3) {
+    this.runs.set(run3.runId, run3);
     this.effects.persist();
   }
   /** Call after setting a run's pid so the state file reflects it. */
@@ -9519,10 +9761,10 @@ var RunTable = class {
    * already-settled run, a daemon shutdown. Guessing `failed` also errs the
    * safe way — it keeps a directory rather than destroying evidence.
    */
-  cleanup(run2, outcome = "failed") {
-    this.runs.delete(run2.runId);
+  cleanup(run3, outcome = "failed") {
+    this.runs.delete(run3.runId);
     this.effects.persist();
-    this.effects.release(run2, { keep: this.keep(outcome, run2), outcome });
+    this.effects.release(run3, { keep: this.keep(outcome, run3), outcome });
   }
   /**
    * Ends a run: flush logs, finish-report, clean up. On a run someone
@@ -9538,26 +9780,26 @@ var RunTable = class {
    * `{ judgment: 'rate_limited' }` with its reset time, while transient 5xx
    * and transport outages use `interrupted` and the normal short backoff.
    */
-  async finishAndCleanup(run2, status, error, judgment) {
-    if (run2.settled) return this.cleanup(run2);
-    run2.settled = true;
-    run2.endNote ??= error;
-    run2.drain?.();
-    if (this.keep(status, run2)) this.effects.noteKept?.(run2);
-    await run2.flush?.();
-    const keptBeforeFinish = this.keep(status, run2);
+  async finishAndCleanup(run3, status, error, judgment) {
+    if (run3.settled) return this.cleanup(run3);
+    run3.settled = true;
+    run3.endNote ??= error;
+    run3.drain?.();
+    if (this.keep(status, run3)) this.effects.noteKept?.(run3);
+    await run3.flush?.();
+    const keptBeforeFinish = this.keep(status, run3);
     try {
-      await this.effects.finish(run2, status, error, judgment);
-      this.effects.log(`run ${run2.runId} finished: ${status}${error ? ` (${error})` : ""}`);
-      if (!keptBeforeFinish && this.keep(status, run2)) {
-        this.effects.log(`run ${run2.runId} workspace kept for resume at ${run2.workspace}`);
+      await this.effects.finish(run3, status, error, judgment);
+      this.effects.log(`run ${run3.runId} finished: ${status}${error ? ` (${error})` : ""}`);
+      if (!keptBeforeFinish && this.keep(status, run3)) {
+        this.effects.log(`run ${run3.runId} workspace kept for resume at ${run3.workspace}`);
       }
     } catch (err) {
       this.effects.log(
-        `finish report for run ${run2.runId} not accepted: ${err instanceof Error ? err.message : String(err)}`
+        `finish report for run ${run3.runId} not accepted: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    this.cleanup(run2, status);
+    this.cleanup(run3, status);
   }
   /**
    * Marks a supervisor-settled run (`cancels`): kill, do NOT finish-report.
@@ -9566,11 +9808,11 @@ var RunTable = class {
    * is cleaned up by the launch path's next settled check.
    */
   markCanceled(runId) {
-    const run2 = this.runs.get(runId);
-    if (!run2 || run2.settled) return null;
-    run2.canceled = true;
-    run2.settled = true;
-    return run2;
+    const run3 = this.runs.get(runId);
+    if (!run3 || run3.settled) return null;
+    run3.canceled = true;
+    run3.settled = true;
+    return run3;
   }
 };
 var LogBatcher = class {
@@ -9746,7 +9988,7 @@ function runNpm(file, args, cwd, timeoutMs) {
     let output = "";
     let done = false;
     let timedOut = false;
-    const child = spawn(file, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn2(file, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     const timer = setTimeout(() => {
       if (done) return;
       timedOut = true;
@@ -9974,12 +10216,12 @@ function nextStepsMessage(name2, baseUrl) {
 // src/daemon/daemon.ts
 var CLI_REFRESH_TTL_MS = 10 * 6e4;
 var DAEMON_VERSION = cliVersion();
-async function uploadRawLog(run2) {
-  const path2 = run2.rawSpoolPath;
-  if (!path2 || !run2.rawUpload) return;
-  run2.rawSpoolPath = void 0;
+async function uploadRawLog(run3) {
+  const path2 = run3.rawSpoolPath;
+  if (!path2 || !run3.rawUpload) return;
+  run3.rawSpoolPath = void 0;
   try {
-    await new Promise((resolve2) => run2.rawSpool?.end(resolve2) ?? resolve2());
+    await new Promise((resolve2) => run3.rawSpool?.end(resolve2) ?? resolve2());
     const size = statSync4(path2).size;
     if (size > 0) {
       let body = readFileSync9(path2);
@@ -9993,7 +10235,7 @@ async function uploadRawLog(run2) {
           body.subarray(body.byteLength - RUN_LOG_RAW_MAX_BYTES + marker.byteLength)
         ]);
       }
-      await run2.rawUpload(body);
+      await run3.rawUpload(body);
     }
   } catch {
   } finally {
@@ -10104,8 +10346,8 @@ async function runDaemon(opts) {
   log(`agent CLI: ${cliLabel(await ensureCli())}`);
   const table2 = new RunTable(
     {
-      finish: async (run2, status, error, judgment) => {
-        const summary = run2.renderer?.summary();
+      finish: async (run3, status, error, judgment) => {
+        const summary = run3.renderer?.summary();
         if (summary?.pricingEvidence && opts.harness === "codex") {
           const raw = summary.pricingEvidence.raw_usage;
           const completeRaw = raw && [
@@ -10114,12 +10356,12 @@ async function runDaemon(opts) {
             "cache_write_input_tokens",
             "output_tokens"
           ].every((field) => raw[field] !== void 0);
-          if (status === "completed" && run2.pricingSessionMode === "cold" && summary.pricingEvidence.measurement_status === "complete" && completeRaw && summary.providerSessionId && run2.codexHome && run2.spawnedAt) {
+          if (status === "completed" && run3.pricingSessionMode === "cold" && summary.pricingEvidence.measurement_status === "complete" && completeRaw && summary.providerSessionId && run3.codexHome && run3.spawnedAt) {
             summary.pricingEvidence.request_context = await collectCodexRequestContext({
-              codexHome: run2.codexHome,
+              codexHome: run3.codexHome,
               threadId: summary.providerSessionId,
-              model: run2.pricingModel ?? null,
-              startedAt: run2.spawnedAt,
+              model: run3.pricingModel ?? null,
+              startedAt: run3.spawnedAt,
               endedAt: Date.now(),
               terminalUsage: raw
             });
@@ -10141,19 +10383,20 @@ async function runDaemon(opts) {
           daemon_version: DAEMON_VERSION,
           status
         };
-        run2.batcher.append(`[usage] ${JSON.stringify(accounting)}
+        run3.batcher.append(`[usage] ${JSON.stringify(accounting)}
 `);
-        await run2.batcher.flush();
-        const ended = await client2.finishRun(run2.runId, {
+        await run3.batcher.flush();
+        const ended = await client2.finishRun(run3.runId, {
           status,
+          ...run3.effortEvidence ? { effort_application: run3.effortEvidence } : {},
           ...error ? { error } : {},
           ...judgment,
           usage: accounting.usage,
           ...summary?.pricingEvidence ? {
             pricing_evidence: {
               ...summary.pricingEvidence,
-              model: run2.pricingModel ?? null,
-              session_mode: run2.pricingSessionMode ?? "cold",
+              model: run3.pricingModel ?? null,
+              session_mode: run3.pricingSessionMode ?? "cold",
               daemon_version: DAEMON_VERSION
             }
           } : {},
@@ -10161,33 +10404,33 @@ async function runDaemon(opts) {
           ...summary?.numTurns !== void 0 ? { turn_count: summary.numTurns } : {},
           // The whole conversation's turns, which for a resumed run is
           // more than this run's own: the size guard reads this one.
-          ...summary?.numTurns !== void 0 ? { conversation_turn_count: run2.priorTurns + summary.numTurns } : {},
-          workspace_path: run2.workspace
+          ...summary?.numTurns !== void 0 ? { conversation_turn_count: run3.priorTurns + summary.numTurns } : {},
+          workspace_path: run3.workspace
         });
-        if (ended?.resume_expires_at) run2.keepForResume = true;
+        if (ended?.resume_expires_at) run3.keepForResume = true;
       },
-      release: (run2, { keep, outcome }) => {
-        if (run2.timeout) clearTimeout(run2.timeout);
-        run2.renderer?.finish();
-        settleWorkspace(run2.workspace, keep, {
-          run_id: run2.runId,
-          ...run2.issueLabel ? { issue_ref: run2.issueLabel } : {},
+      release: (run3, { keep, outcome }) => {
+        if (run3.timeout) clearTimeout(run3.timeout);
+        run3.renderer?.finish();
+        settleWorkspace(run3.workspace, keep, {
+          run_id: run3.runId,
+          ...run3.issueLabel ? { issue_ref: run3.issueLabel } : {},
           status: outcome,
-          ...run2.endNote ? { error: run2.endNote } : {}
+          ...run3.endNote ? { error: run3.endNote } : {}
         });
-        void uploadRawLog(run2);
+        void uploadRawLog(run3);
         sweepKeptWorkspaces();
       },
-      noteKept: (run2) => run2.batcher.append(`workspace kept at ${run2.workspace}
+      noteKept: (run3) => run3.batcher.append(`workspace kept at ${run3.workspace}
 `),
       persist: () => {
-        const entries = table2.values().filter((run2) => run2.child?.pid !== void 0).map((run2) => ({
-          run_id: run2.runId,
-          pid: run2.child.pid,
-          workspace: run2.workspace,
-          key_fingerprint: run2.keyFingerprint,
-          started_at: run2.spawnedAt,
-          ...run2.issueLabel ? { issue_ref: run2.issueLabel } : {}
+        const entries = table2.values().filter((run3) => run3.child?.pid !== void 0).map((run3) => ({
+          run_id: run3.runId,
+          pid: run3.child.pid,
+          workspace: run3.workspace,
+          key_fingerprint: run3.keyFingerprint,
+          started_at: run3.spawnedAt,
+          ...run3.issueLabel ? { issue_ref: run3.issueLabel } : {}
         }));
         saveDaemonState(statePath, entries);
       },
@@ -10196,7 +10439,7 @@ async function runDaemon(opts) {
     {
       // A workspace the server retained for a resume is kept whatever the
       // --keep-workspaces mode says; pruning still bounds it by age/count.
-      keep: (outcome, run2) => run2.keepForResume || keepWorkspace(opts.keepWorkspaces, outcome)
+      keep: (outcome, run3) => run3.keepForResume || keepWorkspace(opts.keepWorkspaces, outcome)
     }
   );
   for (const orphan of loadDaemonState(statePath)) {
@@ -10230,16 +10473,18 @@ async function runDaemon(opts) {
   }
   saveDaemonState(statePath, []);
   const killWithoutFinish = (runId) => {
-    const run2 = table2.markCanceled(runId);
-    if (!run2) return;
-    run2.endNote ??= "canceled by supervisor";
+    const run3 = table2.markCanceled(runId);
+    if (!run3) return;
+    run3.endNote ??= "canceled by supervisor";
     log(`supervisor canceled run ${runId}; killing without finish-reporting`);
-    if (run2.child?.pid) {
-      const pid = run2.child.pid;
+    if (run3.child?.pid) {
+      const pid = run3.child.pid;
       killTree(pid, "SIGTERM");
       setTimeout(() => killTree(pid, "SIGKILL"), 5e3).unref?.();
     }
   };
+  const effortRefresher = new EffortCapabilityRefresher(opts.harness, DAEMON_VERSION);
+  let effortCapabilities = await effortRefresher.get();
   const launch = async (assignment) => {
     const runId = assignment.run.id;
     if (table2.has(runId)) return;
@@ -10251,7 +10496,7 @@ async function runDaemon(opts) {
     }
     const workspace = resume ? resume.workspace_path : join6(workspacesDir(opts.configDir), runId);
     const issueLabel = assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : void 0;
-    const run2 = {
+    const run3 = {
       runId,
       workspace,
       ...issueLabel ? { issueLabel } : {},
@@ -10267,8 +10512,23 @@ async function runDaemon(opts) {
         { onError: (err) => log(`log append for run ${runId} failed: ${message2(err)}`) }
       )
     };
-    run2.flush = () => run2.batcher.flush();
-    table2.track(run2);
+    run3.flush = () => run3.batcher.flush();
+    table2.track(run3);
+    if (assignment.effort) effortCapabilities = await effortRefresher.get(true);
+    const effortRejection = assignmentEffortRejection(assignment, effortCapabilities, opts.harness);
+    if (effortRejection && assignment.effort) {
+      run3.effortEvidence = {
+        status: "rejected",
+        attempted_effort: assignment.effort.value,
+        transport: "argv",
+        reason: effortRejection
+      };
+      await client2.appendRunLog(runId, {
+        chunk: "",
+        effort_application: run3.effortEvidence
+      }).catch(() => void 0);
+      return table2.finishAndCleanup(run3, "failed", effortRejection);
+    }
     log(
       resume ? `run ${runId} assigned (issue ${issueLabel ?? assignment.run.issue_id}); resuming run ${resume.previous_run_id} in ${workspace}` : `run ${runId} assigned (issue ${issueLabel ?? assignment.run.issue_id}); materializing workspace`
     );
@@ -10296,28 +10556,28 @@ async function runDaemon(opts) {
 `
         );
       for (const repo of resume ? [] : assignment.bundle.repos) {
-        if (run2.settled) return table2.cleanup(run2);
+        if (run3.settled) return table2.cleanup(run3);
         const args = [
           "clone",
           ...repo.branch ? ["--branch", repo.branch] : [],
           repo.url,
           repo.dir
         ];
-        run2.batcher.append(`$ git ${args.join(" ")}
+        run3.batcher.append(`$ git ${args.join(" ")}
 `);
-        const result = await runGit(args, workspace, run2.batcher);
+        const result = await runGit(args, workspace, run3.batcher);
         if (result !== 0) {
           return table2.finishAndCleanup(
-            run2,
+            run3,
             "failed",
             `git clone failed for ${repo.url} (exit ${result})`
           );
         }
       }
-      if (run2.settled) return table2.cleanup(run2);
+      if (run3.settled) return table2.cleanup(run3);
       const cli = await ensureCli();
-      if (run2.settled) return table2.cleanup(run2);
-      run2.batcher.append(
+      if (run3.settled) return table2.cleanup(run3);
+      run3.batcher.append(
         cli.source === "fresh" ? `tines CLI: ${cli.version ?? "unknown"} (daemon-managed)
 ` : cli.source === "stale" ? `warning: agent CLI refresh failed; using last-good tines ${cli.version ?? "unknown"} from ${opts.configDir}/cli
 ` : `warning: no daemon-managed tines CLI; using whatever \`tines\` is on this machine's PATH
@@ -10328,6 +10588,7 @@ async function runDaemon(opts) {
         promptFile: join6(workspace, "prompt.md"),
         prompt: assignment.prompt,
         model: assignment.run.model,
+        effort: assignment.effort?.value ?? null,
         ...resume ? { resumeSessionId: resume.provider_session_id } : {}
       };
       const invocation = buildHarnessInvocation(
@@ -10335,10 +10596,10 @@ async function runDaemon(opts) {
         harnessInput
       );
       if (opts.harness === "codex") {
-        run2.pricingModel = harnessInput.model;
-        run2.pricingSessionMode = resume ? "resumed" : "cold";
+        run3.pricingModel = harnessInput.model;
+        run3.pricingSessionMode = resume ? "resumed" : "cold";
       }
-      run2.batcher.append(
+      run3.batcher.append(
         formatLaunchBanner(invocation, harnessInput, {
           harness: opts.harness,
           timeoutMinutes: assignment.timeout_minutes,
@@ -10351,93 +10612,118 @@ async function runDaemon(opts) {
         apiKey: assignment.run_key,
         apiUrl: baseUrl
       });
-      if (opts.harness === "codex") run2.codexHome = resolveCodexHome(spawnEnv, workspace);
-      const child = spawn2(invocation.file, invocation.args, {
+      if (opts.harness === "codex") run3.codexHome = resolveCodexHome(spawnEnv, workspace);
+      const child = spawn3(invocation.file, invocation.args, {
         cwd: workspace,
         env: spawnEnv,
         stdio: ["ignore", "pipe", "pipe"],
         detached: true
       });
-      run2.child = child;
-      run2.spawnedAt = Date.now();
+      if (assignment.effort) {
+        child.once("spawn", () => {
+          run3.effortEvidence = {
+            status: "accepted_unconfirmed",
+            attempted_effort: assignment.effort.value,
+            transport: "argv"
+          };
+          void client2.appendRunLog(runId, {
+            chunk: "",
+            effort_application: run3.effortEvidence
+          }).catch((err) => log(`run ${runId}: effort evidence rejected: ${message2(err)}`));
+        });
+      }
+      run3.child = child;
+      run3.spawnedAt = Date.now();
       table2.persist();
       log(`run ${runId}: launched ${invocation.file} (pid ${child.pid})`);
       if (opts.harness === "claude_code") {
         const limiter = new RateLimitDetector();
-        run2.limiter = limiter;
+        run3.limiter = limiter;
         const renderer = new ClaudeStreamRenderer(
-          (line) => run2.batcher.append(line),
+          (line) => run3.batcher.append(line),
           (event) => limiter.noteStreamEvent(event)
         );
-        run2.renderer = renderer;
+        run3.renderer = renderer;
         const spoolPath = join6(opts.configDir, "rawlogs", `${runId}.ndjson`);
         mkdirSync4(dirname4(spoolPath), { recursive: true });
-        run2.rawSpoolPath = spoolPath;
-        run2.rawSpool = createWriteStream(spoolPath);
-        run2.rawUpload = (body) => client2.putRunLogRaw(runId, body);
+        run3.rawSpoolPath = spoolPath;
+        run3.rawSpool = createWriteStream(spoolPath);
+        run3.rawUpload = (body) => client2.putRunLogRaw(runId, body);
         const decoder = new StringDecoder2("utf8");
-        run2.drain = () => {
+        run3.drain = () => {
           const trailing = decoder.end();
           if (trailing) renderer.write(trailing);
           renderer.finish();
         };
         child.stdout?.on("data", (data) => {
-          run2.rawSpool?.write(data);
+          run3.rawSpool?.write(data);
           renderer.write(decoder.write(data));
         });
       } else if (opts.harness === "codex") {
-        const renderer = new CodexStreamRenderer((line) => run2.batcher.append(line));
+        const renderer = new CodexStreamRenderer((line) => run3.batcher.append(line));
         const decoder = new StringDecoder2("utf8");
-        run2.renderer = renderer;
-        run2.drain = () => {
+        run3.renderer = renderer;
+        run3.drain = () => {
           const trailing = decoder.end();
           if (trailing) renderer.write(trailing);
           renderer.finish();
         };
         child.stdout?.on("data", (data) => renderer.write(decoder.write(data)));
       } else {
-        child.stdout?.on("data", (data) => run2.batcher.append(data.toString("utf8")));
+        child.stdout?.on("data", (data) => run3.batcher.append(data.toString("utf8")));
       }
       child.stderr?.on("data", (data) => {
         const text4 = data.toString("utf8");
-        run2.batcher.append(text4);
-        run2.limiter?.noteStderr(text4);
+        run3.batcher.append(text4);
+        run3.limiter?.noteStderr(text4);
       });
-      run2.timeout = setTimeout(() => {
-        if (run2.settled) return;
+      run3.timeout = setTimeout(() => {
+        if (run3.settled) return;
         log(`run ${runId} hit its ${assignment.timeout_minutes}m timeout; killing`);
-        run2.timedOut = true;
+        run3.timedOut = true;
         if (child.pid) killTree(child.pid, "SIGTERM");
         if (child.pid) setTimeout(() => killTree(child.pid, "SIGKILL"), 5e3).unref?.();
       }, assignment.timeout_minutes * 6e4);
       child.on("error", (err) => {
-        void table2.finishAndCleanup(run2, "failed", `failed to launch harness: ${message2(err)}`);
+        const reason = `failed to launch harness: ${message2(err)}`;
+        if (assignment.effort)
+          run3.effortEvidence = {
+            status: "rejected",
+            attempted_effort: assignment.effort.value,
+            transport: "argv",
+            reason
+          };
+        const evidence = assignment.effort ? client2.appendRunLog(runId, {
+          chunk: "",
+          effort_application: run3.effortEvidence
+        }).catch(() => void 0) : Promise.resolve();
+        void evidence.then(() => table2.finishAndCleanup(run3, "failed", reason));
       });
       child.on("close", (code, signal) => {
-        run2.drain?.();
-        run2.limiter?.finish();
-        const closing = exitLineForRun(run2, {
+        run3.drain?.();
+        run3.limiter?.finish();
+        const closing = exitLineForRun(run3, {
           code,
           signal,
-          durationMs: Date.now() - (run2.spawnedAt ?? Date.now())
+          durationMs: Date.now() - (run3.spawnedAt ?? Date.now())
         });
-        if (closing) run2.batcher.append(closing);
-        if (run2.timedOut) {
+        if (closing) run3.batcher.append(closing);
+        if (run3.timedOut) {
           void table2.finishAndCleanup(
-            run2,
+            run3,
             "failed",
             `run exceeded the ${assignment.timeout_minutes}m timeout; harness killed`
           );
         } else if (code === 0) {
-          void table2.finishAndCleanup(run2, "completed");
+          void table2.finishAndCleanup(run3, "completed");
         } else {
-          const limited = signal ? null : run2.limiter?.signal() ?? null;
-          const providerError = signal ? null : run2.limiter?.providerError() ?? null;
+          const limited = signal ? null : run3.limiter?.signal() ?? null;
+          const providerError = signal ? null : run3.limiter?.providerError() ?? null;
           if (limited) {
             log(
               `run ${runId}: harness rate limited (${limited.detail}); reporting without a strike`
             );
-            void table2.finishAndCleanup(run2, "failed", `rate limited: ${limited.detail}`, {
+            void table2.finishAndCleanup(run3, "failed", `rate limited: ${limited.detail}`, {
               judgment: "rate_limited",
               ...limited.resumeAt !== null ? { resume_at: limited.resumeAt } : {}
             });
@@ -10445,12 +10731,12 @@ async function runDaemon(opts) {
             log(
               `run ${runId}: transient provider error (${providerError.detail}); reporting without a strike`
             );
-            void table2.finishAndCleanup(run2, "failed", `provider error: ${providerError.detail}`, {
+            void table2.finishAndCleanup(run3, "failed", `provider error: ${providerError.detail}`, {
               judgment: "interrupted"
             });
           } else {
             void table2.finishAndCleanup(
-              run2,
+              run3,
               "failed",
               signal ? `harness killed by ${signal}` : `harness exited with code ${code}`
             );
@@ -10458,7 +10744,7 @@ async function runDaemon(opts) {
         }
       });
     } catch (err) {
-      void table2.finishAndCleanup(run2, "failed", `workspace setup failed: ${message2(err)}`);
+      void table2.finishAndCleanup(run3, "failed", `workspace setup failed: ${message2(err)}`);
     }
   };
   const shutdown = async () => {
@@ -10466,9 +10752,9 @@ async function runDaemon(opts) {
     shuttingDown = true;
     log("shutting down; failing in-flight runs");
     await Promise.all(
-      table2.values().map(async (run2) => {
-        if (run2.child?.pid) killTree(run2.child.pid, "SIGTERM");
-        await table2.finishAndCleanup(run2, "failed", "daemon shut down", {
+      table2.values().map(async (run3) => {
+        if (run3.child?.pid) killTree(run3.child.pid, "SIGTERM");
+        await table2.finishAndCleanup(run3, "failed", "daemon shut down", {
           judgment: "interrupted"
         });
       })
@@ -10483,10 +10769,12 @@ async function runDaemon(opts) {
   let failures = 0;
   while (!shuttingDown) {
     try {
+      effortCapabilities = await effortRefresher.get();
       const res = await client2.pollRunner(creds.runner_id, {
         instance_id: instanceId,
         owned_runs: table2.ids(),
         max_concurrent: opts.maxConcurrent,
+        ...effortCapabilities ? { effort_capabilities: effortCapabilities } : {},
         // Stated on every poll while pending; absent otherwise, which
         // the server reads as "not draining" — so a daemon that died
         // mid-drain cannot pin its runner shut past its relaunch.
@@ -10519,11 +10807,11 @@ async function runDaemon(opts) {
         return;
       }
       if (err instanceof ApiError && err.status === 401) {
-        for (const run2 of table2.values()) {
-          if (run2.child?.pid) killTree(run2.child.pid, "SIGKILL");
-          settleWorkspace(run2.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
-            run_id: run2.runId,
-            ...run2.issueLabel ? { issue_ref: run2.issueLabel } : {},
+        for (const run3 of table2.values()) {
+          if (run3.child?.pid) killTree(run3.child.pid, "SIGKILL");
+          settleWorkspace(run3.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
+            run_id: run3.runId,
+            ...run3.issueLabel ? { issue_ref: run3.issueLabel } : {},
             status: "failed",
             error: "daemon token rejected"
           });
@@ -10557,7 +10845,7 @@ function realpathOrNull(path2) {
 }
 function runGit(args, cwd, batcher) {
   return new Promise((resolve2) => {
-    const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     child.stdout?.on("data", (data) => batcher.append(data.toString("utf8")));
     child.stderr?.on("data", (data) => batcher.append(data.toString("utf8")));
     child.on("error", () => resolve2(127));
@@ -10633,7 +10921,7 @@ function harnessFlag(harness) {
 }
 
 // src/commands/runner-service.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir3, hostname as hostname3, userInfo } from "node:os";
 import { dirname as dirname6 } from "node:path";
@@ -10832,7 +11120,7 @@ function managedBinaryPresent(prefix) {
 }
 
 // src/commands/runner-service.ts
-var run = promisify(execFile);
+var run2 = promisify(execFile2);
 var STARTUP_TIMEOUT_MS = 3e4;
 var log2 = (message3) => console.log(message3);
 function resolveServiceManager(flag) {
@@ -10852,7 +11140,7 @@ function resolveServiceManager(flag) {
 async function runServiceCommands(steps) {
   for (const step of steps) {
     try {
-      await run(step.argv[0], step.argv.slice(1), { timeout: 3e4 });
+      await run2(step.argv[0], step.argv.slice(1), { timeout: 3e4 });
     } catch (err) {
       if (step.optional) continue;
       const detail = err && typeof err === "object" && "stderr" in err && String(err.stderr).trim() ? `: ${String(err.stderr).trim()}` : err instanceof Error ? `: ${err.message}` : "";
@@ -10862,7 +11150,7 @@ async function runServiceCommands(steps) {
 }
 async function listProcesses() {
   try {
-    const { stdout } = await run("ps", ["-axo", "pid=,args="], { maxBuffer: 16 * 1024 * 1024 });
+    const { stdout } = await run2("ps", ["-axo", "pid=,args="], { maxBuffer: 16 * 1024 * 1024 });
     return stdout;
   } catch {
     return null;
@@ -11506,14 +11794,14 @@ function register8(program3) {
       if (evidence.population === "pending") {
         table([
           ["ID", "ISSUE", "RUNNER", "TIER", "STATUS", "COST", "CREATED"],
-          ...items.map((run2) => [
-            run2.id,
-            run2.issue_ref ? `${run2.issue_ref.project_name}/${run2.issue_ref.number}` : run2.issue_id,
-            run2.runner_name,
-            run2.tier,
+          ...items.map((run3) => [
+            run3.id,
+            run3.issue_ref ? `${run3.issue_ref.project_name}/${run3.issue_ref.number}` : run3.issue_id,
+            run3.runner_name,
+            run3.tier,
             "Pending at cutoff",
             "\u2014",
-            timestamp(run2.created_at)
+            timestamp(run3.created_at)
           ])
         ]);
         return;
@@ -11523,12 +11811,12 @@ function register8(program3) {
         ...items.map(runRow)
       ]);
       if (evidence.population === "finalized") {
-        for (const run2 of items)
-          if (run2.usage_dimensions && run2.usage_accounting)
+        for (const run3 of items)
+          if (run3.usage_dimensions && run3.usage_accounting)
             for (const line of usageEvidenceLines(
-              run2.id,
-              run2.usage_dimensions,
-              run2.usage_accounting
+              run3.id,
+              run3.usage_dimensions,
+              run3.usage_accounting
             ))
               console.log(line);
       }
@@ -11539,29 +11827,41 @@ function register8(program3) {
   ).action(
     async (id2, opts) => {
       const api = client(opts);
-      const run2 = await api.getRun(id2);
-      if (opts.json) return printJson(run2);
+      const run3 = await api.getRun(id2);
+      if (opts.json) return printJson(run3);
       console.log(
-        `${run2.id}  ${run2.status}  on ${run2.runner_name}${run2.resumed_from_run_id ? `  \xB7 resumed run ${run2.resumed_from_run_id}` : ""}`
+        `${run3.id}  ${run3.status}  on ${run3.runner_name}${run3.resumed_from_run_id ? `  \xB7 resumed run ${run3.resumed_from_run_id}` : ""}`
+      );
+      if (run3.issue_ref) console.log(`issue: ${issueRef(run3.issue_ref)} \u2014 ${run3.issue_ref.title}`);
+      console.log(`tier: ${run3.tier}  model: ${run3.model ?? "(n/a)"}`);
+      const effortSource = run3.effort_source;
+      const sourceLabel2 = effortSource?.kind === "routing_target" ? `routing target ${effortSource.target_index + 1} (${effortSource.scope_label})` : effortSource?.kind === "runner_tier" ? `runner tier ${effortSource.tier}` : effortSource?.kind === "none" ? "provider default" : "legacy record";
+      const evidence = run3.effort_application_evidence;
+      const observed = evidence?.milestones?.findLast(
+        (item) => item.observed_model !== void 0 || item.observed_effort !== void 0
       );
-      if (run2.issue_ref) console.log(`issue: ${issueRef(run2.issue_ref)} \u2014 ${run2.issue_ref.title}`);
-      console.log(`tier: ${run2.tier}  model: ${run2.model ?? "(n/a)"}`);
       console.log(
-        `states: ${run2.state_at_start_name ?? run2.state_id_at_start} \u2192 ${run2.state_at_end_name ?? run2.state_id_at_end ?? "\u2026"}`
+        `effort: requested ${run3.requested_effort ?? "(none)"}  resolved ${run3.resolved_effort ?? "(provider default)"}  source ${sourceLabel2}`
       );
       console.log(
-        `created: ${timestamp(run2.created_at)}  started: ${run2.started_at ? timestamp(run2.started_at) : "\u2014"}  ended: ${run2.ended_at ? timestamp(run2.ended_at) : "\u2014"}  duration: ${runDurationLabel(run2)}`
+        `effort application: ${(run3.effort_application_status ?? "unknown").replaceAll("_", " ")}${observed ? `  observed ${observed.observed_effort ?? "(unknown effort)"} on ${observed.observed_model ?? "(unknown model)"}` : "  observed unknown"}${observed?.reason ? `  (${observed.reason})` : ""}`
       );
-      if (run2.usage) {
-        const u = run2.usage;
-        const costLabel = runCostLabel(run2);
+      console.log(
+        `states: ${run3.state_at_start_name ?? run3.state_id_at_start} \u2192 ${run3.state_at_end_name ?? run3.state_id_at_end ?? "\u2026"}`
+      );
+      console.log(
+        `created: ${timestamp(run3.created_at)}  started: ${run3.started_at ? timestamp(run3.started_at) : "\u2014"}  ended: ${run3.ended_at ? timestamp(run3.ended_at) : "\u2014"}  duration: ${runDurationLabel(run3)}`
+      );
+      if (run3.usage) {
+        const u = run3.usage;
+        const costLabel = runCostLabel(run3);
         const metric = (value) => value === void 0 ? "unknown" : value.toLocaleString();
         console.log(
           `usage: input ${metric(u.input_tokens)}  cache-read ${metric(u.cache_read_tokens)}  cache-write ${metric(u.cache_write_tokens)}  output ${metric(u.output_tokens)}`
         );
         if (u.cost_usd !== void 0)
           console.log(
-            `cost: ${runCostLabel(run2)}${u.cost_source === void 0 ? " \xB7 source unavailable" : ""}`
+            `cost: ${runCostLabel(run3)}${u.cost_source === void 0 ? " \xB7 source unavailable" : ""}`
           );
         const pricing = u.pricing;
         if (pricing?.status === "provider_authoritative")
@@ -11596,9 +11896,9 @@ function register8(program3) {
           );
         }
       }
-      if (run2.provider_session_id) console.log(`provider session: ${run2.provider_session_id}`);
-      if (run2.provider_url) console.log(`provider console: ${run2.provider_url}`);
-      if (run2.error) console.log(`error: ${run2.error}`);
+      if (run3.provider_session_id) console.log(`provider session: ${run3.provider_session_id}`);
+      if (run3.provider_url) console.log(`provider console: ${run3.provider_url}`);
+      if (run3.error) console.log(`error: ${run3.error}`);
       if (opts.logs) {
         console.log("");
         if (opts.full || opts.raw) {
@@ -11615,12 +11915,12 @@ function register8(program3) {
           process.stdout.write(decoder.decode());
           return;
         }
-        if (run2.log_bytes_dropped > 0) {
+        if (run3.log_bytes_dropped > 0) {
           console.log(
-            `[${Math.round(run2.log_bytes_dropped / 1024)} KB truncated from the head \u2014 ` + (run2.log_expired ? "past its retention window; only this tail remains]" : `run \`tines runs show ${run2.id} --logs --full\` for the complete ${Math.round(run2.log_full_bytes / 1024)} KB log]`)
+            `[${Math.round(run3.log_bytes_dropped / 1024)} KB truncated from the head \u2014 ` + (run3.log_expired ? "past its retention window; only this tail remains]" : `run \`tines runs show ${run3.id} --logs --full\` for the complete ${Math.round(run3.log_full_bytes / 1024)} KB log]`)
           );
         }
-        console.log(run2.log || "(no log output captured)");
+        console.log(run3.log || "(no log output captured)");
       }
     }
   );
@@ -11628,10 +11928,10 @@ function register8(program3) {
     runsCmd.command("cancel <id>").description("Cancel a run (judged like any other end: usually a strike)")
   ).action(async (id2, opts) => {
     const api = client(opts);
-    const run2 = await api.cancelRun(id2);
-    if (opts.json) return printJson(run2);
+    const run3 = await api.cancelRun(id2);
+    if (opts.json) return printJson(run3);
     console.log(
-      `canceled ${run2.id}${run2.issue_ref ? ` on ${issueRef(run2.issue_ref)}` : ""} (was on ${run2.runner_name})`
+      `canceled ${run3.id}${run3.issue_ref ? ` on ${issueRef(run3.issue_ref)}` : ""} (was on ${run3.runner_name})`
     );
   });
 }
@@ -11858,6 +12158,8 @@ function queueHeadline(block) {
       return `${runner} backing off`;
     case "rate_limited":
       return `${runner} rate limited`;
+    case "effort_incompatible":
+      return `${runner} cannot apply the requested effort`;
     case "no_rule":
       return "no matching routing rule";
     case "no_targets":
@@ -11896,6 +12198,8 @@ function queueFix(block) {
       return "retries automatically; check the daemon log if it keeps failing";
     case "rate_limited":
       return "resumes automatically when the usage window resets; nothing to do";
+    case "effort_incompatible":
+      return `upgrade or reconnect ${runner}, or choose a model and effort it reports as supported`;
     default:
       return null;
   }
@@ -12115,7 +12419,7 @@ import { readFileSync as readFileSync12 } from "node:fs";
 
 // src/workflow-packages.ts
 import { createInterface as createInterface4 } from "node:readline/promises";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { readFileSync as readFileSync11 } from "node:fs";
 var PACKAGE_STDIN = "-";
 var MAX_LOCAL_JSON_BYTES = 32 * 1024 * 1024;
@@ -12282,7 +12586,7 @@ function expectedWorkflowPackageOperations(plan) {
 function assertPlanBinding(plan) {
   const payload = tokenPayload(plan.plan_token);
   const { plan_digest: signedDigest, ...unsigned } = payload;
-  const digest = `sha256:${createHash("sha256").update(canonicalizeLibraryValue({ plan: unsigned, resolved: plan.resolved })).digest("hex")}`;
+  const digest2 = `sha256:${createHash2("sha256").update(canonicalizeLibraryValue({ plan: unsigned, resolved: plan.resolved })).digest("hex")}`;
   const mirrors = {
     id: plan.plan_id,
     plan_digest: plan.plan_digest,
@@ -12299,7 +12603,7 @@ function assertPlanBinding(plan) {
     if (canonicalizeLibraryValue(payload[signedField]) !== canonicalizeLibraryValue(value))
       throw new Error(`saved workflow package plan has modified ${field}`);
   }
-  if (signedDigest !== digest || plan.plan_digest !== digest)
+  if (signedDigest !== digest2 || plan.plan_digest !== digest2)
     throw new Error("saved workflow package plan digest does not bind its review");
   if (canonicalizeLibraryValue(plan.operations) !== canonicalizeLibraryValue(expectedWorkflowPackageOperations(plan)))
     throw new Error("saved workflow package plan has modified operations");
@@ -12922,12 +13226,12 @@ function printEvidence(page) {
     table([
       ["RUN", "ISSUE", "SPEND", "AT"],
       ...page.items.map((item) => {
-        const run2 = item;
+        const run3 = item;
         return [
-          run2.id,
-          run2.issue_id,
-          page.population === "pending" ? "Pending" : money(run2.usage_accounting?.cost ?? null),
-          new Date(run2.ended_at ?? run2.created_at).toISOString()
+          run3.id,
+          run3.issue_id,
+          page.population === "pending" ? "Pending" : money(run3.usage_accounting?.cost ?? null),
+          new Date(run3.ended_at ?? run3.created_at).toISOString()
         ];
       })
     ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.214",
+  "version": "0.0.215",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",