agentwrangler 0.1.1-next.2f6c1df → 0.1.1-next.37edadd

package/dist/daemon/router.js

@@ -264,7 +264,7 @@ export function handleApiRequest(_db, req, res, method, url) {
             sendJson(res, 200, getPractices(_db, { from, to }));
             return;
         }
-        // GET /api/efficiency-headroom (individual weekly estimates; separate selected-window spend)
+        // GET /api/efficiency-headroom (BM2 modeled savings vs trailing-window spend)
         if (method === "GET" && pathname === "/api/efficiency-headroom") {
             const { from, to } = resolveWindow(parseWindowFilter(url));
             sendJson(res, 200, getEfficiencyHeadroom(_db, { from, to }));

package/dist/detector/detectors/d10_catalog_footprint.js

@@ -95,7 +95,7 @@ export const d10Detector = {
         const latestProbedAt = rows.reduce((latest, row) => (latest === null || row.probed_at > latest ? row.probed_at : latest), null);
         const refs = rows.map((row) => row.file_ref);
         const evidence = {
-            title: `Review tool catalog: ${Math.round(catalogTokens / 1000)}K estimated tokens`,
+            title: `Review ${state.effective_catalog_state} tool catalog: ${Math.round(catalogTokens / 1000)}K tokens`,
             component: "MCP_SCHEMAS",
             file_ref: refs.length === 1 ? refs[0] : null,
             file_refs: refs,
@@ -120,7 +120,7 @@ export const d10Detector = {
             scopeKey: "D10|global|MCP_SCHEMAS",
             category: "TOOLING",
             scope_workspace_id: null,
-            lever: "The tool catalog exceeds its size target; actual loaded context is not measured",
+            lever: "Too many connected tools, plugins, and skills",
             target_metric: "catalog_context_tokens",
             // R11 is required before catalog size can become a freed-headroom claim.
             modeled_savings_u_per_wk: null,

package/dist/detector/detectors/d1_ctx_always_loaded.js

@@ -29,16 +29,16 @@ function stepsFor(component, fileRef) {
         case "CLAUDE_MD":
             return [
                 `Open ${fileRef}`,
-                "Move changelogs, history, and background explanations to a linked document",
-                "Keep only current rules and links here",
-                "Check the size again after the next local scan",
+                "Move changelog/history/rationale prose to a linked doc",
+                "Keep current-state rules + pointers only",
+                "Re-measure: probe re-sizes on next daemon pass",
             ];
         case "MEMORY":
             return [
                 `Review memory files under ${fileRef}`,
-                "Remove old or duplicate memories",
-                "Combine overlapping facts into concise entries",
-                "Check the size again after the next local scan",
+                "Delete stale or duplicate memories",
+                "Consolidate overlapping facts into concise entries",
+                "Re-measure: probe re-sizes on next daemon pass",
             ];
         case "MCP_SCHEMAS":
             return [
@@ -62,13 +62,13 @@ function titleFor(component, tokens, target) {
 function leverFor(component) {
     switch (component) {
         case "CLAUDE_MD":
-            return "Move changelogs and history out of CLAUDE.md; keep current rules and links.";
+            return "Move changelog/history prose out of CLAUDE.md; keep current-state + pointers.";
         case "MEMORY":
-            return "Remove old or duplicate memories and combine overlapping facts.";
+            return "Prune stale/duplicate memories; consolidate overlapping facts.";
         case "MCP_SCHEMAS":
             return "Identify rarely-used skills/plugins; extract to on-demand or disable.";
         default:
-            return "Shorten this content that is loaded into every conversation.";
+            return "Trim always-loaded context source to the per-source target.";
     }
 }
 export const d1Detector = {

package/dist/detector/detectors/d2_session_long_full_context.js

@@ -81,12 +81,12 @@ export const d2Detector = {
             scopeKey: `D2|global|${formula.model}`,
             category: "CONTEXT",
             scope_workspace_id: null,
-            lever: "Use /clear between unrelated tasks, split long work into separate sessions, and avoid automatic compaction while you are working.",
+            lever: "/clear between unrelated tasks; split long work; avoid mid-task /compact.",
             target_metric: "avg_context_per_turn",
             modeled_savings_u_per_wk: savingsU,
             modeled_formula: formula,
             evidence: {
-                title: `Split ${n} long session${n === 1 ? "" : "s"} this week`,
+                title: `Shorten sessions: ${n} long-context run${n === 1 ? "" : "s"} this week`,
                 qualifying_session_count: qualifying.length,
                 qualifying_turn_count: qualifyingTurnCount,
                 session_ids: sessionIds,

package/dist/detector/detectors/d4_model_mismatch.js

@@ -192,7 +192,7 @@ export const d4Detector = {
                 ? {
                     withheld: true,
                     withheld_reason: `Sonnet weekly cap is the binding constraint (Sonnet util ${bindingSonnet.utilization} >= all-models ${perModelSnapshot.seven_day_util}) — routing Opus->Sonnet would worsen it`,
-                    title: `Model change is not recommended: ${mismatchPct}% of Opus turns have large context and little output`,
+                    title: `[withheld] Route Opus→Sonnet: ${mismatchPct}% of turns are high-context low-output`,
                 }
                 : perModelSnapshot && sonnetEntries && sonnetEntries.length > 0
                     ? { cap_attribution: "all_models_or_opus_binds" }
@@ -202,7 +202,7 @@ export const d4Detector = {
                 category: "MODEL",
                 scope_workspace_id: workspace_id,
                 // Advisory gate (W0.3): which cap binds is NOT inferable from JSONL. Conditional lever.
-                lever: "Check /usage first. If your overall, Opus, or 5-hour limit is filling, these large-context Opus turns with little output may be suitable for Sonnet. Do not switch if your Sonnet weekly limit is the one filling.",
+                lever: "If your all-models / Opus / 5h cap is the one binding — check /usage — these high-context low-output Opus turns are Sonnet-movable. This does NOT help, and can hurt, if your Sonnet-specific weekly cap is the binding constraint.",
                 target_metric: "model_mix_opus_fraction",
                 // Advisory gate: suppress the crisp $/wk headline until live /usage cap-attribution exists.
                 modeled_savings_u_per_wk: null,
@@ -210,7 +210,7 @@ export const d4Detector = {
                 // Destructure out result_usd_per_wk so the advisory formula carries no crisp $/wk figure.
                 modeled_formula: (({ result_usd_per_wk: _, ...rest }) => ({ ...rest, kind: "ADVISORY" }))(formula),
                 evidence: {
-                    title: `Review model choice: ${mismatchPct}% of Opus turns have large context and little output`,
+                    title: `Route Opus→Sonnet: ${mismatchPct}% of turns are high-context low-output`,
                     workspace_id,
                     total_opus_turns_per_week: totalOpus,
                     mismatch_turns_per_week: mismatchCount,

package/dist/detector/detectors/d6_tool_result_bloat.js

@@ -262,7 +262,7 @@ export const d6Detector = {
                 modeled_savings_u_per_wk: modeledSavingsU,
                 modeled_formula: formula,
                 evidence: {
-                    title: `Reduce large tool results: ${Math.round(bloatShare * 100)}% of this session's context`,
+                    title: `Trim tool output: ${Math.round(bloatShare * 100)}% bloat share in session`,
                     session_id: row.session_id,
                     workspace_id: row.workspace_id,
                     tool_result_bytes: row.tool_result_bytes,

package/dist/detector/detectors/d7_loop_retry_waste.js

@@ -299,7 +299,7 @@ export const d7Detector = {
                     expression: "cap-weighted exposure of turns owning repeat-excess events; not an avoidable-token or USD savings estimate",
                 },
                 evidence: {
-                    title: `Stop repeated attempts: ${flaggedTurns.size} affected turn${flaggedTurns.size === 1 ? "" : "s"} in this session`,
+                    title: `Break retry loops: ${flaggedTurns.size} flagged turn${flaggedTurns.size === 1 ? "" : "s"} in session`,
                     session_id: sessionId,
                     workspace_id: session.workspaceId,
                     loop_flagged_event_count: flaggedEventIds.size,

package/dist/detector/detectors/d8_cache_write_churn.js

@@ -125,7 +125,7 @@ export const d8Detector = {
             // TTL-regime facet: is this session dominated by 5m-tier creation?
             const fiveMinCreation = events.reduce((s, e) => s + e.cache_write_5m, 0);
             const regime5m = totalCreation > 0 && fiveMinCreation / totalCreation >= D8_REGIME_5M_SHARE;
-            const baseLever = "Before a long break, use /clear or resume from a summary. Make instruction-file changes between sessions so they do not rebuild the cache while you work.";
+            const baseLever = "Use /clear (or resume-from-summary) before idling past the cache TTL, and batch prefix/CLAUDE.md edits to a session boundary so they don't invalidate the warm cache mid-session.";
             const lever = regime5m
                 ? `${baseLever} This session's creation is mostly 5m-tier — enable the 1h cache regime (ENABLE_PROMPT_CACHING_1H) where long pauses are unavoidable.`
                 : baseLever;
@@ -138,7 +138,7 @@ export const d8Detector = {
                 modeled_savings_u_per_wk: savingsU,
                 modeled_formula: formula,
                 evidence: {
-                    title: `Avoid repeated cache rebuilds: ${events.length} after a long pause`,
+                    title: `Reduce cache-write churn: ${events.length} re-write${events.length === 1 ? "" : "s"} in session`,
                     session_id: sessionId,
                     workspace_id,
                     churn_event_count: events.length,

package/dist/detector/detectors/d9_idle_background_session.js

@@ -62,7 +62,7 @@ export const d9Detector = {
                 modeled_savings_u_per_wk: null,
                 modeled_formula: d9Formula(sidechainCap, D9_UNPRODUCTIVE_FRACTION),
                 evidence: {
-                    title: `Review background-agent work: ${Math.round(share * 100)}% of estimated limit use`,
+                    title: `Review background fan-out: ${Math.round(share * 100)}% cap-weighted sidechain`,
                     workspace_id: row.workspace_id,
                     sidechain_cap_weighted_tokens: sidechainCap,
                     total_cap_weighted_tokens: totalCap,

package/dist/query/api/cost-per-success.js

@@ -21,7 +21,6 @@ export function getCostPerSuccess(db, workspaceId, from, to) {
             to,
             workspaceId,
             workspaceId,
-            workspaceId,
             from,
             to,
             workspaceId,
@@ -47,14 +46,6 @@ export function getCostPerSuccess(db, workspaceId, from, to) {
            JOIN merged_work_items mwi ON mwi.work_item_id = swl.work_item_id
           WHERE 1 = 1${sessionFilter}
        ),
-       merged_session_links AS (
-         SELECT swl.session_id, COUNT(DISTINCT swl.work_item_id) AS merged_pr_links
-           FROM session_work_links swl
-           JOIN merged_work_items mwi ON mwi.work_item_id = swl.work_item_id
-           JOIN sessions s ON s.session_id = swl.session_id
-          WHERE 1 = 1${sessionFilter}
-          GROUP BY swl.session_id
-       ),
        in_window_sessions AS (
          SELECT s.session_id, s.cost_equiv_u
            FROM sessions s
@@ -73,8 +64,6 @@ export function getCostPerSuccess(db, workspaceId, from, to) {
        SELECT
          (SELECT COUNT(*) FROM merged_work_items) AS merged_pr_count,
          (SELECT COUNT(*) FROM closed_unmerged_work_items) AS closed_unmerged_count,
-         (SELECT COUNT(*) FROM merged_session_links) AS unique_linked_session_count,
-         (SELECT COUNT(*) FROM merged_session_links WHERE merged_pr_links > 1) AS shared_linked_session_count,
          CASE WHEN (SELECT COUNT(*) FROM merged_work_items) = 0 THEN NULL
               ELSE (SELECT COALESCE(SUM(cost_equiv_u), 0) FROM merged_session_costs) * 1.0
                    / (SELECT COUNT(*) FROM merged_work_items)
@@ -102,14 +91,13 @@ export function getCostPerSuccess(db, workspaceId, from, to) {
     };
     return buildResponse(data, {
         claim_kind: "OBS_PROXY",
-        metric_definition_version: "esf-1",
         n: data.merged_pr_count,
         window: { from, to },
         qualification: {
             provisional_excluded: false,
             unpriced_turns: 0,
             claim_kinds_count: 1,
-            note: "Directional (OBS_PROXY): Unique linked-session cost / merged PRs. The terminal-date PR cohort counts each linked session once, even when it links to multiple merged PRs; shared sessions are coverage, not per-PR allocation. Full linked-session lifecycle cost is used, while linkage_coverage_pct is a separate session-start coverage observation. Unknown pricing is not free. Survivorship bias and reviewer dependence remain.",
+            note: "Directional (OBS_PROXY): survivorship bias (heavy-spend sessions that never open a PR are invisible); reviewer-dependence (merge is a human decision, not a quality guarantee); linkage-coverage cap (only linkage_coverage_pct% of in-window sessions are linked to a PR, so unlinked spend is excluded). cost_per_merged_pr_u uses lifecycle attribution: each merged PR carries the full cost of every linked session whenever it ran, so narrowing the window changes the PR population, not the per-PR cost.",
         },
         ...(workspaceId === null ? {} : { drilldown_ids: { workspace_id: workspaceId } }),
     });

package/dist/query/api/delivery.js

@@ -44,20 +44,8 @@ export function getDeliveryMetrics(db, opts) {
                     FROM tool_events te
                    WHERE te.session_id = iws.session_id
                      AND te.commit_sha IS NOT NULL
-                ) AND s.state = 'RECONCILED' AS is_abandoned_session,
-                s.state = 'LIVE'
-                  AND EXISTS (
-                    SELECT 1 FROM tool_events te
-                     WHERE te.session_id = iws.session_id
-                       AND te.tool_name IN ('Bash', 'Edit', 'Write', 'NotebookEdit')
-                  )
-                  AND NOT EXISTS (
-                    SELECT 1 FROM tool_events te
-                     WHERE te.session_id = iws.session_id
-                       AND te.commit_sha IS NOT NULL
-                  ) AS is_live_session
+                ) AS is_abandoned_session
            FROM in_window_sessions iws
-           JOIN sessions s USING (session_id)
        ),
        session_spend AS (
          SELECT session_id,
@@ -79,16 +67,7 @@ export function getDeliveryMetrics(db, opts) {
               CASE WHEN COALESCE(SUM(ss.spend_u), 0) = 0 THEN NULL
                    ELSE SUM(CASE WHEN sf.is_abandoned_session THEN ss.spend_u ELSE 0 END) * 1.0
                         / SUM(ss.spend_u)
-              END AS abandoned_spend_share,
-              COALESCE(SUM(sf.is_abandoned_session), 0) AS no_commit_activity_session_count,
-              COALESCE(SUM(CASE WHEN sf.is_abandoned_session THEN ss.spend_u ELSE 0 END), 0)
-                AS no_commit_activity_spend_u,
-              CASE WHEN COALESCE(SUM(ss.spend_u), 0) = 0 THEN NULL
-                   ELSE SUM(CASE WHEN sf.is_abandoned_session THEN ss.spend_u ELSE 0 END) * 1.0
-                        / SUM(ss.spend_u)
-              END AS no_commit_activity_spend_share,
-              COALESCE(SUM(CASE WHEN sf.is_live_session THEN 1 ELSE 0 END), 0)
-                AS live_session_excluded_from_no_commit_activity_count
+              END AS abandoned_spend_share
          FROM session_flags sf
          JOIN session_spend ss USING (session_id)`)
         .get(...params);
@@ -100,14 +79,13 @@ export function getDeliveryMetrics(db, opts) {
     };
     return buildResponse(data, {
         claim_kind: "OBS_PROXY",
-        metric_definition_version: "esf-1",
         n: data.commit_session_count,
         window: { from: opts.from, to: opts.to },
         qualification: {
             provisional_excluded: true,
             unpriced_turns: 0,
             claim_kinds_count: 1,
-            note: "Commit SHA presence is an observed delivery proxy. No-commit activity means RECONCILED Bash/Edit/Write/NotebookEdit activity without an observed commit; LIVE sessions remain in total spend but are excluded from that activity cohort. Legacy abandoned_* fields are compatibility aliases, not an abandonment finding.",
+            note: "Commit SHA presence is an observed delivery proxy.",
         },
         ...(opts.workspaceId === null ? {} : { drilldown_ids: { workspace_id: opts.workspaceId } }),
     });

package/dist/query/api/effectiveness.js

@@ -34,17 +34,11 @@ export function computeSessionDelivery(db, sessionId) {
         turns_to_first_commit = countRow.n;
     }
     const sessRow = db
-        .prepare(`SELECT user_turn_count, state,
-              EXISTS (SELECT 1 FROM tool_events te WHERE te.session_id = sessions.session_id
-                      AND te.tool_name IN ('Bash','Write','Edit','NotebookEdit')) AS has_activity
-         FROM sessions WHERE session_id = ?`)
+        .prepare("SELECT user_turn_count, state FROM sessions WHERE session_id = ?")
         .get(sessionId);
     const user_turn_count = sessRow?.user_turn_count ?? 0;
     const state = sessRow?.state ?? "";
-    const deep_abandoned = user_turn_count >= 10 &&
-        firstCommitTs === null &&
-        state === "RECONCILED" &&
-        sessRow?.has_activity === 1;
+    const deep_abandoned = user_turn_count >= 10 && firstCommitTs === null && state === "RECONCILED";
     return { turns_to_first_commit, deep_abandoned };
 }
 // ---------------------------------------------------------------------------
@@ -89,9 +83,8 @@ export function getAbandonedSpendSplit(db, opts) {
                     FROM tool_events te
                    WHERE te.session_id = iws.session_id
                      AND te.commit_sha IS NOT NULL
-                ) AND s.state = 'RECONCILED' AS is_abandoned_session
+                ) AS is_abandoned_session
            FROM in_window_sessions iws
-           JOIN sessions s USING (session_id)
        ),
        session_spend AS (
          SELECT session_id,
@@ -152,24 +145,15 @@ export function getClosureProxy(db, opts) {
         unresolved_count: 0,
         pending_count: 0,
         resolved_share: null,
-        no_later_workspace_session_count: 0,
-        later_workspace_session_count: 0,
-        no_later_workspace_session_share: null,
         window_hours: windowHours,
         workspace_id: opts.workspaceId,
     });
     if (candidates.length === 0) {
         return buildResponse(emptyProxy(), {
             claim_kind: "EXPERIMENTAL",
-            metric_definition_version: "esf-1",
             n: 0,
             window: { from: opts.now, to: opts.now },
-            qualification: {
-                provisional_excluded: false,
-                unpriced_turns: 0,
-                claim_kinds_count: 1,
-                note: `${note} No later workspace session is an observation, not task resolution.`,
-            },
+            qualification: { provisional_excluded: false, unpriced_turns: 0, claim_kinds_count: 1, note },
             ...(opts.workspaceId === null ? {} : { drilldown_ids: { workspace_id: opts.workspaceId } }),
         });
     }
@@ -220,23 +204,14 @@ export function getClosureProxy(db, opts) {
         unresolved_count,
         pending_count,
         resolved_share,
-        no_later_workspace_session_count: resolved_count,
-        later_workspace_session_count: unresolved_count,
-        no_later_workspace_session_share: resolved_share,
         window_hours: windowHours,
         workspace_id: opts.workspaceId,
     };
     return buildResponse(proxy, {
         claim_kind: "EXPERIMENTAL",
-        metric_definition_version: "esf-1",
         n: no_commit_session_count,
         window: { from: opts.now, to: opts.now },
-        qualification: {
-            provisional_excluded: false,
-            unpriced_turns: 0,
-            claim_kinds_count: 1,
-            note: `${note} "Resolved" and "unresolved" are legacy aliases for no later workspace session and a later workspace session; neither establishes task resolution.`,
-        },
+        qualification: { provisional_excluded: false, unpriced_turns: 0, claim_kinds_count: 1, note },
         ...(opts.workspaceId === null ? {} : { drilldown_ids: { workspace_id: opts.workspaceId } }),
     });
 }

package/dist/query/api/efficiency-headroom.js

@@ -37,19 +37,22 @@ export function getEfficiencyHeadroom(db, opts) {
          FROM turns
         WHERE ts >= ? AND ts < ? AND provisional = 0`)
         .get(from, to);
-    const opportunities = db
-        .prepare(`SELECT rec_id, modeled_savings_u_per_wk
-         FROM recommendations
-        WHERE state IN ('PROPOSED', 'ADOPTED') AND modeled_savings_u_per_wk IS NOT NULL
-        ORDER BY rec_id`)
-        .all();
     const headroom_u_per_wk = recs.sum_u ?? 0;
     const actual_u_per_wk = spend.actual_u;
-    // Individual recommendation models overlap and their weekly horizon differs from
-    // the trailing spend window, so a combined percentage would be misleading.
-    const headroom_pct = null;
+    const openRecsExist = recs.open_total > 0;
+    // Null when: no spend (avoid /0 → ∞/NaN), or open recs exist but none carries a
+    // savings figure (an all-null modeled set is not a defensible ceiling).
+    let headroom_pct;
+    if (actual_u_per_wk === 0) {
+        headroom_pct = null;
+    }
+    else if (openRecsExist && recs.with_savings === 0) {
+        headroom_pct = null;
+    }
+    else {
+        headroom_pct = headroom_u_per_wk / actual_u_per_wk;
+    }
     const data = {
-        opportunities,
         headroom_u_per_wk,
         actual_u_per_wk,
         headroom_pct,
@@ -59,14 +62,13 @@ export function getEfficiencyHeadroom(db, opts) {
     };
     return buildResponse(data, {
         claim_kind: "EXPERIMENTAL",
-        metric_definition_version: "esf-1",
         n: recs.with_savings,
         window: { from, to },
         qualification: {
             provisional_excluded: true,
             unpriced_turns: 0,
             claim_kinds_count: 1,
-            note: "Individual modeled weekly opportunities are not summed: recommendations can overlap and their weekly horizon differs from the trailing spend window.",
+            note: "Modeled headroom — if every open recommendation were applied; built from unvalidated per-detector fractions.",
         },
     });
 }

package/dist/query/api/overview.js

@@ -109,7 +109,7 @@ function makeResponse(data, o) {
                 note: "",
                 ...o.qualification,
             },
-            metric_definition_version: o.metric_definition_version ?? "observe-1",
+            metric_definition_version: "observe-1",
             claim_kind: o.claim_kind,
             drilldown_ids: o.drilldown_ids ?? {},
         },
@@ -352,30 +352,7 @@ export function listSessions(workspace_id, filters, cursor) {
               (SELECT COUNT(*) FROM tool_events te
                 WHERE te.session_id = s.session_id AND te.exit_class = 'ERROR')     AS tool_error_count,
               (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.result_bytes IS NOT NULL) AS tool_completed_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.exit_class = 'ERROR'
-                  AND te.result_bytes IS NOT NULL)                                 AS tool_completed_error_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.exit_class = 'TEST_FAIL'
-                  AND EXISTS (SELECT 1 FROM tool_event_metadata metadata
-                               WHERE metadata.event_id = te.event_id AND metadata.is_test_command = 1)) AS test_fail_count,
-              (SELECT COUNT(*) FROM tool_events te JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id AND metadata.is_test_command = 1 AND te.result_bytes IS NOT NULL) AS test_completed_count,
-              (SELECT COUNT(*) FROM tool_events te JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id AND metadata.is_test_command = 1 AND te.exit_class = 'OK' AND te.result_bytes IS NOT NULL) AS test_pass_count,
-              CASE WHEN NOT EXISTS (SELECT 1 FROM tool_events observed JOIN tool_event_metadata observed_metadata ON observed_metadata.event_id = observed.event_id
-                                     WHERE observed.session_id = s.session_id AND observed_metadata.is_test_command = 1 AND observed.result_bytes IS NOT NULL)
-                     THEN 'NO_TEST_OUTCOMES'
-                   WHEN NOT EXISTS (SELECT 1 FROM tool_events failed JOIN tool_event_metadata failed_metadata ON failed_metadata.event_id = failed.event_id
-                                    WHERE failed.session_id = s.session_id AND failed_metadata.is_test_command = 1 AND failed.exit_class = 'TEST_FAIL' AND failed.result_bytes IS NOT NULL)
-                     THEN 'NO_FAILURES_OBSERVED'
-                   WHEN EXISTS (SELECT 1 FROM tool_events passed JOIN tool_event_metadata passed_metadata ON passed_metadata.event_id = passed.event_id
-                                WHERE passed.session_id = s.session_id AND passed_metadata.is_test_command = 1 AND passed.exit_class = 'OK' AND passed.result_bytes IS NOT NULL
-                                  AND EXISTS (SELECT 1 FROM tool_events failed_before JOIN tool_event_metadata failed_before_metadata ON failed_before_metadata.event_id = failed_before.event_id
-                                              WHERE failed_before.session_id = s.session_id AND failed_before_metadata.is_test_command = 1
-                                                AND failed_before.exit_class = 'TEST_FAIL' AND failed_before.result_bytes IS NOT NULL AND failed_before.ts < passed.ts))
-                     THEN 'FAILED_THEN_PASSED' ELSE 'FAILURES_OBSERVED' END AS test_outcome,
+                WHERE te.session_id = s.session_id AND te.exit_class = 'TEST_FAIL') AS test_fail_count,
               s.gap_median_s, s.gap_p90_s, s.long_gap_count, s.gap_n,
               CASE WHEN EXISTS (
                      SELECT 1 FROM tool_events te
@@ -390,11 +367,6 @@ export function listSessions(workspace_id, filters, cursor) {
                         )
                    ) ELSE NULL END AS turns_to_first_commit,
               CASE WHEN s.state = 'RECONCILED' AND s.user_turn_count >= 10
-                        AND EXISTS (
-                          SELECT 1 FROM tool_events te
-                           WHERE te.session_id = s.session_id
-                             AND te.tool_name IN ('Bash', 'Write', 'Edit', 'NotebookEdit')
-                        )
                         AND NOT EXISTS (
                           SELECT 1 FROM tool_events te
                            WHERE te.session_id = s.session_id AND te.commit_sha IS NOT NULL
@@ -420,18 +392,9 @@ export function listSessions(workspace_id, filters, cursor) {
         compaction_count: r.compaction_count,
         api_error_count: r.api_error_count,
         interrupt_count: r.interrupt_count,
-        interrupts_supported: false,
-        api_error_eligible_request_count: null,
-        api_error_rate: null,
         user_turn_count: r.user_turn_count,
         tool_error_count: r.tool_error_count,
-        tool_completed_count: r.tool_completed_count,
-        tool_completed_error_count: r.tool_completed_error_count,
-        tool_error_rate: r.tool_completed_count > 0 ? r.tool_completed_error_count / r.tool_completed_count : null,
         test_fail_count: r.test_fail_count,
-        test_completed_count: r.test_completed_count,
-        test_pass_count: r.test_pass_count,
-        test_outcome: r.test_outcome,
         gap_median_s: r.gap_median_s,
         gap_p90_s: r.gap_p90_s,
         long_gap_count: r.long_gap_count,
@@ -440,7 +403,6 @@ export function listSessions(workspace_id, filters, cursor) {
         deep_abandoned: r.deep_abandoned_int !== 0,
     }));
     return makeResponse({ items, next_cursor: nextCursor(offset, limit, total) }, {
-        metric_definition_version: "esf-1",
         n: items.length,
         window,
         claim_kind: "LIST_EQUIV",
@@ -458,30 +420,7 @@ export function getSession(id) {
               (SELECT COUNT(*) FROM tool_events te
                 WHERE te.session_id = s.session_id AND te.exit_class = 'ERROR')     AS tool_error_count,
               (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.result_bytes IS NOT NULL) AS tool_completed_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.exit_class = 'ERROR'
-                  AND te.result_bytes IS NOT NULL)                                 AS tool_completed_error_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id AND te.exit_class = 'TEST_FAIL'
-                  AND EXISTS (SELECT 1 FROM tool_event_metadata metadata
-                               WHERE metadata.event_id = te.event_id AND metadata.is_test_command = 1)) AS test_fail_count,
-              (SELECT COUNT(*) FROM tool_events te JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id AND metadata.is_test_command = 1 AND te.result_bytes IS NOT NULL) AS test_completed_count,
-              (SELECT COUNT(*) FROM tool_events te JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id AND metadata.is_test_command = 1 AND te.exit_class = 'OK' AND te.result_bytes IS NOT NULL) AS test_pass_count,
-              CASE WHEN NOT EXISTS (SELECT 1 FROM tool_events observed JOIN tool_event_metadata observed_metadata ON observed_metadata.event_id = observed.event_id
-                                     WHERE observed.session_id = s.session_id AND observed_metadata.is_test_command = 1 AND observed.result_bytes IS NOT NULL)
-                     THEN 'NO_TEST_OUTCOMES'
-                   WHEN NOT EXISTS (SELECT 1 FROM tool_events failed JOIN tool_event_metadata failed_metadata ON failed_metadata.event_id = failed.event_id
-                                    WHERE failed.session_id = s.session_id AND failed_metadata.is_test_command = 1 AND failed.exit_class = 'TEST_FAIL' AND failed.result_bytes IS NOT NULL)
-                     THEN 'NO_FAILURES_OBSERVED'
-                   WHEN EXISTS (SELECT 1 FROM tool_events passed JOIN tool_event_metadata passed_metadata ON passed_metadata.event_id = passed.event_id
-                                WHERE passed.session_id = s.session_id AND passed_metadata.is_test_command = 1 AND passed.exit_class = 'OK' AND passed.result_bytes IS NOT NULL
-                                  AND EXISTS (SELECT 1 FROM tool_events failed_before JOIN tool_event_metadata failed_before_metadata ON failed_before_metadata.event_id = failed_before.event_id
-                                              WHERE failed_before.session_id = s.session_id AND failed_before_metadata.is_test_command = 1
-                                                AND failed_before.exit_class = 'TEST_FAIL' AND failed_before.result_bytes IS NOT NULL AND failed_before.ts < passed.ts))
-                     THEN 'FAILED_THEN_PASSED' ELSE 'FAILURES_OBSERVED' END AS test_outcome,
+                WHERE te.session_id = s.session_id AND te.exit_class = 'TEST_FAIL') AS test_fail_count,
               s.gap_median_s, s.gap_p90_s, s.long_gap_count, s.gap_n
          FROM sessions s JOIN workspaces w USING (workspace_id)
         WHERE s.session_id = ?`)
@@ -489,7 +428,6 @@ export function getSession(id) {
     const window = resolveWindow({});
     if (row === undefined) {
         return makeResponse(null, {
-            metric_definition_version: "esf-1",
             n: 0,
             window,
             claim_kind: "N_A",
@@ -513,20 +451,9 @@ export function getSession(id) {
         compaction_count: row.compaction_count,
         api_error_count: row.api_error_count,
         interrupt_count: row.interrupt_count,
-        interrupts_supported: false,
-        api_error_eligible_request_count: null,
-        api_error_rate: null,
         user_turn_count: row.user_turn_count,
         tool_error_count: row.tool_error_count,
-        tool_completed_count: row.tool_completed_count,
-        tool_completed_error_count: row.tool_completed_error_count,
-        tool_error_rate: row.tool_completed_count > 0
-            ? row.tool_completed_error_count / row.tool_completed_count
-            : null,
         test_fail_count: row.test_fail_count,
-        test_completed_count: row.test_completed_count,
-        test_pass_count: row.test_pass_count,
-        test_outcome: row.test_outcome,
         gap_median_s: row.gap_median_s,
         gap_p90_s: row.gap_p90_s,
         long_gap_count: row.long_gap_count,
@@ -534,7 +461,6 @@ export function getSession(id) {
         ...delivery,
     };
     return makeResponse(data, {
-        metric_definition_version: "esf-1",
         n: 1,
         window,
         claim_kind: "LIST_EQUIV",

package/dist/query/spend.js

@@ -156,61 +156,7 @@ export function hotSessionsByCost(db, limit = 20, window) {
                   AND te.exit_class = 'ERROR')                                AS tool_error_count,
               (SELECT COUNT(*) FROM tool_events te
                 WHERE te.session_id = s.session_id
-                  AND te.exit_class = 'ERROR'
-                  AND te.result_bytes IS NOT NULL)                             AS tool_completed_error_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id
-                  AND te.result_bytes IS NOT NULL)                             AS tool_completed_count,
-              (SELECT COUNT(*) FROM tool_events te
-                WHERE te.session_id = s.session_id
-                  AND te.exit_class = 'TEST_FAIL'
-                  AND EXISTS (
-                    SELECT 1 FROM tool_event_metadata metadata
-                     WHERE metadata.event_id = te.event_id AND metadata.is_test_command = 1
-                  ))                                                          AS test_fail_count,
-              (SELECT COUNT(*) FROM tool_events te
-                 JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id
-                  AND metadata.is_test_command = 1
-                  AND te.result_bytes IS NOT NULL)                             AS test_completed_count,
-              (SELECT COUNT(*) FROM tool_events te
-                 JOIN tool_event_metadata metadata ON metadata.event_id = te.event_id
-                WHERE te.session_id = s.session_id
-                  AND metadata.is_test_command = 1
-                  AND te.exit_class = 'OK'
-                  AND te.result_bytes IS NOT NULL)                             AS test_pass_count,
-              CASE WHEN NOT EXISTS (
-                     SELECT 1 FROM tool_events observed
-                      JOIN tool_event_metadata observed_metadata ON observed_metadata.event_id = observed.event_id
-                     WHERE observed.session_id = s.session_id
-                       AND observed_metadata.is_test_command = 1
-                       AND observed.result_bytes IS NOT NULL
-                   ) THEN 'NO_TEST_OUTCOMES'
-                   WHEN NOT EXISTS (
-                     SELECT 1 FROM tool_events failed
-                      JOIN tool_event_metadata failed_metadata ON failed_metadata.event_id = failed.event_id
-                     WHERE failed.session_id = s.session_id
-                       AND failed_metadata.is_test_command = 1
-                       AND failed.exit_class = 'TEST_FAIL'
-                       AND failed.result_bytes IS NOT NULL
-                   ) THEN 'NO_FAILURES_OBSERVED'
-                   WHEN EXISTS (
-                     SELECT 1 FROM tool_events passed
-                      JOIN tool_event_metadata passed_metadata ON passed_metadata.event_id = passed.event_id
-                     WHERE passed.session_id = s.session_id
-                       AND passed_metadata.is_test_command = 1
-                       AND passed.exit_class = 'OK'
-                       AND passed.result_bytes IS NOT NULL
-                       AND EXISTS (
-                         SELECT 1 FROM tool_events failed_before
-                          JOIN tool_event_metadata failed_before_metadata ON failed_before_metadata.event_id = failed_before.event_id
-                         WHERE failed_before.session_id = s.session_id
-                           AND failed_before_metadata.is_test_command = 1
-                           AND failed_before.exit_class = 'TEST_FAIL'
-                           AND failed_before.result_bytes IS NOT NULL
-                           AND failed_before.ts < passed.ts
-                       )
-                   ) THEN 'FAILED_THEN_PASSED' ELSE 'FAILURES_OBSERVED' END  AS test_outcome,
+                  AND te.exit_class = 'TEST_FAIL')                            AS test_fail_count,
               s.gap_median_s                                                   AS gap_median_s,
               s.gap_p90_s                                                      AS gap_p90_s,
               s.long_gap_count                                                 AS long_gap_count,
@@ -221,13 +167,5 @@ export function hotSessionsByCost(db, limit = 20, window) {
         ORDER BY cost_equiv_u DESC, s.session_id ASC
         LIMIT @limit`)
         .all(window === undefined ? { limit } : { limit, from: window.from, to: window.to });
-    return rows.map((row) => ({
-        ...row,
-        api_error_eligible_request_count: null,
-        api_error_rate: null,
-        interrupts_supported: false,
-        tool_error_rate: row.tool_completed_count > 0
-            ? row.tool_completed_error_count / row.tool_completed_count
-            : null,
-    }));
+    return rows;
 }