@gobing-ai/spur 0.4.30 → 0.4.31

package/spur.js

@@ -43367,6 +43367,56 @@ var require_extra_typings = __commonJS(function(exports, module) {
   exports.createArgument = (name, description) => new commander.Argument(name, description);
 });
 
+// ../../packages/domain/src/analytics/models.ts
+var init_models = () => {};
+
+// ../../packages/domain/src/analytics/costs.ts
+function cacheHitRatio(totals) {
+  if (totals.recordsWithUsage === 0)
+    return null;
+  if (totals.inputTokens === 0)
+    return null;
+  return totals.cacheReadTokens / totals.inputTokens;
+}
+function formatSummary(summary) {
+  const lines = [];
+  const totalCost = summary.totals.costUsd.toFixed(2);
+  const totalInput = (summary.totals.inputTokens / 1e6).toFixed(1);
+  const totalOutput = (summary.totals.outputTokens / 1e6).toFixed(1);
+  lines.push(`Total: ${totalInput}M input / ${totalOutput}M output tokens \xB7 $${totalCost} \xB7 ${summary.totals.records} records`);
+  lines.push(`Cache hit: ${formatRatio(cacheHitRatio(summary.totals))} of input tokens served from cache`);
+  lines.push("");
+  lines.push("By source:");
+  const sourceEntries = Object.entries(summary.bySource).sort(byCostDesc);
+  for (const entry of sourceEntries) {
+    const [source, stats] = entry;
+    lines.push(`  ${source.padEnd(12)} $${stats.costUsd.toFixed(2).padStart(8)}  ${(stats.inputTokens / 1e6).toFixed(1).padStart(6)}M in  ${(stats.outputTokens / 1e6).toFixed(1).padStart(6)}M out  ${String(stats.records).padStart(6)} rec`);
+  }
+  lines.push("");
+  lines.push("By model:");
+  const modelEntries = Object.entries(summary.byModel).sort(byCostDesc);
+  for (const entry of modelEntries) {
+    const [model, stats] = entry;
+    lines.push(`  ${model.slice(0, 28).padEnd(28)} $${stats.costUsd.toFixed(2).padStart(8)}  ${(stats.inputTokens / 1e6).toFixed(1).padStart(6)}M in  ${(stats.outputTokens / 1e6).toFixed(1).padStart(6)}M out  ${String(stats.records).padStart(6)} rec`);
+  }
+  return lines.join(`
+`);
+}
+function formatRatio(ratio) {
+  return ratio === null ? "n/a" : `${(ratio * 100).toFixed(1)}%`;
+}
+function byCostDesc([, a], [, b]) {
+  return b.costUsd - a.costUsd;
+}
+var init_costs = __esm(() => {
+  init_models();
+});
+
+// ../../packages/domain/src/analytics/antigravity-etl.ts
+var init_antigravity_etl = __esm(() => {
+  init_costs();
+});
+
 // ../../packages/domain/src/analytics/artifact.ts
 import { createHash } from "crypto";
 function selectorDigest(selector) {
@@ -43434,51 +43484,6 @@ var init_artifact_digest = __esm(() => {
   RANKED_ARTIFACT_KEYS = new Set(Object.entries(ARTIFACT_ARRAY_CLASSIFICATION).filter(([, kind]) => kind === "ranked").map(([key]) => key));
 });
 
-// ../../packages/domain/src/analytics/models.ts
-var init_models = () => {};
-
-// ../../packages/domain/src/analytics/costs.ts
-function cacheHitRatio(totals) {
-  if (totals.recordsWithUsage === 0)
-    return null;
-  if (totals.inputTokens === 0)
-    return null;
-  return totals.cacheReadTokens / totals.inputTokens;
-}
-function formatSummary(summary) {
-  const lines = [];
-  const totalCost = summary.totals.costUsd.toFixed(2);
-  const totalInput = (summary.totals.inputTokens / 1e6).toFixed(1);
-  const totalOutput = (summary.totals.outputTokens / 1e6).toFixed(1);
-  lines.push(`Total: ${totalInput}M input / ${totalOutput}M output tokens \xB7 $${totalCost} \xB7 ${summary.totals.records} records`);
-  lines.push(`Cache hit: ${formatRatio(cacheHitRatio(summary.totals))} of input tokens served from cache`);
-  lines.push("");
-  lines.push("By source:");
-  const sourceEntries = Object.entries(summary.bySource).sort(byCostDesc);
-  for (const entry of sourceEntries) {
-    const [source, stats] = entry;
-    lines.push(`  ${source.padEnd(12)} $${stats.costUsd.toFixed(2).padStart(8)}  ${(stats.inputTokens / 1e6).toFixed(1).padStart(6)}M in  ${(stats.outputTokens / 1e6).toFixed(1).padStart(6)}M out  ${String(stats.records).padStart(6)} rec`);
-  }
-  lines.push("");
-  lines.push("By model:");
-  const modelEntries = Object.entries(summary.byModel).sort(byCostDesc);
-  for (const entry of modelEntries) {
-    const [model, stats] = entry;
-    lines.push(`  ${model.slice(0, 28).padEnd(28)} $${stats.costUsd.toFixed(2).padStart(8)}  ${(stats.inputTokens / 1e6).toFixed(1).padStart(6)}M in  ${(stats.outputTokens / 1e6).toFixed(1).padStart(6)}M out  ${String(stats.records).padStart(6)} rec`);
-  }
-  return lines.join(`
-`);
-}
-function formatRatio(ratio) {
-  return ratio === null ? "n/a" : `${(ratio * 100).toFixed(1)}%`;
-}
-function byCostDesc([, a], [, b]) {
-  return b.costUsd - a.costUsd;
-}
-var init_costs = __esm(() => {
-  init_models();
-});
-
 // ../../packages/domain/src/analytics/derived.ts
 class MetricRegistry {
   fns = [];
@@ -43719,6 +43724,81 @@ async function deriveMissingAssistantDurations(db, ceilingMs) {
     `);
 }
 
+// ../../packages/domain/src/analytics/executor-latency.ts
+async function readExecutorLatency(db, keys) {
+  const wanted = [...new Set(keys)].filter((key) => key.length > 0);
+  if (wanted.length === 0)
+    return new Map;
+  try {
+    const placeholders = wanted.map(() => "?").join(", ");
+    const rows = await db.queryAll(`SELECT model, assistant_duration_ms, assistant_duration_samples, errors, tool_calls
+             FROM history_board_model_stats WHERE model IN (${placeholders})`, ...wanted);
+    const stats = new Map;
+    for (const row of rows) {
+      const samples = row.assistant_duration_samples;
+      if (samples <= 0)
+        continue;
+      const successRate = row.tool_calls > 0 ? Math.min(1, Math.max(0, 1 - row.errors / row.tool_calls)) : 1;
+      stats.set(row.model, {
+        meanMs: row.assistant_duration_ms / samples,
+        samples,
+        successRate
+      });
+    }
+    return stats;
+  } catch {
+    return new Map;
+  }
+}
+
+// ../../packages/domain/src/analytics/selector-time-range.ts
+function instantPrefilterBound(bound, slackMs) {
+  const at = Date.parse(bound);
+  return Number.isFinite(at) ? new Date(at + slackMs).toISOString() : undefined;
+}
+function buildTimeRangeClauses(range, target) {
+  if (!COLUMN.test(target.column))
+    throw new Error(`invalid time-range column: ${target.column}`);
+  const bound = BOUND_SQL[target.grain];
+  const clauses = [];
+  const params = [];
+  const column = COLUMN_SQL[target.grain](target.column);
+  const prefilter = target.grain === "instant";
+  if (range.since !== null) {
+    const low = prefilter ? instantPrefilterBound(range.since, -INSTANT_PREFILTER_SLACK_MS) : undefined;
+    if (low !== undefined) {
+      clauses.push(`${target.column} >= ?`);
+      params.push(low);
+    }
+    clauses.push(`${column} >= ${bound}`);
+    params.push(range.since);
+  }
+  if (range.until !== null) {
+    const high = prefilter ? instantPrefilterBound(range.until, INSTANT_PREFILTER_SLACK_MS) : undefined;
+    if (high !== undefined) {
+      clauses.push(`${target.column} <= ?`);
+      params.push(high);
+    }
+    clauses.push(`${column} <= ${bound}`);
+    params.push(range.until);
+  }
+  return { clauses, params };
+}
+var BOUND_SQL, COLUMN_SQL, COLUMN, INSTANT_PREFILTER_SLACK_MS = 1000;
+var init_selector_time_range = __esm(() => {
+  BOUND_SQL = {
+    day: "DATE(?)",
+    timestamp: "strftime('%Y-%m-%dT%H:%M:%SZ', ?)",
+    instant: "julianday(?)"
+  };
+  COLUMN_SQL = {
+    day: (column) => column,
+    timestamp: (column) => column,
+    instant: (column) => `julianday(${column})`
+  };
+  COLUMN = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+});
+
 // ../../packages/domain/src/analytics/tool-name-sql.ts
 var EFFECTIVE_TOOL_NAME_SQL = `CASE
     WHEN tc.tool_name IS NOT NULL AND TRIM(tc.tool_name) != '' AND tc.tool_name != 'unknown'
@@ -43809,13 +43889,10 @@ function escapeLike(value) {
 function buildMessageWhereClauses(sel, alias) {
   const clauses = [];
   const params = [];
-  if (sel.since != null) {
-    clauses.push(`${alias}.ts >= ?`);
-    params.push(sel.since);
-  }
-  if (sel.until != null) {
-    clauses.push(`${alias}.ts <= ?`);
-    params.push(sel.until);
+  if (sel.since != null || sel.until != null) {
+    const range = buildTimeRangeClauses({ since: sel.since ?? null, until: sel.until ?? null }, { column: `${alias}.ts`, grain: "instant" });
+    clauses.push(...range.clauses);
+    params.push(...range.params);
   }
   if (sel.sources != null && sel.sources.length > 0) {
     clauses.push(`${alias}.source IN (${sel.sources.map(() => "?").join(", ")})`);
@@ -43887,6 +43964,7 @@ function buildMessageWhereClauses(sel, alias) {
   return { clauses, params };
 }
 var init_message_where = __esm(() => {
+  init_selector_time_range();
   init_tool_alias();
 });
 
@@ -44132,8 +44210,8 @@ async function bySession(db, sel, top, opts) {
                     SUM(COALESCE(cache_read_tokens, 0)) AS cache_read_tokens,
                     SUM(COALESCE(output_tokens, 0)) AS output_tokens,
                     SUM(cost_usd) AS cost_usd,
-                    SUM(CASE WHEN role = 'assistant' THEN COALESCE(duration_ms, 0) ELSE 0 END) AS assistant_duration_ms,
-                    SUM(CASE WHEN role = 'assistant' AND duration_ms IS NULL THEN 1 ELSE 0 END) AS assistant_duration_unmeasured
+                    SUM(CASE WHEN role = 'assistant' AND disposition <> 'poll-duplicate' THEN COALESCE(duration_ms, 0) ELSE 0 END) AS assistant_duration_ms,
+                    SUM(CASE WHEN role = 'assistant' AND duration_ms IS NULL AND disposition <> 'poll-duplicate' THEN 1 ELSE 0 END) AS assistant_duration_unmeasured
              FROM selected m
              GROUP BY source, session_id
          ), last_messages AS (
@@ -44141,7 +44219,7 @@ async function bySession(db, sel, top, opts) {
                     ROW_NUMBER() OVER (
                         PARTITION BY source, session_id ORDER BY seq DESC, source_rowid DESC
                     ) AS rank
-             FROM selected WHERE disposition != 'meta'
+             FROM selected WHERE disposition NOT IN ('meta', 'poll-duplicate') -- 1324 R3: latency denominator excludes collapsed polls
          )
          SELECT ms.session_id AS sessionId, ms.source AS source, ms.model AS model,
                 ms.started_at AS startedAt, ms.ended_at AS endedAt, ms.messages AS messages,
@@ -44311,7 +44389,7 @@ async function bySessionPage(db, sel, input, opts) {
          last_messages AS (
              SELECT source, session_id, record_hash, role,
                     ROW_NUMBER() OVER (PARTITION BY source, session_id ORDER BY seq DESC, source_rowid DESC) AS rank
-             FROM selected WHERE disposition != 'meta'
+             FROM selected WHERE disposition NOT IN ('meta', 'poll-duplicate') -- 1324 R3: latency denominator excludes collapsed polls
          )
          SELECT ms.session_id AS sessionId, ms.source AS source, ms.model AS model,
                 ms.started_at AS startedAt, ms.ended_at AS endedAt, ms.messages AS messages,
@@ -44387,8 +44465,10 @@ async function loops(db, sel, opts) {
              FROM history_tool_call tc
              JOIN history_message m ON m.record_hash = tc.message_hash
              WHERE tc.session_id IN (${placeholders})
-               AND tc.args_digest IS NOT NULL
+               AND tc.args_digest IS NOT NULL AND tc.args_digest <> ''
                AND tc.session_id NOT IN ('', 'unknown', 'session')
+               -- 1324 R3: tool calls hanging off a collapsed poll duplicate are loop noise.
+               AND COALESCE(m.disposition, '') <> 'poll-duplicate'
              GROUP BY tc.source, tc.session_id, tc.tool_name, tc.args_digest
              HAVING COUNT(*) >= 3
              ORDER BY repeats DESC`, ...sessionScope);
@@ -44396,7 +44476,7 @@ async function loops(db, sel, opts) {
   const { where, params } = buildMessageWhere(sel);
   const wm = applyWatermarkToWhere(where, opts?.watermark);
   return db.queryAll(`WITH filtered_messages AS (
-             SELECT m.record_hash, m.source, m.model, m.ts
+             SELECT m.record_hash, m.source, m.model, m.ts, m.disposition
              FROM history_message m
              ${wm.where}
          )
@@ -44409,7 +44489,8 @@ async function loops(db, sel, opts) {
                 MAX(tc.seq) AS lastSeq
          FROM filtered_messages fm
          CROSS JOIN history_tool_call tc ON tc.message_hash = fm.record_hash
-         WHERE tc.args_digest IS NOT NULL AND tc.session_id NOT IN ('', 'unknown', 'session')
+         WHERE tc.args_digest IS NOT NULL AND tc.args_digest <> '' AND tc.session_id NOT IN ('', 'unknown', 'session')
+           AND COALESCE(fm.disposition, '') <> 'poll-duplicate' -- 1324 R3: collapsed poll noise
          GROUP BY fm.source, tc.session_id, tc.tool_name, tc.args_digest
          HAVING COUNT(*) >= 3
          ORDER BY repeats DESC`, ...params, ...wm.params);
@@ -45392,32 +45473,6 @@ var init_forensic_query = __esm(() => {
 END`;
 });
 
-// ../../packages/domain/src/analytics/selector-time-range.ts
-function buildTimeRangeClauses(range, target) {
-  if (!COLUMN.test(target.column))
-    throw new Error(`invalid time-range column: ${target.column}`);
-  const bound = BOUND_SQL[target.grain];
-  const clauses = [];
-  const params = [];
-  if (range.since !== null) {
-    clauses.push(`${target.column} >= ${bound}`);
-    params.push(range.since);
-  }
-  if (range.until !== null) {
-    clauses.push(`${target.column} <= ${bound}`);
-    params.push(range.until);
-  }
-  return { clauses, params };
-}
-var BOUND_SQL, COLUMN;
-var init_selector_time_range = __esm(() => {
-  BOUND_SQL = {
-    day: "DATE(?)",
-    timestamp: "strftime('%Y-%m-%dT%H:%M:%SZ', ?)"
-  };
-  COLUMN = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
-});
-
 // ../../packages/domain/src/analytics/history-board-marts.ts
 function resolveSummaryReadPath(input) {
   if (!input.fresh)
@@ -53813,18 +53868,12 @@ async function loadFolds(db, spec) {
   }
 }
 function eventWindow(spec) {
-  const clauses = [];
-  const params = [];
-  if (spec.since !== undefined) {
-    clauses.push("occurred_at >= ?");
-    params.push(spec.since);
-  }
-  if (spec.until !== undefined) {
-    clauses.push("occurred_at <= ?");
-    params.push(spec.until);
-  }
+  const { clauses, params } = buildTimeRangeClauses({ since: spec.since ?? null, until: spec.until ?? null }, { column: "occurred_at", grain: "instant" });
   return { where: clauses.length > 0 ? `AND ${clauses.join(" AND ")}` : "", params };
 }
+var init_pairings = __esm(() => {
+  init_selector_time_range();
+});
 // ../../packages/domain/src/analytics/render-report.ts
 function assertArtifactVersion(actualVersion, artifactPath, expectedVersion = HISTORY_ARTIFACT_SCHEMA_VERSION) {
   if (actualVersion !== expectedVersion) {
@@ -55645,6 +55694,7 @@ var init_workflow_measurements = __esm(() => {
 
 // ../../packages/domain/src/analytics/index.ts
 var init_analytics = __esm(() => {
+  init_antigravity_etl();
   init_artifact();
   init_artifact_digest();
   init_costs();
@@ -55655,6 +55705,7 @@ var init_analytics = __esm(() => {
   init_importer_schema_version();
   init_models();
   init_narrow_artifact();
+  init_pairings();
   init_render_forensics();
   init_render_pairings();
   init_render_report();
@@ -58153,7 +58204,7 @@ var init_run_dao = __esm(() => {
              FROM runs
              WHERE (?1 IS NULL OR workflow_name = ?1)
                AND (?2 IS NULL OR status = ?2)
-               AND (?3 IS NULL OR started_at >= ?3)
+               AND (?3 IS NULL OR julianday(started_at) >= julianday(?3))
                AND (
                  ?4 IS NULL
                  OR started_at < ?4
@@ -58165,6 +58216,9 @@ var init_run_dao = __esm(() => {
     traceRowById(runId) {
       return this.adapter.queryFirst("SELECT id, workflow_name, mode, status, agent, started_at, completed_at, updated_at, terminal_reason, metadata_json, pid FROM runs WHERE id = ?", runId);
     }
+    traceRowsByIdPrefix(prefix) {
+      return this.adapter.queryAll("SELECT id FROM runs WHERE substr(id, 1, length(?1)) = ?1 ORDER BY id LIMIT 21", prefix);
+    }
     mergeMetadata(runId, patch) {
       return this.adapter.run(`UPDATE runs
              SET metadata_json = json_patch(
@@ -58321,6 +58375,19 @@ var init_run_storage_reference_dao = __esm(() => {
 });
 
 // ../../packages/domain/src/dao/run-transfer.ts
+function stampWorktreeOrigin(row) {
+  let meta = {};
+  try {
+    const parsed = JSON.parse(String(row.metadata_json ?? "{}"));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      meta = parsed;
+    }
+  } catch {
+    meta = {};
+  }
+  meta.worktree_origin = true;
+  return { ...row, metadata_json: JSON.stringify(meta) };
+}
 function insertIfAbsentOps(table, rows, targetColumns) {
   return rows.map((row) => {
     const columns = Object.keys(row).filter((column) => targetColumns.has(column));
@@ -58349,6 +58416,29 @@ async function ledgerOps(from, to, runId) {
   }
   return ops;
 }
+async function worktreeRunSessionOps(from, to, runId) {
+  const present = await from.queryFirst("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?", "history_run_session");
+  if (present === undefined)
+    return [];
+  const rows = await from.queryAll("SELECT * FROM history_run_session WHERE run_id = ?", runId);
+  if (rows.length === 0)
+    return [];
+  const targetColumns = await tableColumns(to, "history_run_session");
+  const ops = [];
+  for (const row of rows) {
+    const exists = await to.queryFirst(`SELECT run_id FROM history_run_session
+             WHERE run_id = ? AND source IS ? AND session_id IS ? AND exactness IS ? AND resolved_at IS ?
+             LIMIT 1`, row.run_id, row.source ?? null, row.session_id ?? null, row.exactness ?? null, row.resolved_at ?? null);
+    if (exists !== undefined)
+      continue;
+    const columns = Object.keys(row).filter((column) => targetColumns.has(column));
+    ops.push({
+      sql: `INSERT INTO history_run_session (${columns.join(", ")}) ` + `VALUES (${columns.map(() => "?").join(", ")})`,
+      params: columns.map((column) => column === "mechanism" ? "worktree-merge" : row[column])
+    });
+  }
+  return ops;
+}
 async function tableColumns(db, table) {
   const rows = await db.queryAll(`PRAGMA table_info(${table})`);
   return new Set(rows.map((row) => row.name));
@@ -58387,7 +58477,8 @@ async function transferRunTables(from, to) {
         continue;
       }
     }
-    const ops = insertIfAbsentOps("runs", [row], targetRunsColumns);
+    const ops = insertIfAbsentOps("runs", [stampWorktreeOrigin(row)], targetRunsColumns);
+    ops.push(...await worktreeRunSessionOps(from, to, id));
     for (const table of CHILD_TABLES) {
       ops.push(...insertIfAbsentOps(table, await from.queryAll(`SELECT * FROM ${table} WHERE run_id = ?`, id), await tableColumns(to, table)));
     }
@@ -75695,6 +75786,13 @@ class MarkdownDocument {
   get sectionNames() {
     return this._sections.map((s) => s.name);
   }
+  sectionContent(name) {
+    const section = this.findSection(name);
+    if (section === undefined)
+      return null;
+    const text = section.modifiedText ?? section.originalText;
+    return { headingLine: section.headingLine, text };
+  }
   get demotedHeadings() {
     return this._demotedHeadings;
   }
@@ -99550,6 +99648,12 @@ function bounded3(value, maxLength = MAX_FIELD_LENGTH) {
   const redacted = value.replace(SECRET_PATTERN2, "[REDACTED]");
   return redacted.length <= maxLength ? redacted : `${redacted.slice(0, maxLength)}\u2026`;
 }
+function positiveMs(value) {
+  const n = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  if (typeof n !== "number" || !Number.isFinite(n) || n <= 0)
+    return;
+  return Math.trunc(n);
+}
 function projectActionMetadata(kind, options) {
   if (options === undefined)
     return;
@@ -99561,9 +99665,9 @@ function projectActionMetadata(kind, options) {
   if (kind === "agent.run" && typeof options.role === "string" && options.role !== "") {
     metadata.role = bounded3(options.role);
   }
-  if (typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs)) {
-    metadata.timeoutMs = Math.max(0, options.timeoutMs);
-  }
+  const timeoutMs = positiveMs(options.timeoutMs);
+  if (timeoutMs !== undefined)
+    metadata.timeoutMs = timeoutMs;
   if (typeof options.maxTokens === "number" && Number.isFinite(options.maxTokens)) {
     metadata.maxTokens = Math.max(0, options.maxTokens);
   }
@@ -102629,6 +102733,13 @@ function classifyDispatch(result) {
   }
   return;
 }
+function executorUnavailabilityEvidence(result) {
+  if (result.exitCode === 2)
+    return `dispatch-level exit 2 (executor unusable for this run)`;
+  if (result.signal === "unavailable")
+    return `terminal signal ${result.signal}`;
+  return;
+}
 var FAILURE_RULES, PERMISSION_PATTERNS, HTTP_STATUS_PATTERN;
 var init_failure_classification = __esm(() => {
   init_agent_execution();
@@ -105481,6 +105592,8 @@ ${traced.stdout ?? ""}`);
       const resumedDispatch = ok && affinityOn && !freshSession && resumeSupported && storedSessionId !== undefined;
       if (!ok && traced.signal !== undefined)
         resultData.signal = traced.signal;
+      if (traced.ladder !== undefined && traced.ladder.length > 0)
+        resultData.ladder = traced.ladder;
       resultData.session = resumedDispatch ? "reused" : "fresh";
       resultData.sessionSource = sessionDeclared ? "declared" : "default";
       if (escalated) {
@@ -107544,6 +107657,72 @@ var init_agent_invocation_sanitize = __esm(() => {
   SENSITIVE_INLINE_FLAG = /^(--?(?:api[-_]?key|authorization|credential|password|secret|token)=).+$/i;
 });
 
+// ../../packages/app/src/services/adaptive-timeout.ts
+function derivedBudgetMs(latency) {
+  const base = latency.p95Ms ?? latency.meanMs;
+  const headroom = latency.p95Ms !== undefined ? P95_HEADROOM : MEAN_HEADROOM;
+  return Math.max(DERIVED_FLOOR_MS, Math.ceil(base * headroom));
+}
+function resolveAdaptiveTimeoutMs(staticMs, latency) {
+  if (latency === undefined || latency.samples <= 0) {
+    return {
+      source: "static",
+      ...staticMs !== undefined ? { staticMs, appliedMs: staticMs } : {},
+      fits: true
+    };
+  }
+  const derivedMs = derivedBudgetMs(latency);
+  if (staticMs === undefined) {
+    return {
+      source: "derived-latency",
+      appliedMs: derivedMs,
+      derivedMs,
+      meanMs: latency.meanMs,
+      ...latency.p95Ms !== undefined ? { p95Ms: latency.p95Ms } : {},
+      samples: latency.samples,
+      successRate: latency.successRate,
+      fits: true
+    };
+  }
+  const fits = derivedMs <= staticMs;
+  return {
+    source: "static",
+    staticMs,
+    appliedMs: staticMs,
+    derivedMs,
+    meanMs: latency.meanMs,
+    ...latency.p95Ms !== undefined ? { p95Ms: latency.p95Ms } : {},
+    samples: latency.samples,
+    successRate: latency.successRate,
+    fits
+  };
+}
+function ladderScore(latency) {
+  const base = latency.p95Ms ?? latency.meanMs;
+  const successRate = Math.min(1, Math.max(0.1, latency.successRate));
+  return base / successRate;
+}
+async function loadExecutorLatency(source, keys) {
+  if (source.historyLatency !== undefined) {
+    try {
+      return new Map(Object.entries(await source.historyLatency([...keys])));
+    } catch {
+      return new Map;
+    }
+  }
+  if (source.getDb === undefined)
+    return new Map;
+  try {
+    return await readExecutorLatency(await source.getDb(), keys);
+  } catch {
+    return new Map;
+  }
+}
+var P95_HEADROOM = 1.5, MEAN_HEADROOM = 3, DERIVED_FLOOR_MS = 30000;
+var init_adaptive_timeout = __esm(() => {
+  init_src2();
+});
+
 // ../../packages/app/src/services/agent-run-flags.ts
 function stringFlag(flags, name, fallback) {
   const value = flags[name];
@@ -107743,10 +107922,12 @@ class AgentResolver {
         const failedTier = getExecutorTier(failed);
         const failedCanonical = resolveAgentName2(failed.agent);
         const exhaustedAgents = new Set(executors.filter((executor) => executor.name === fromExecutor || (exclude?.has(executor.name) ?? false)).map((executor) => resolveAgentName2(executor.agent)).filter((agent) => agent !== undefined));
-        const sideways = executors.filter((e) => {
+        let sideways = executors.filter((e) => {
           const canonical = resolveAgentName2(e.agent);
           return !executorDisabled(e) && e.name !== fromExecutor && getExecutorTier(e) === failedTier && canonical !== failedCanonical && (canonical === undefined || !exhaustedAgents.has(canonical)) && !(exclude?.has(e.name) ?? false);
         });
+        const sidewaysOrder = await this.orderEligibleByMeasuredLatency(sideways, signal !== undefined);
+        sideways = sidewaysOrder.ordered;
         for (const executor of sideways) {
           const canonical = resolveAgentName2(executor.agent);
           if (canonical === undefined) {
@@ -107772,6 +107953,7 @@ class AgentResolver {
               model: executor.model,
               source: "stage",
               executor: executor.name,
+              ...sidewaysOrder.ordering !== undefined ? { ordering: sidewaysOrder.ordering } : {},
               stage: {
                 stageId: stageRecord.id,
                 policy,
@@ -107810,7 +107992,9 @@ class AgentResolver {
     if (eligible.length === 0) {
       return;
     }
-    for (const executor of eligible) {
+    const measuredOrder = await this.orderEligibleByMeasuredLatency(eligible, signal !== undefined);
+    const orderedEligible = measuredOrder.ordered;
+    for (const executor of orderedEligible) {
       const canonical = resolveAgentName2(executor.agent);
       if (canonical === undefined) {
         return {
@@ -107834,6 +108018,7 @@ class AgentResolver {
           model: executor.model,
           source: "stage",
           executor: executor.name,
+          ...measuredOrder.ordering !== undefined ? { ordering: measuredOrder.ordering } : {},
           stage: {
             stageId: stageRecord.id,
             policy,
@@ -107845,6 +108030,36 @@ class AgentResolver {
     }
     return;
   }
+  async orderEligibleByMeasuredLatency(eligible, ordered) {
+    if (!ordered || eligible.length <= 1)
+      return { ordered: [...eligible] };
+    const stats = await loadExecutorLatency(this.ctx, eligible.map((e) => e.model ?? e.name));
+    const scored = eligible.map((executor, index) => {
+      const hit = stats.get(executor.model ?? executor.name);
+      return {
+        executor,
+        index,
+        ...hit !== undefined && hit.samples > 0 ? { score: ladderScore(hit), samples: hit.samples } : {}
+      };
+    });
+    const known = scored.filter((entry) => entry.score !== undefined);
+    if (known.length === 0)
+      return { ordered: [...eligible] };
+    const sorted = [...scored].sort((a, b) => {
+      const aKnown = a.score !== undefined ? 1 : 0;
+      const bKnown = b.score !== undefined ? 1 : 0;
+      if (aKnown !== bKnown)
+        return bKnown - aKnown;
+      if (aKnown === 1)
+        return (a.score ?? 0) - (b.score ?? 0) || a.index - b.index;
+      return a.index - b.index;
+    });
+    const ordering = sorted.map((entry) => ({
+      executor: entry.executor.name,
+      ...entry.score !== undefined ? { scoreMs: entry.score, samples: entry.samples } : {}
+    }));
+    return { ordered: sorted.map((entry) => entry.executor), ordering };
+  }
   async resolveAgentPriority(doctorRunner) {
     const results = await doctorRunner.runAll();
     for (const name of TIER1_PRIORITY2) {
@@ -108076,6 +108291,7 @@ var warnedBareBinary;
 var init_agent_resolver = __esm(() => {
   init_src2();
   init_dist29();
+  init_adaptive_timeout();
   init_capability_attestation();
   init_executor_tier();
   warnedBareBinary = new Set;
@@ -109066,6 +109282,36 @@ class AgentRunExecutor {
     this.resolver = resolver;
   }
   sessionRootRegistry = { active: new Map, overlapped: new Set };
+  runBreakers = new Map;
+  static BREAKER_CAP = 256;
+  breakerFor(runId) {
+    let breaker = this.runBreakers.get(runId);
+    if (breaker === undefined) {
+      breaker = { executors: new Set, touchedAt: Date.now() };
+      this.runBreakers.set(runId, breaker);
+      if (this.runBreakers.size > AgentRunExecutor.BREAKER_CAP) {
+        const oldest = [...this.runBreakers.entries()].sort((a, b) => a[1].touchedAt - b[1].touchedAt);
+        for (const [key] of oldest.slice(0, this.runBreakers.size - AgentRunExecutor.BREAKER_CAP)) {
+          this.runBreakers.delete(key);
+        }
+      }
+    }
+    breaker.touchedAt = Date.now();
+    return breaker;
+  }
+  recordLadderDecision(decisions, identity, events, decision) {
+    const row = { ...decision, at: new Date().toISOString() };
+    decisions.push(row);
+    if (events !== undefined) {
+      events.emit("agent.invoke.ladder", {
+        runId: identity.runId,
+        executionId: identity.executionId,
+        ...identity.actionId !== undefined ? { actionId: identity.actionId } : {},
+        ...row,
+        severity: "warning"
+      });
+    }
+  }
   async executeRun(prompt, flags, deps, options) {
     const silent = options.silent;
     const nonInteractive = options.nonInteractive === true;
@@ -109137,6 +109383,9 @@ class AgentRunExecutor {
     if (quotaEventBridge !== undefined)
       quotaEventBridge.on("agent.quota.exhausted", onQuotaExhausted);
     const tiersAttempted = new Set(currentStage ? [currentStage.executorTier] : []);
+    const breaker = this.breakerFor(stringFlag(flags, "run-id", runCorrelation.runId));
+    const ladderDecisions = [];
+    const latencyCache = new Map;
     if (!jsonOutput && TIER2_AGENTS2.has(currentAgent)) {
       this.ctx.output.error(`Warning: ${currentAgent} is a Tier-2 agent (TUI/gateway only)`);
     }
@@ -109227,10 +109476,85 @@ class AgentRunExecutor {
         await sessionObserver.watermark(currentAgent, sessionDir);
       }
     }
+    if (currentStage !== undefined && breaker.executors.has(currentStage.executorName)) {
+      const skippedExecutor = currentStage.executorName;
+      runFlags.signal = "resource-exhaustion";
+      runFlags["from-executor"] = skippedExecutor;
+      const rerun = await this.resolver.resolveAgent(runFlags, doctorRunner, new Set([...attemptedExecutors, ...breaker.executors]));
+      if (!rerun.ok || rerun.stage === undefined || breaker.executors.has(rerun.stage.executorName)) {
+        const message = `executor circuit breaker: every remaining executor for stage '${skippedExecutor}' is ` + `unavailable for this run (tripped: ${[...breaker.executors].join(", ")})`;
+        this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+          kind: "chain-exhausted",
+          executor: skippedExecutor,
+          reason: message
+        });
+        await sessionObserver?.resolve();
+        return { ok: false, exitCode: 2, message };
+      }
+      currentAgent = rerun.agent;
+      currentModel = rerun.model;
+      currentSource = rerun.source;
+      currentStage = rerun.stage;
+      currentRole = rerun.role;
+      currentRoleOrigin = rerun.roleOrigin;
+      dispatchExecutor.setRoleEnv(currentRole);
+      currentTier = rerun.tier;
+      currentExecutor = rerun.executor;
+      routing = buildRoutingAttribution(rerun);
+      attemptedExecutors.add(rerun.stage.executorName);
+      tiersAttempted.add(rerun.stage.executorTier);
+      this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+        kind: "breaker-skip",
+        executor: skippedExecutor,
+        toExecutor: rerun.stage.executorName,
+        reason: "run-scoped circuit breaker: skipped an executor proven unavailable earlier in this run"
+      });
+    }
     try {
       for (let attempt = 0;; attempt++) {
         const agent = currentAgent;
         const model = (attempt === 0 ? explicitModel : undefined) ?? currentModel;
+        const attemptExecutorEntry = this.ctx.agentConfig?.executors?.find((entry) => entry.name === (currentExecutor ?? ""));
+        const latencyKey = attemptExecutorEntry?.model ?? currentExecutor ?? agent;
+        if (!latencyCache.has(latencyKey)) {
+          const stats = await loadExecutorLatency(this.ctx, [latencyKey]);
+          latencyCache.set(latencyKey, stats.get(latencyKey));
+        }
+        const timeoutDecision = resolveAdaptiveTimeoutMs(timeoutMs, latencyCache.get(latencyKey));
+        const effectiveTimeoutMs = timeoutDecision.appliedMs ?? timeoutMs;
+        if (timeoutMs !== undefined && !timeoutDecision.fits && currentStage !== undefined && breaker.executors.size + attemptedExecutors.size < 64) {
+          const exhaustedExecutor = currentStage.executorName;
+          runFlags.signal = "timeout";
+          runFlags["from-executor"] = exhaustedExecutor;
+          const rerun = await this.resolver.resolveAgent(runFlags, doctorRunner, new Set([...attemptedExecutors, ...breaker.executors]));
+          if (rerun.ok && rerun.stage !== undefined && rerun.stage.executorName !== exhaustedExecutor && !attemptedExecutors.has(rerun.stage.executorName) && !breaker.executors.has(rerun.stage.executorName)) {
+            currentAgent = rerun.agent;
+            currentModel = rerun.model;
+            currentSource = rerun.source;
+            currentStage = rerun.stage;
+            currentRole = rerun.role;
+            currentRoleOrigin = rerun.roleOrigin;
+            dispatchExecutor.setRoleEnv(currentRole);
+            currentTier = rerun.tier;
+            currentExecutor = rerun.executor;
+            routing = buildRoutingAttribution(rerun);
+            attemptedExecutors.add(rerun.stage.executorName);
+            tiersAttempted.add(rerun.stage.executorTier);
+            this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+              kind: "timeout-exhausted-skip",
+              executor: exhaustedExecutor,
+              toExecutor: rerun.stage.executorName,
+              reason: `measured latency exceeds the static budget; failed over without burning ` + `the ${timeoutMs}ms timeout`,
+              detail: JSON.stringify({
+                derivedMs: timeoutDecision.derivedMs,
+                staticMs: timeoutMs,
+                meanMs: timeoutDecision.meanMs,
+                samples: timeoutDecision.samples
+              })
+            });
+            continue;
+          }
+        }
         if (requiresCapabilities !== undefined && Object.keys(requiresCapabilities).length > 0) {
           const executorEntry = this.ctx.agentConfig?.executors?.find((entry) => entry.name === (currentExecutor ?? ""));
           const evaluation = evaluateCapabilities(requiresCapabilities, executorEntry);
@@ -109302,7 +109626,8 @@ class AgentRunExecutor {
           ...cwd !== "" ? { cwd } : {},
           mode,
           outputMode,
-          ...timeoutMs !== undefined ? { timeoutMs } : {},
+          ...effectiveTimeoutMs !== undefined ? { timeoutMs: effectiveTimeoutMs } : {},
+          ...timeoutDecision.staticMs !== undefined || timeoutDecision.derivedMs !== undefined ? { timeoutBudget: timeoutDecision } : {},
           continue: !freshRole && continueFlag,
           stdinInteractive: false,
           ...model !== undefined ? { model } : {},
@@ -109314,7 +109639,7 @@ class AgentRunExecutor {
             agent,
             ...model !== undefined ? { model } : {},
             invocation: `${attemptInvocation.command} ${attemptInvocation.argv.join(" ")}`,
-            ...timeoutMs !== undefined ? { timeoutMs } : {},
+            ...effectiveTimeoutMs !== undefined ? { timeoutMs: effectiveTimeoutMs } : {},
             ...routing !== undefined ? { routing } : {}
           });
           dispatchStartedAt = Date.now();
@@ -109359,7 +109684,7 @@ class AgentRunExecutor {
         try {
           result = warmOutcome !== undefined ? warmResult(warmOutcome, dispatchStartedAt) : await runner.runPromptCommand(agent, promptOptions, {
             cwd: cwd || undefined,
-            ...timeoutMs !== undefined ? { timeout: timeoutMs } : {},
+            ...effectiveTimeoutMs !== undefined ? { timeout: effectiveTimeoutMs } : {},
             signal: controller.signal,
             correlation: lifecycle.identity,
             ...currentExecutor !== undefined ? {
@@ -109399,8 +109724,19 @@ class AgentRunExecutor {
         if (result.exitCode === 0)
           break;
         const quotaConfirmed = currentExecutor !== undefined && runQuotaExhaustedExecutors.has(currentExecutor);
+        const unavailability = executorUnavailabilityEvidence(result);
+        let breakerTripped = false;
+        if (unavailability !== undefined && currentStage !== undefined) {
+          breaker.executors.add(currentStage.executorName);
+          breakerTripped = true;
+          this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+            kind: "breaker-trip",
+            executor: currentStage.executorName,
+            reason: `circuit breaker: ${unavailability}`
+          });
+        }
         const classifiedSignal = classifyObjectiveFailure(result);
-        let escalationSignal = quotaConfirmed ? "resource-exhaustion" : classifiedSignal;
+        let escalationSignal = quotaConfirmed ? "resource-exhaustion" : classifiedSignal ?? (breakerTripped ? "resource-exhaustion" : undefined);
         if (escalationSignal === undefined && result.signal === undefined && this.ctx.classifyUnmatchedFailure !== undefined) {
           const text = `${result.stderr ?? ""}
 ${result.stdout ?? ""}`;
@@ -109415,15 +109751,21 @@ ${result.stdout ?? ""}`;
         }
         const matchingFallbacks = currentStage.policy.fallback.filter((fallback) => fallback.trigger === escalationSignal);
         if (matchingFallbacks.length === 0 || escalationSignal !== "resource-exhaustion" && attempt >= matchingFallbacks.length) {
-          break;
+          if (!breakerTripped)
+            break;
         }
         runFlags.signal = escalationSignal;
         runFlags["from-executor"] = currentStage.executorName;
-        const nextResolved = await this.resolver.resolveAgent(runFlags, doctorRunner, attemptedExecutors);
-        if (!nextResolved.ok || nextResolved.stage === undefined || attemptedExecutors.has(nextResolved.stage.executorName)) {
+        const nextResolved = await this.resolver.resolveAgent(runFlags, doctorRunner, new Set([...attemptedExecutors, ...breaker.executors]));
+        if (!nextResolved.ok || nextResolved.stage === undefined || attemptedExecutors.has(nextResolved.stage.executorName) || breaker.executors.has(nextResolved.stage.executorName)) {
           if (!jsonOutput) {
             this.ctx.output.error(`Escalation chain exhausted after ${attempt + 1} attempt(s); stage=${currentStage.stageId}; tiers attempted: ${[...tiersAttempted].join(", ")}; executors tried: ${[...attemptedExecutors].join(", ")}`);
           }
+          this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+            kind: "chain-exhausted",
+            executor: currentStage.executorName,
+            reason: `escalation chain exhausted; executors tried: ${[...attemptedExecutors].join(", ")}`
+          });
           if (this.ctx.events !== undefined) {
             this.ctx.events.emit("agent.invoke.exhausted", {
               runId: lifecycle.identity.runId,
@@ -109438,9 +109780,12 @@ ${result.stdout ?? ""}`;
           }
           break;
         }
+        const escalationLine = `Escalating: ${currentStage.executorName} (tier ${currentStage.executorTier}) failed with ${escalationSignal}; retrying on ${nextResolved.stage.executorName} (tier ${nextResolved.stage.executorTier})`;
+        const failedExecutor = currentStage.executorName;
         if (!jsonOutput) {
-          this.ctx.output.error(`Escalating: ${currentStage.executorName} (tier ${currentStage.executorTier}) failed with ${escalationSignal}; retrying on ${nextResolved.stage.executorName} (tier ${nextResolved.stage.executorTier})`);
+          this.ctx.output.error(escalationLine);
         }
+        agentLog.append("stderr", escalationLine);
         if (this.ctx.events !== undefined) {
           this.ctx.events.emit("agent.invoke.escalated", {
             runId: lifecycle.identity.runId,
@@ -109466,6 +109811,12 @@ ${result.stdout ?? ""}`;
         routing = buildRoutingAttribution(nextResolved);
         attemptedExecutors.add(nextResolved.stage.executorName);
         tiersAttempted.add(nextResolved.stage.executorTier);
+        this.recordLadderDecision(ladderDecisions, lifecycle.identity, this.ctx.events, {
+          kind: "escalation",
+          executor: failedExecutor,
+          toExecutor: nextResolved.stage.executorName,
+          reason: `escalated on ${escalationSignal}`
+        });
       }
     } finally {
       if (quotaEventBridge !== undefined)
@@ -109515,6 +109866,7 @@ ${result.stdout ?? ""}`;
       ok: true,
       result,
       invocation,
+      ...ladderDecisions.length > 0 ? { ladder: ladderDecisions } : {},
       ...occupantRef !== undefined ? { coordination: { occupant: occupantRef } } : {}
     };
   }
@@ -109540,6 +109892,7 @@ var init_agent_run_executor = __esm(() => {
   init_agent_run_log();
   init_fleet_dispatch();
   init_run_record();
+  init_adaptive_timeout();
   init_agent_invocation_sanitize();
   init_agent_routing_attribution();
   init_agent_run_preflight();
@@ -109712,6 +110065,7 @@ class AgentService {
     return {
       exitCode,
       invocation: outcome.invocation,
+      ...outcome.ladder !== undefined ? { ladder: outcome.ladder } : {},
       stdout: result.stdout,
       stderr: result.stderr,
       durationMs: result.durationMs,
@@ -119085,7 +119439,10 @@ async function deriveVerifiedOutcome(deps, window2 = {}) {
     const linkDao = new TaskRunLinkDao(deps.db);
     linkRows = [];
     for (const run of runs) {
-      if (window2.until !== null && window2.until !== undefined && (run.started_at ?? "") > window2.until)
+      const startedAt = Date.parse(run.started_at ?? "");
+      if (!Number.isFinite(startedAt))
+        continue;
+      if (window2.until !== null && window2.until !== undefined && startedAt > Date.parse(window2.until))
         continue;
       for (const link of await linkDao.listByRun(run.id, 100)) {
         linkRows.push({
@@ -128183,10 +128540,19 @@ class TaskFiles {
   slugify(title) {
     return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   }
+  async sizeBudgetWarnings(filePath) {
+    try {
+      const doc = MarkdownDocument.parse(await this.ctx.fs.readFile(filePath), "task");
+      return evaluateTaskSize(doc.bodyWithoutFrontmatter).reasons;
+    } catch {
+      return [];
+    }
+  }
 }
 var init_task_files = __esm(() => {
   init_src2();
   init_task_service_errors();
+  init_task_size_precheck();
 });
 
 // ../../packages/app/src/services/task-section-bodies.ts
@@ -128524,12 +128890,15 @@ ${templateBackground}`;
       const ref = { kind: "task", id: wbs, filePath, folder };
       return { ref, content };
     });
-    if (featureReopened === undefined && shape.normalized === undefined)
+    const sizeWarnings = await this.files.sizeBudgetWarnings(created.ref.filePath);
+    if (featureReopened === undefined && shape.normalized === undefined && sizeWarnings.length === 0) {
       return created;
+    }
     return {
       ...created,
       ...featureReopened !== undefined ? { featureReopened } : {},
-      ...shape.normalized !== undefined ? { normalized: shape.normalized } : {}
+      ...shape.normalized !== undefined ? { normalized: shape.normalized } : {},
+      ...sizeWarnings.length > 0 ? { warnings: [...created.warnings ?? [], ...sizeWarnings] } : {}
     };
   }
   async batchCreate(jsonPath) {
@@ -128658,7 +129027,14 @@ ${issues}`);
       const ref = { kind: "task", id: wbs, filePath, folder };
       return { ref, content };
     });
-    return shape.normalized !== undefined ? { ...created, normalized: shape.normalized } : created;
+    const sizeWarnings = await this.files.sizeBudgetWarnings(created.ref.filePath);
+    if (shape.normalized === undefined && sizeWarnings.length === 0)
+      return created;
+    return {
+      ...created,
+      ...shape.normalized !== undefined ? { normalized: shape.normalized } : {},
+      ...sizeWarnings.length > 0 ? { warnings: [...created.warnings ?? [], ...sizeWarnings] } : {}
+    };
   }
   async deriveBackground(featureId) {
     const featuresDir = this.featureLink.deriveFeaturesDir();
@@ -128725,23 +129101,62 @@ class TaskQueryOps {
     this.locator = locator;
     this.files = files;
   }
-  async show(wbs) {
+  async readTaskSummary(wbs) {
     const filePath = await this.files.resolveTaskFile(wbs);
     const raw = await this.ctx.fs.readFile(filePath);
     const doc = MarkdownDocument.parse(raw, "task");
     const fm = doc.frontmatterData ?? {};
     const { status, featureId } = taskMetadata(fm);
     return {
-      wbs,
-      name: fm.name ?? "",
-      status,
-      filePath,
-      dependencies: Array.isArray(fm.dependencies) ? fm.dependencies.filter((dep) => typeof dep === "string") : [],
-      feature_id: featureId,
-      frontmatter: fm,
-      content: doc.bodyWithoutFrontmatter
+      summary: {
+        wbs,
+        name: fm.name ?? "",
+        status,
+        filePath,
+        dependencies: Array.isArray(fm.dependencies) ? fm.dependencies.filter((dep) => typeof dep === "string") : [],
+        feature_id: featureId,
+        frontmatter: fm
+      },
+      doc,
+      raw
     };
   }
+  async show(wbs) {
+    const { summary, doc } = await this.readTaskSummary(wbs);
+    return { ...summary, content: doc.bodyWithoutFrontmatter };
+  }
+  async showSections(wbs, requested) {
+    const { summary, doc, raw } = await this.readTaskSummary(wbs);
+    const present = doc.sectionNames;
+    const unknown = requested.filter((name) => !present.includes(name));
+    if (unknown.length > 0) {
+      const err = new Error(`Unknown section(s): ${unknown.map((n) => `"${n}"`).join(", ")}. ` + `Sections in task ${wbs}: ${present.join(", ") || "(none)"}`);
+      err.cliCode = "VALIDATION_FAILED";
+      throw err;
+    }
+    const sections = present.filter((name) => requested.includes(name)).map((name) => {
+      const content = doc.sectionContent(name);
+      return {
+        name,
+        headingLine: content?.headingLine ?? "",
+        byteCount: Buffer.byteLength(content?.text ?? ""),
+        content: content?.text ?? ""
+      };
+    });
+    return { ...summary, sections, totalBytes: Buffer.byteLength(raw) };
+  }
+  async showSummary(wbs) {
+    const { summary, doc, raw } = await this.readTaskSummary(wbs);
+    const sections = doc.sectionNames.map((name) => {
+      const content = doc.sectionContent(name);
+      return {
+        name,
+        headingLine: content?.headingLine ?? "",
+        byteCount: Buffer.byteLength(content?.text ?? "")
+      };
+    });
+    return { ...summary, sections, totalBytes: Buffer.byteLength(raw) };
+  }
   async refresh() {
     const folders = this.files.allFolderDirs();
     let totalTasks = 0;
@@ -130327,7 +130742,9 @@ class TaskUpdateOps {
   async updateBody(wbs, body, _actor) {
     const filePath = await this.files.resolveTaskFile(wbs);
     const ref = { kind: "task", id: wbs, filePath, folder: this.ctx.tasksDir };
-    return this.writeService.updateBody(ref, body);
+    const result = await this.writeService.updateBody(ref, body);
+    const sizeWarnings = await this.files.sizeBudgetWarnings(filePath);
+    return sizeWarnings.length > 0 ? { ...result, warnings: [...result.warnings ?? [], ...sizeWarnings] } : result;
   }
   async updateSection(wbs, sectionName, sourceFile, append = false) {
     const filePath = await this.files.resolveTaskFile(wbs);
@@ -130467,6 +130884,12 @@ class TaskService {
   async show(wbs) {
     return this.queryOps.show(wbs);
   }
+  async showSections(wbs, requested) {
+    return this.queryOps.showSections(wbs, requested);
+  }
+  async showSummary(wbs) {
+    return this.queryOps.showSummary(wbs);
+  }
   async updateStatus(wbs, toStatus, actor) {
     return this.updateOps.updateStatus(wbs, toStatus, actor);
   }
@@ -131829,6 +132252,20 @@ class CommandGateActionRunner {
         error: `resultFile ${error.message}`
       };
     }
+    let logNormalized;
+    if (options.logFile !== undefined && options.logFile !== null && options.logFile !== "") {
+      if (typeof options.logFile !== "string") {
+        return { ok: false, error: 'Action option "logFile" must be a string resolving under .spur/run/' };
+      }
+      try {
+        logNormalized = await resolveRunArtifactPath(this.fileSystem, workdir, options.logFile);
+      } catch (error) {
+        return {
+          ok: false,
+          error: `logFile ${error.message}`
+        };
+      }
+    }
     const split = splitLaunchCommand(executable, 'command.gate "executable"');
     if ("error" in split) {
       return { ok: false, error: split.error };
@@ -131853,6 +132290,7 @@ class CommandGateActionRunner {
     let lastExitCode = -1;
     let attemptsRun = 0;
     let timedOut = false;
+    let capturedLog = "";
     for (let attempt = 1;attempt <= maxAttempts; attempt++) {
       attemptsRun = attempt;
       const res = await this.processExecutor.run({
@@ -131868,7 +132306,14 @@ class CommandGateActionRunner {
       lastStderr = res.stderr;
       lastExitCode = res.exitCode ?? -1;
       timedOut = res.outcome === "timeout";
+      capturedLog += `--- attempt ${attempt} exit ${lastExitCode}${timedOut ? " (timeout)" : ""}
+${lastStdout}${lastStderr}`;
       if (res.exitCode === 0) {
+        if (logNormalized !== undefined) {
+          await this.fileSystem.ensureDir(normalize3(join59(logNormalized, "..")));
+          await this.fileSystem.writeFile(logNormalized, `${capturedLog}gate outcome: PASS (exit 0)
+`);
+        }
         await this.fileSystem.writeFile(normalized, `PASS
 `);
         return {
@@ -131879,7 +132324,8 @@ class CommandGateActionRunner {
             attempts: attemptsRun,
             stdout: lastStdout,
             stderr: lastStderr,
-            resultFile: normalized
+            resultFile: normalized,
+            ...logNormalized !== undefined ? { logFile: logNormalized } : {}
           }
         };
       }
@@ -131894,6 +132340,11 @@ ${lastStderr}`;
       }
       break;
     }
+    if (logNormalized !== undefined) {
+      await this.fileSystem.ensureDir(normalize3(join59(logNormalized, "..")));
+      await this.fileSystem.writeFile(logNormalized, `${capturedLog}gate outcome: ${commandGateOutcome(lastExitCode)} (exit ${lastExitCode})
+`);
+    }
     await this.fileSystem.writeFile(normalized, `${commandGateOutcome(lastExitCode)}
 `);
     const failureData = {
@@ -131903,6 +132354,7 @@ ${lastStderr}`;
       stdout: lastStdout,
       stderr: lastStderr,
       resultFile: normalized,
+      ...logNormalized !== undefined ? { logFile: logNormalized } : {},
       ...timedOut ? { timedOut: true, timeoutMs } : {}
     };
     if (softFail) {
@@ -135927,6 +136379,18 @@ class WorkflowInspectOps {
     const entries = await Promise.all(rows.map(async (row) => rowToTraceEntry(row, this.ctx.cwd, Date.now(), row.status === "paused" || row.status === "interrupted" ? pausedNodeBudgetMs(await actionDao.actionRowsByRunId(row.id)) : undefined)));
     return { entries, total: rows.length };
   }
+  async resolveRunId(db, input) {
+    const runDao = new RunDao(db);
+    if (await runDao.traceRowById(input))
+      return input;
+    const rows = await runDao.traceRowsByIdPrefix(input);
+    if (rows.length === 0)
+      throw new Error(`Run not found: ${input}`);
+    if (rows.length === 1)
+      return rows[0]?.id ?? input;
+    const candidates = rows.slice(0, 20).map((r) => r.id);
+    throw new Error(`Ambiguous run id prefix: ${input}; candidates: ${candidates.join(", ")}`);
+  }
   async traceRun(db, runId, preloadedRow) {
     const runDao = new RunDao(db);
     const row = preloadedRow ?? await runDao.traceRowById(runId);
@@ -137207,10 +137671,18 @@ class WorkflowAppService {
     const db = await this.ctx.getDb();
     if (typeof runIdOrFilter === "string") {
       const probe = await reapIfWorkerLost(db, this.ctx.cwd, runIdOrFilter);
-      return this.inspectOps.traceRun(db, runIdOrFilter, probe.reaped ? undefined : probe.row);
+      if (probe.row !== undefined) {
+        return this.inspectOps.traceRun(db, runIdOrFilter, probe.reaped ? undefined : probe.row);
+      }
+      const resolved = await this.inspectOps.resolveRunId(db, runIdOrFilter);
+      const resolvedProbe = await reapIfWorkerLost(db, this.ctx.cwd, resolved);
+      return this.inspectOps.traceRun(db, resolved, resolvedProbe.reaped ? undefined : resolvedProbe.row);
     }
     return this.inspectOps.traceList(db, runIdOrFilter ?? {});
   }
+  async resolveRunId(runId) {
+    return this.inspectOps.resolveRunId(await this.ctx.getDb(), runId);
+  }
   inspectRunRecord(runId) {
     return this.inspectOps.inspectRunRecord(runId);
   }
@@ -146170,6 +146642,83 @@ function resolveReceiptReuse(receiptPath, wbs, capture) {
   const receiptStatus = readReceiptStatus(receiptPath, capture.tree, wbs);
   return { reuse: receiptStatus.reuse, receiptStatus };
 }
+function workspaceGraphFrom(workspaces) {
+  const byName = new Map;
+  for (const workspace of workspaces) {
+    if (workspace.name.length > 0)
+      byName.set(workspace.name, workspace.dir);
+  }
+  const dependents = new Map;
+  for (const workspace of workspaces) {
+    for (const dependency of new Set(workspace.dependencies)) {
+      if (dependency === workspace.name || !byName.has(dependency))
+        continue;
+      const dirs = dependents.get(dependency) ?? [];
+      if (!dirs.includes(workspace.dir))
+        dirs.push(workspace.dir);
+      dependents.set(dependency, dirs);
+    }
+  }
+  return { byName, dependents };
+}
+function dependentsOf(graph, dir) {
+  for (const [name, owner] of graph.byName) {
+    if (owner !== dir)
+      continue;
+    return graph.dependents.get(name) ?? [];
+  }
+  return [];
+}
+function workspaceDependenciesOf(abs, dir) {
+  let name = "";
+  const dependencies = [];
+  try {
+    const pkg = JSON.parse(readFileSync21(abs(`${dir}/package.json`), "utf8"));
+    if (typeof pkg.name === "string")
+      name = pkg.name;
+    for (const section of [pkg.dependencies, pkg.devDependencies, pkg.peerDependencies]) {
+      if (section !== null && typeof section === "object")
+        dependencies.push(...Object.keys(section));
+    }
+  } catch {}
+  return { name, dependencies };
+}
+function readWorkspaceGraph(cwd) {
+  const abs = (p) => cwd ? join78(cwd, p) : p;
+  const info = [];
+  let globs = [];
+  try {
+    const root = JSON.parse(readFileSync21(abs("package.json"), "utf8"));
+    const declared = Array.isArray(root.workspaces) ? root.workspaces : root.workspaces?.packages;
+    if (Array.isArray(declared))
+      globs = declared.filter((g) => typeof g === "string");
+  } catch {
+    return { byName: new Map, dependents: new Map };
+  }
+  const dirs = new Set;
+  for (const glob of globs) {
+    if (glob.endsWith("/*")) {
+      const parent = glob.slice(0, -2);
+      let entries = [];
+      try {
+        entries = readdirSync11(abs(parent));
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (existsSync23(abs(`${parent}/${entry}/package.json`)))
+          dirs.add(`${parent}/${entry}`);
+      }
+    } else if (existsSync23(abs(`${glob}/package.json`))) {
+      dirs.add(glob);
+    }
+  }
+  for (const dir of [...dirs].sort()) {
+    const { name, dependencies } = workspaceDependenciesOf(abs, dir);
+    info.push({ dir, name, dependencies });
+  }
+  return workspaceGraphFrom(info);
+}
 function workspaceOf(file, exists) {
   const segments = file.split("/");
   for (let depth = 1;depth < segments.length; depth++) {
@@ -146179,7 +146728,7 @@ function workspaceOf(file, exists) {
   }
   return null;
 }
-function lightScope(changedFiles, exists = existsSync23) {
+function lightScope(changedFiles, exists = existsSync23, graph) {
   const files = [];
   const workspaces = new Set;
   const tests = new Set;
@@ -146229,7 +146778,29 @@ function lightScope(changedFiles, exists = existsSync23) {
       tests.add(file);
     }
   }
-  return { files, workspaces: [...workspaces].sort(), tests: [...tests].sort() };
+  let fallback;
+  if (graph !== undefined) {
+    for (const file of changedFiles) {
+      if (file.startsWith("plugins/sp/"))
+        continue;
+      const owner = workspaceOf(file, exists);
+      if (owner === null) {
+        fallback = `unmapped path ${file} (no owning workspace package.json) \u2014 full suite required`;
+        break;
+      }
+      const dependents = dependentsOf(graph, owner);
+      if (dependents.length > 0) {
+        fallback = `shared package ${owner} (depended on by ${dependents.join(", ")}) \u2014 full suite required`;
+        break;
+      }
+    }
+  }
+  return {
+    files,
+    workspaces: [...workspaces].sort(),
+    tests: [...tests].sort(),
+    ...fallback !== undefined ? { fallback } : {}
+  };
 }
 function workspaceHasTypecheck(workspace) {
   try {
@@ -146272,10 +146843,21 @@ function planLightChecks(scope, hasTypecheck = workspaceHasTypecheck, builder) {
   }
   return plans;
 }
-function gitChangedFiles(cwd, timeoutMs) {
+function readBaseSha(path) {
+  if (path === undefined)
+    return null;
+  try {
+    const line = readFileSync21(path, "utf8").trim();
+    return /^[0-9a-f]{7,64}$/i.test(line) ? line : null;
+  } catch {
+    return null;
+  }
+}
+function gitChangedFiles(cwd, timeoutMs, baseShaPath) {
   const abs = (p) => cwd ? join78(cwd, p) : p;
   const changed = new Set;
-  for (const cmd of ["git diff --name-only HEAD", "git ls-files --others --exclude-standard"]) {
+  const base = readBaseSha(baseShaPath) ?? "HEAD";
+  for (const cmd of [`git diff --name-only ${base}`, "git ls-files --others --exclude-standard"]) {
     const result = runShellCommand(cmd, cwd, undefined, timeoutMs);
     if (result.timedOut)
       return null;
@@ -146302,6 +146884,7 @@ function runDeferredGate(env, options = {}) {
   writeFileSync14(abs(statusFile), `${status}
 `);
   const note = status === "DEFERRED" ? `deferred gate: light tier PASS \u2014 the integrated full gate is owed on the batch base ref (1111 R3)
+` : light.blocked !== undefined ? `deferred gate: light tier BLOCKED (${light.blocked}) \u2014 no scoped tier could decide; the integrated full gate stays owed (1111 R3; 1322 R3)
 ` : `deferred gate: light tier FAIL \u2014 the task's bounded fix lane runs; the integrated full gate stays owed (1111 R3)
 `;
   appendFileSync7(abs(light.logFile), note);
@@ -146318,7 +146901,7 @@ function runLightGate(env, options = {}) {
   const receiptFile = join78(runDir, `${env.wbs}-check-receipt.json`);
   writeFileSync14(abs(logFile), "");
   const timeoutMs = gateTimeoutMsFor(env, options);
-  const changed = gitChangedFiles(cwd, timeoutMs);
+  const changed = gitChangedFiles(cwd, timeoutMs, abs(join78(runDir, `${env.wbs}-base.sha`)));
   if (changed === null) {
     const line = `--- light gate BLOCKED: changed-path git read timed out after ${timeoutMs}ms
 `;
@@ -146339,7 +146922,29 @@ function runLightGate(env, options = {}) {
     appendFileSync7(abs(logFile), `--- light receipt: no git tree identity \u2014 ${capture.error}
 `);
   }
-  const scope = lightScope(changed, (p) => existsSync23(abs(p)));
+  const scope = lightScope(changed, (p) => existsSync23(abs(p)), readWorkspaceGraph(cwd));
+  const scopeHeader = scope.fallback !== undefined ? `--- light scope: full-suite-fallback \u2014 ${scope.fallback}
+--- light scope files (${changed.length}): ${changed.join(" ")}
+` : `--- light scope: selected \u2014 workspaces: ${scope.workspaces.join(" ") || "(none)"}; related tests: ${scope.tests.length}; files: ${changed.length}
+--- light scope files (${changed.length}): ${changed.join(" ")}
+`;
+  appendFileSync7(abs(logFile), scopeHeader);
+  if (scope.fallback !== undefined) {
+    const line = `--- light gate BLOCKED: affected-scope fallback \u2014 full gate owns this tree
+`;
+    appendFileSync7(abs(logFile), line);
+    process.stdout.write(`light gate BLOCKED \u2014 ${scope.fallback}
+`);
+    return {
+      status: "FAIL",
+      scope,
+      checks: [],
+      logFile,
+      receiptFile,
+      blocked: scope.fallback,
+      fallback: scope.fallback
+    };
+  }
   const plans = planLightChecks(scope, (workspace) => workspaceHasTypecheck(abs(workspace)), options.builder);
   const reusable = new Map;
   let preserveFullReceipt = false;
@@ -146401,6 +147006,11 @@ function runLightGate(env, options = {}) {
     appendFileSync7(abs(logFile), `--- light receipt: not written \u2014 the full-tier receipt at the same git tree is preserved
 `);
     process.stdout.write(`light gate ${receipt.status} (${scope.files.length} changed files; checks: ${checks.length},` + ` skipped: ${skipped}, unbound: ${unbound}; receipt: ${receiptFile} preserved (full tier); log: ${logFile})
+`);
+  } else if (!capture.ok) {
+    appendFileSync7(abs(logFile), `--- light receipt: not written \u2014 git tree capture failed (${capture.error})
+`);
+    process.stdout.write(`light gate ${receipt.status} (${scope.files.length} changed files; checks: ${checks.length},` + ` skipped: ${skipped}, unbound: ${unbound}; receipt: none (git tree capture failed); log: ${logFile})
 `);
   } else {
     writeFileSync14(abs(receiptFile), `${JSON.stringify(receipt, null, 2)}
@@ -146709,6 +147319,37 @@ function runQualityGate(mode, env, options = {}) {
     appendFileSync7(abs(logFile), line);
     gateRc = 1;
   }
+  if (mode === "recheck" && commandPresent && gateRc === 0) {
+    const light = runLightGate(env, options);
+    appendFileSync7(abs(logFile), `--- gate visit ${mode}: affected-scope light tier (1322) \u2014 ${light.status}
+${readFileSync21(abs(light.logFile), "utf8")}`);
+    if (light.fallback === undefined) {
+      if (light.status === "FAIL") {
+        writeFileSync14(abs(findingsFile), extractFindings(readFileSync21(abs(logFile), "utf8")));
+        writeFileSync14(abs(statusFile), `FAIL
+`);
+        appendFileSync7(abs(logFile), `git-tree: ${tree.ok ? tree.tree : "unbound"}
+`);
+        process.stdout.write(`quality gate FAIL (light tier) \u2014 last 40 lines follow (full log: ${logFile})
+`);
+        process.stdout.write(tailLines(readFileSync21(abs(logFile), "utf8"), 40));
+        return {
+          status: "FAIL",
+          attempts: 0,
+          logFile,
+          findingsFile,
+          statusFile,
+          attemptFile,
+          receiptFile: light.receiptFile
+        };
+      }
+    } else {
+      const line = `check.scope-fallback \u2014 ${light.fallback}; probe + full gate follow
+`;
+      process.stdout.write(line);
+      appendFileSync7(abs(logFile), line);
+    }
+  }
   if (mode === "recheck" && gateRc === 0 && (env.gateProbeCmd ?? "").length > 0) {
     const probe = runShellCommand(env.gateProbeCmd ?? "", cwd, undefined, timeoutMs);
     writeFileSync14(abs(`${logFile}.probe`), probe.output);
@@ -147279,6 +147920,15 @@ function parseProvenance(reportMarkdown) {
       schemaVersion: obj.schemaVersion == null ? undefined : Number(obj.schemaVersion),
       executor: optionalString(obj.executor),
       model: optionalString(obj.model),
+      executorProfile: optionalString(obj.executorProfile),
+      dispatches: Array.isArray(obj.dispatches) ? obj.dispatches.map((d) => ({
+        node: String(d.node ?? ""),
+        actionId: String(d.actionId ?? ""),
+        agent: String(d.agent ?? ""),
+        executor: String(d.executor ?? ""),
+        model: String(d.model ?? ""),
+        timeoutMs: d.timeoutMs === "unbounded" ? "unbounded" : Number(d.timeoutMs ?? 0)
+      })) : undefined,
       cacheDisposition: DISPOSITIONS.includes(obj.cacheDisposition) ? obj.cacheDisposition : undefined
     };
   } catch {
@@ -147322,6 +147972,88 @@ function decideCache(cached, current, opts) {
     reasons.push("window-closed");
   return { disposition: reasons.length === 0 ? "hit" : "miss", reasons };
 }
+function evaluateCalcAssertion(expr) {
+  const text = expr.trim().replace(/^`?calc`?\s*:\s*/i, "").trim();
+  const cmp = text.match(new RegExp(`^(${NUM})\\s*(<=|>=|<|>)\\s*(${NUM})$`));
+  if (cmp !== null) {
+    const left = Number(cmp[1]);
+    const right = Number(cmp[3]);
+    switch (cmp[2]) {
+      case "<":
+        return left < right;
+      case "<=":
+        return left <= right;
+      case ">":
+        return left > right;
+      default:
+        return left >= right;
+    }
+  }
+  const eq = text.match(new RegExp(`^(${NUM}(?:\\s*[-+*/]\\s*${NUM})+)\\s*=\\s*(${NUM})$`));
+  if (eq === null)
+    return;
+  const tokens = (eq[1] ?? "").split(/\s*([-+*/])\s*/);
+  let acc = Number(tokens[0]);
+  let exact = Number.isInteger(acc);
+  let divided = false;
+  for (let i = 1;i < tokens.length; i += 2) {
+    const op = tokens[i];
+    const operand = Number(tokens[i + 1]);
+    if (op === "+")
+      acc += operand;
+    else if (op === "-")
+      acc -= operand;
+    else if (op === "*")
+      acc *= operand;
+    else {
+      if (operand === 0)
+        return false;
+      acc /= operand;
+      divided = true;
+    }
+    exact = exact && Number.isInteger(operand);
+  }
+  const expected = Number(eq[2]);
+  if (!divided && exact && Number.isInteger(expected))
+    return acc === expected;
+  const scale = Math.max(Math.abs(acc), Math.abs(expected), 1);
+  return Math.abs(acc - expected) <= 0.000000001 * scale;
+}
+function auditArithmetic(findingsBody, problems) {
+  const blockList = findingsBody.split(/^###\s+/m).slice(1);
+  for (const block of blockList) {
+    const lines = block.split(`
+`);
+    const calcLines = lines.filter((l) => CALC_LINE.test(l));
+    for (const line of calcLines) {
+      const expr = line.slice(line.search(/calc/i));
+      const verdict = evaluateCalcAssertion(expr);
+      const shown = expr.replace(/^`?calc`?\s*:\s*/i, "").trim();
+      if (verdict === undefined)
+        problems.push(`arithmetic-invalid-assertion:${shown}`);
+      else if (!verdict)
+        problems.push(`arithmetic-contradiction:${shown}`);
+    }
+    const fieldNames = ["observation", "inference"];
+    for (const field of fieldNames) {
+      const start = lines.findIndex((l) => new RegExp(`^[-*\\s]*\\*{0,2}\`?${field}\`?\\*{0,2}\\s*:`).test(l));
+      if (start === -1)
+        continue;
+      let end = lines.length;
+      for (let i = start + 1;i < lines.length; i++) {
+        if (/^[-*]\s*`?[a-zA-Z]+`?\s*:/.test(lines[i] ?? "")) {
+          end = i;
+          break;
+        }
+      }
+      const span = lines.slice(start, end).join(`
+`);
+      if (DERIVED_SIGNAL.test(span) && !CALC_LINE.test(span)) {
+        problems.push(`arithmetic-evidence-missing:${field}`);
+      }
+    }
+  }
+}
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -147379,6 +148111,7 @@ function checkReportStructure(reportMarkdown) {
         problems.push(`finding-invalid-key-category:${firstSegment}`);
       }
     }
+    auditArithmetic(findingsBody, problems);
   }
   const ledgerIdx = reportMarkdown.search(/^#{2,3}\s+Evidence\s+ledger/im);
   if (ledgerIdx !== -1) {
@@ -147561,6 +148294,66 @@ function validateSelector(opts) {
     until: val(opts.until)
   };
 }
+function collectAgentRuns(node, out) {
+  if (Array.isArray(node)) {
+    for (const item of node)
+      collectAgentRuns(item, out);
+    return;
+  }
+  if (node === null || typeof node !== "object")
+    return;
+  const obj = node;
+  if (obj.actionKind === "agent.run" && obj.ok === true)
+    out.push(obj);
+  for (const value of Object.values(obj))
+    collectAgentRuns(value, out);
+}
+function applyFinalProvenance(p, input) {
+  const lines = readFileSync25(input.validationPath, "utf8").trimEnd().split(`
+`);
+  if ((lines[lines.length - 1] ?? "").trim() !== "Verdict: PASS") {
+    throw new Error(`final validation artifact does not end with "Verdict: PASS": ${input.validationPath}`);
+  }
+  const validatedAt = statSync17(input.validationPath).mtime.toISOString();
+  let trace;
+  try {
+    trace = JSON.parse(readFileSync25(input.tracePath, "utf8"));
+  } catch (err) {
+    throw new Error(`could not parse run trace at ${input.tracePath}: ${err.message}`);
+  }
+  const collected = [];
+  collectAgentRuns(trace, collected);
+  const seen = new Set;
+  const dispatches = [];
+  for (const action of collected) {
+    const actionId = action.actionId ?? "";
+    if (actionId !== "" && seen.has(actionId))
+      continue;
+    if (actionId !== "")
+      seen.add(actionId);
+    const inv = action.invocation ?? {};
+    dispatches.push({
+      node: action.node ?? "",
+      actionId,
+      agent: inv.agent != null && inv.agent !== "" ? inv.agent : "not available: invocation agent absent",
+      executor: inv.executor != null && inv.executor !== "" ? inv.executor : "not available: invocation executor absent",
+      model: inv.model != null && inv.model !== "" ? inv.model : "not available: invocation model absent",
+      timeoutMs: typeof inv.timeoutMs === "number" && inv.timeoutMs > 0 ? inv.timeoutMs : "unbounded"
+    });
+  }
+  if (dispatches.length === 0) {
+    throw new Error(`run trace records no successful agent.run action: ${input.tracePath}`);
+  }
+  const finalValidation = [...dispatches].reverse().find((d) => d.node === "validate") ?? dispatches[dispatches.length - 1];
+  return {
+    ...p,
+    validatedAt,
+    dispatches,
+    executor: finalValidation?.agent ?? NOT_AVAILABLE,
+    model: finalValidation?.model ?? NOT_AVAILABLE,
+    executorProfile: finalValidation?.executor ?? NOT_AVAILABLE
+  };
+}
 function buildProvenance(opts) {
   let raw;
   try {
@@ -147608,10 +148401,10 @@ function buildProvenance(opts) {
     runId: opts.runId,
     currentArtifactPath: opts.artifact,
     baselineArtifactPath: opts.baseline ?? null,
-    spurVersion: opts.spurVersion ?? NOT_AVAILABLE,
+    spurVersion: opts.spurVersion !== undefined && opts.spurVersion !== "" ? opts.spurVersion : typeof raw.spurVersion === "string" && raw.spurVersion !== "" ? raw.spurVersion : NOT_AVAILABLE,
     schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : undefined,
-    executor: opts.executor ?? NOT_AVAILABLE,
-    model: opts.model ?? NOT_AVAILABLE
+    executor: opts.executor ?? "not available: probe did not receive an executor",
+    model: opts.model ?? "not available: probe did not receive a model"
   };
 }
 function probe(opts) {
@@ -147656,6 +148449,12 @@ function renderProvenanceFrontmatter(p) {
   for (const c of p.coverage) {
     lines.push(`  - source: ${c.source}, status: ${c.status}, lastImportedAt: ${c.lastImportedAt ?? "null"}`);
   }
+  if (p.dispatches !== undefined && p.dispatches.length > 0) {
+    lines.push("dispatches:");
+    for (const d of p.dispatches) {
+      lines.push(`  - node: ${d.node}, actionId: ${d.actionId}, agent: ${d.agent}, executor: ${d.executor}, model: ${d.model}, timeoutMs: ${d.timeoutMs}`);
+    }
+  }
   lines.push("---");
   return lines.join(`
 `);
@@ -147707,7 +148506,7 @@ function diffPorcelain(before, now, expects) {
   const beforePaths = porcelainPaths(before);
   return [...porcelainPaths(now)].filter((p) => !beforePaths.has(p) && !expects.has(p)).sort();
 }
-var REPORT_SECTIONS, FINDING_FIELDS, DISPOSITIONS, FINDING_CATEGORIES, NOT_AVAILABLE = "not available", YAML_KEYS;
+var REPORT_SECTIONS, FINDING_FIELDS, DISPOSITIONS, DERIVED_SIGNAL, NUM = "-?\\d+(?:\\.\\d+)?", CALC_LINE, FINDING_CATEGORIES, NOT_AVAILABLE = "not available", YAML_KEYS;
 var init_history_anatomy = __esm(() => {
   init_artifact_digest();
   REPORT_SECTIONS = [
@@ -147738,6 +148537,8 @@ var init_history_anatomy = __esm(() => {
     "ownerSurface"
   ];
   DISPOSITIONS = ["hit", "miss", "forced-recompute"];
+  DERIVED_SIGNAL = /%|\b(larger|smaller|higher|lower|more than|less than|above|below|exceeds|dominates|gap|delta|difference|sum|sums|sum of|share|ratio|mean|average)\b/i;
+  CALC_LINE = /`?calc`?\s*:\s*\S/i;
   FINDING_CATEGORIES = [
     "reliability",
     "repetition",
@@ -147763,6 +148564,7 @@ var init_history_anatomy = __esm(() => {
     "spurVersion",
     "schemaVersion",
     "executor",
+    "executorProfile",
     "model",
     "cacheDisposition"
   ];
@@ -147976,16 +148778,19 @@ ${reasons}`, stderr: "" };
         return {
           exitCode: 1,
           stdout: "",
-          stderr: `usage: spur history anatomy-stamp --candidate <c.md> --provenance <p.json> --out <o.md>
+          stderr: `usage: spur history anatomy-stamp --candidate <c.md> --provenance <p.json> --out <o.md> [--validation <v.txt> --trace <t.json>]
 `
         };
       }
       try {
-        const p = JSON.parse(readFileSync26(f.provenance, "utf8"));
+        let p = JSON.parse(readFileSync26(f.provenance, "utf8"));
+        if (f.validation !== undefined && f.trace !== undefined) {
+          p = applyFinalProvenance(p, { validationPath: f.validation, tracePath: f.trace });
+        }
         writeFileSync18(f.out, `${stampReport(readFileSync26(f.candidate, "utf8"), p)}
 `);
-      } catch {
-        return { exitCode: 1, stdout: "", stderr: `stamp: could not read candidate or provenance
+      } catch (err) {
+        return { exitCode: 1, stdout: "", stderr: `stamp: ${err.message}
 ` };
       }
       return { exitCode: 0, stdout: "", stderr: "" };
@@ -156992,6 +157797,7 @@ var SHARED_OPTIONS = {
   ],
   jsonSupported: ["--json", "Output machine-readable JSON where supported"],
   section: ["--section <name>", "Section name to write"],
+  sectionShowFilter: ["--section <name>", "Show only this section, byte-exact (repeatable)"],
   fromFile: ["--from-file <path>", "File to read section body from (requires --section)"],
   statusFilter: ["--status <s>", "Filter by status"],
   last: ["--last <n>", "Limit results (default 20)"],
@@ -158817,11 +159623,13 @@ function registerTaskBatchCreateCommand(task, context) {
       if (options.json) {
         const ids = children.map((r) => r.ref.id);
         const normalized = children.map((r, i) => ({ wbs: ids[i] ?? r.ref.id, normalized: r.normalized ?? [] })).filter((row) => row.normalized.length > 0);
+        const warnings = children.map((r, i) => ({ wbs: ids[i] ?? r.ref.id, warnings: r.warnings ?? [] })).filter((row) => row.warnings.length > 0);
         context.output.write(toEnvelopeJson({
           created: children.length,
           wbs: ids,
           parentsWired,
           ...normalized.length > 0 ? { normalized } : {},
+          ...warnings.length > 0 ? { warnings } : {},
           ...featureReopened.some((r) => r !== undefined) ? { featureReopened } : {},
           ...readiness
         }, { enveloped: options.jsonEnvelope }));
@@ -158830,6 +159638,11 @@ function registerTaskBatchCreateCommand(task, context) {
         for (const r of children) {
           context.output.write(`  ${r.ref.id}  ${r.ref.filePath}`);
         }
+        for (const r of children) {
+          for (const warning of r.warnings ?? []) {
+            context.output.error(`${r.ref.id}: ${warning}`);
+          }
+        }
         if (parentsWired.length > 0) {
           context.output.write(`Wired ${parentsWired.length} parent(s):`);
           for (const p of parentsWired) {
@@ -159135,10 +159948,20 @@ function registerTaskCreateCommand(task, context) {
           cwd: context.cwd
         });
       }
+      const warnings = result.warnings ?? [];
       if (options.json) {
-        context.output.write(toEnvelopeJson({ ...result, wbs: result.ref.id, filePath: result.ref.filePath, ...readiness }, { enveloped: options.jsonEnvelope }));
+        context.output.write(toEnvelopeJson({
+          ...result,
+          wbs: result.ref.id,
+          filePath: result.ref.filePath,
+          ...readiness,
+          ...warnings.length > 0 ? { warnings } : {}
+        }, { enveloped: options.jsonEnvelope }));
       } else {
         context.output.write(`Created task ${result.ref.id}: ${result.ref.filePath}`);
+        for (const warning of warnings) {
+          context.output.error(warning);
+        }
         if (readiness.readiness.status === "ready") {
           context.output.write(`Ready: checklist + post-check passed (${result.ref.id} promoted to todo)`);
         }
@@ -159932,14 +160755,37 @@ function registerTaskSectionsCommand(task, context) {
 
 // src/commands/task/show.ts
 init_src2();
+function collectSection(value, previous = []) {
+  return [...previous, value];
+}
+function parseCsvSections(csv) {
+  if (csv === undefined)
+    return [];
+  return csv.split(",").map((name) => name.trim()).filter((name) => name !== "");
+}
 function registerTaskShowCommand(task, context) {
-  task.command("show").alias("get").summary("Show a task by WBS.").argument("<wbs>", "Task WBS number").option(...SHARED_OPTIONS.folderTasks).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (wbs, options) => {
+  task.command("show").alias("get").summary("Show a task by WBS.").argument("<wbs>", "Task WBS number").option(...SHARED_OPTIONS.folderTasks).option(...SHARED_OPTIONS.sectionShowFilter, collectSection, []).option("--sections <csv>", 'Comma-separated section names to show (e.g. "Background,Plan"); combined with --section').option("--summary", "Print frontmatter metadata plus a section index (name, heading, byte count) and total file size \u2014 no section bodies", false).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (wbs, options) => {
+    const requested = [...options.section ?? [], ...parseCsvSections(options.sections)];
+    if (options.summary === true && requested.length > 0) {
+      writeJsonError(context.output, options, "--summary cannot be combined with --section/--sections", "VALIDATION_FAILED");
+      context.setExitCode(2);
+      return;
+    }
     const svc = await makeService(context, options.folder);
     try {
-      const result = await svc.show(wbs);
+      const result = options.summary === true ? await svc.showSummary(wbs) : requested.length > 0 ? await svc.showSections(wbs, requested) : await svc.show(wbs);
       if (options.json) {
         const { frontmatter, ...rest } = result;
         context.output.write(toEnvelopeJson({ ...rest, frontmatter }, { enveloped: options.jsonEnvelope }));
+      } else if ("sections" in result) {
+        const header = `${taskStatusIcon(result.status)} ${result.status.toUpperCase()} \u2014 ${result.wbs}`;
+        if (result.sections.every((entry) => entry.content === undefined)) {
+          const lines = result.sections.map((entry) => `  ${entry.headingLine} \u2014 ${entry.byteCount} bytes`);
+          context.output.write([`${header} \u2014 summary`, ...lines, `  total: ${result.totalBytes} bytes`].join(`
+`));
+        } else {
+          context.output.write([header, ...result.sections.map((entry) => entry.content ?? "")].join(""));
+        }
       } else {
         context.output.write(`${taskStatusIcon(result.status)} ${result.status.toUpperCase()} \u2014 ${result.wbs}
 
@@ -159948,7 +160794,7 @@ ${result.content}`);
     } catch (err) {
       const cliCode = err?.cliCode;
       writeJsonError(context.output, options, String(err), "INTERNAL_ERROR", cliCode !== undefined ? { cliCode } : undefined);
-      context.setExitCode(1);
+      context.setExitCode(cliCode === "VALIDATION_FAILED" ? 3 : 1);
     }
   });
 }
@@ -165193,7 +166039,7 @@ init_src2();
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.4.30",
+  binaryVersion: "0.4.31",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -172932,7 +173778,7 @@ init_dist5();
 import { homedir as homedir17 } from "os";
 import { basename as basename23, join as join95, relative as relative19, resolve as resolve37 } from "path";
 // ../server/package.json
-var version4 = "0.4.30";
+var version4 = "0.4.31";
 
 // ../server/src/modules/health/index.ts
 var startedAt = Date.now();
@@ -180049,13 +180895,23 @@ function registerWorkflowTraceCommand(workflow, context) {
       context.setExitCode(1);
       return;
     }
-    if (options.follow === true && runId !== undefined) {
-      const timedOut = options.output === true ? await followRunLog(svc, runId, context.cwd, pollMs, (line) => context.output.write(line), undefined, undefined, timeoutMs) : await followTrace(svc, runId, pollMs, (line) => context.output.write(line), undefined, undefined, timeoutMs);
+    let resolvedRunId = runId;
+    if (runId !== undefined) {
+      try {
+        resolvedRunId = await svc.resolveRunId(runId);
+      } catch (err) {
+        writeJsonError(context.output, options, err.message, "NOT_FOUND");
+        context.setExitCode(1);
+        return;
+      }
+    }
+    if (options.follow === true && resolvedRunId !== undefined) {
+      const timedOut = options.output === true ? await followRunLog(svc, resolvedRunId, context.cwd, pollMs, (line) => context.output.write(line), undefined, undefined, timeoutMs) : await followTrace(svc, resolvedRunId, pollMs, (line) => context.output.write(line), undefined, undefined, timeoutMs);
       if (timedOut)
         context.setExitCode(1);
       return;
     }
-    const result = runId ? await svc.trace(runId) : await svc.trace({
+    const result = resolvedRunId ? await svc.trace(resolvedRunId) : await svc.trace({
       workflow: options.workflow,
       status: options.status,
       since: options.since,