@use-aistack/cli 0.8.0 → 0.9.0

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/version.ts
-var CLI_VERSION = true ? "0.8.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.9.0" : "0.0.0-dev";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
@@ -2133,192 +2133,628 @@ async function hasRecentFile(roots, matches, sinceMs, opts = {}) {
   return false;
 }
 
-// ../workflow-rules/src/metricRules.ts
-var METRIC_RULES_V1 = "metric-rules/v1";
+// ../workflow-rules/src/daily.ts
+var WORKFLOW_AGGREGATES_V2 = "workflow-aggregates/v2";
+var LOG_BUCKETS_V1 = "log-buckets/v1";
+var EMPTY_PHASE_TOTALS = Object.freeze({
+  scout: 0,
+  build: 0,
+  verify: 0,
+  handoff: 0,
+  unknown: 0
+});
+var EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "other"
+];
+function effortLevelOf(effort) {
+  switch (effort.toLowerCase()) {
+    case "low":
+    case "minimal":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+    case "xhigh":
+    case "max":
+    case "ultra":
+      return "high";
+    default:
+      return "other";
+  }
+}
+function logBucket(value) {
+  if (!(value >= 1)) return 0;
+  return Math.floor(Math.log2(value)) + 1;
+}
+function bucketRange(bucket) {
+  if (bucket <= 0) return { low: 0, high: 1 };
+  return { low: 2 ** (bucket - 1), high: 2 ** bucket };
+}
+function bucketMid(bucket) {
+  const { low, high } = bucketRange(bucket);
+  return Math.sqrt(Math.max(low, 0.25) * high);
+}
+function medianBucket(buckets) {
+  const total = buckets.reduce((sum, row) => sum + row.count, 0);
+  if (total <= 0) return void 0;
+  const sorted = [...buckets].sort((a, b) => a.bucket - b.bucket);
+  const middle = (total + 1) / 2;
+  let seen = 0;
+  for (const row of sorted) {
+    seen += row.count;
+    if (seen >= middle) return row.bucket;
+  }
+  return sorted[sorted.length - 1]?.bucket;
+}
 function median(values) {
   if (values.length === 0) return void 0;
   const sorted = [...values].sort((a, b) => a - b);
   const mid = Math.floor(sorted.length / 2);
   const midValue = sorted[mid];
-  if (midValue === void 0) return void 0;
   return sorted.length % 2 === 0 ? (sorted[mid - 1] + midValue) / 2 : midValue;
 }
-function shareOf(sessions, predicate) {
-  if (!sessions || sessions.length === 0) return void 0;
-  const hits = sessions.filter(predicate).length;
-  return hits / sessions.length;
+function addPhaseTotals(into, from) {
+  for (const phase of Object.keys(into)) {
+    into[phase] += from[phase] ?? 0;
+  }
+}
+function sumBy(rows, key, add, clone) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const k = key(row);
+    const held = merged.get(k);
+    if (held) add(held, row);
+    else merged.set(k, clone(row));
+  }
+  return [...merged.values()];
+}
+function foldCells(rows, field) {
+  return sumBy(
+    rows,
+    (row) => `${row.weekdayUtc}:${row.hourUtc}`,
+    (into, from) => {
+      into[field] += from[field];
+    },
+    (row) => ({ ...row })
+  ).sort((a, b) => a.weekdayUtc - b.weekdayUtc || a.hourUtc - b.hourUtc);
+}
+function foldModels(rows) {
+  return sumBy(
+    rows,
+    (row) => row.model,
+    (into, from) => {
+      into.tokens += from.tokens;
+    },
+    (row) => ({ ...row })
+  ).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
+}
+function foldLengths(rows) {
+  return sumBy(
+    rows,
+    (row) => String(row.bucket),
+    (into, from) => {
+      into.sessions += from.sessions;
+      addPhaseTotals(into.phaseSec, from.phaseSec);
+      into.merged += from.merged;
+      into.verified += from.verified;
+      into.mergedVerified += from.mergedVerified;
+      into.openedWithScout += from.openedWithScout;
+    },
+    (row) => ({ ...row, phaseSec: { ...row.phaseSec } })
+  ).sort((a, b) => a.bucket - b.bucket);
+}
+function foldHarnessDays(days) {
+  const first = days[0];
+  if (!first) throw new Error("foldHarnessDays needs at least one day");
+  const versions = (values) => [...new Set(values)].sort().join(" \xB7 ");
+  const out = {
+    harness: first.harness,
+    sessions: days.reduce((sum, day) => sum + day.sessions, 0),
+    startHours: sumBy(
+      days.flatMap((day) => day.startHours),
+      (row) => String(row.hourUtc),
+      (into, from) => {
+        into.sessions += from.sessions;
+      },
+      (row) => ({ ...row })
+    ).sort((a, b) => a.hourUtc - b.hourUtc),
+    activity: foldCells(
+      days.flatMap((day) => day.activity),
+      "events"
+    )
+  };
+  const phases = days.flatMap((day) => day.phase ? [day.phase] : []);
+  if (phases.length > 0) {
+    const phaseSec = { ...EMPTY_PHASE_TOTALS };
+    const phaseEvents = { ...EMPTY_PHASE_TOTALS };
+    for (const phase of phases) {
+      addPhaseTotals(phaseSec, phase.phaseSec);
+      addPhaseTotals(phaseEvents, phase.phaseEvents);
+    }
+    out.phase = {
+      ruleVersion: versions(phases.map((phase) => phase.ruleVersion)),
+      sessions: phases.reduce((sum, phase) => sum + phase.sessions, 0),
+      phaseSec,
+      phaseEvents,
+      waitingSec: phases.reduce((sum, phase) => sum + phase.waitingSec, 0),
+      idleSec: phases.reduce((sum, phase) => sum + phase.idleSec, 0),
+      sessionsWithVerify: phases.reduce(
+        (sum, phase) => sum + phase.sessionsWithVerify,
+        0
+      ),
+      sessionsWithHandoff: phases.reduce(
+        (sum, phase) => sum + phase.sessionsWithHandoff,
+        0
+      ),
+      bucketRuleVersion: versions(
+        phases.map((phase) => phase.bucketRuleVersion)
+      ),
+      lengths: foldLengths(phases.flatMap((phase) => phase.lengths))
+    };
+  }
+  const routings = days.flatMap((day) => day.routing ? [day.routing] : []);
+  if (routings.length > 0) {
+    out.routing = {
+      main: foldModels(routings.flatMap((routing) => routing.main)),
+      subagents: foldModels(routings.flatMap((routing) => routing.subagents))
+    };
+  }
+  const delegations = days.flatMap(
+    (day) => day.delegation ? [day.delegation] : []
+  );
+  if (delegations.length > 0) {
+    out.delegation = {
+      mainToolCalls: delegations.reduce((sum, d) => sum + d.mainToolCalls, 0),
+      subagentToolCalls: delegations.reduce(
+        (sum, d) => sum + d.subagentToolCalls,
+        0
+      ),
+      widestFanOut: Math.max(...delegations.map((d) => d.widestFanOut)),
+      mostSubagents: Math.max(...delegations.map((d) => d.mostSubagents))
+    };
+  }
+  const efforts = days.flatMap((day) => day.effort ?? []);
+  if (days.some((day) => day.effort)) {
+    out.effort = sumBy(
+      efforts,
+      (row) => row.level,
+      (into, from) => {
+        into.turns += from.turns;
+      },
+      (row) => ({ ...row })
+    ).sort(
+      (a, b) => EFFORT_LEVELS.indexOf(a.level) - EFFORT_LEVELS.indexOf(b.level)
+    );
+  }
+  const thinkings = days.flatMap((day) => day.thinking ? [day.thinking] : []);
+  if (thinkings.length > 0) {
+    out.thinking = {
+      thinkingTokens: thinkings.reduce((sum, t) => sum + t.thinkingTokens, 0),
+      responseTokens: thinkings.reduce((sum, t) => sum + t.responseTokens, 0)
+    };
+  }
+  const durations = days.flatMap(
+    (day) => day.turnDurations ? [day.turnDurations] : []
+  );
+  if (durations.length > 0) {
+    out.turnDurations = {
+      bucketRuleVersion: versions(durations.map((d) => d.bucketRuleVersion)),
+      buckets: sumBy(
+        durations.flatMap((d) => d.buckets),
+        (row) => String(row.bucket),
+        (into, from) => {
+          into.turns += from.turns;
+        },
+        (row) => ({ ...row })
+      ).sort((a, b) => a.bucket - b.bucket)
+    };
+  }
+  const questions = days.flatMap(
+    (day) => day.questions ? [day.questions] : []
+  );
+  if (questions.length > 0) {
+    out.questions = {
+      asked: questions.reduce((sum, q) => sum + q.asked, 0),
+      turns: questions.reduce((sum, q) => sum + q.turns, 0)
+    };
+  }
+  if (days.some((day) => day.webSearches !== void 0)) {
+    out.webSearches = days.reduce(
+      (sum, day) => sum + (day.webSearches ?? 0),
+      0
+    );
+  }
+  return out;
+}
+function foldGitDays(days) {
+  const versions = (values) => [...new Set(values)].sort().join(" \xB7 ");
+  return {
+    testFileRuleVersion: versions(days.map((d) => d.testFileRuleVersion)),
+    fileTypeRuleVersion: versions(days.map((d) => d.fileTypeRuleVersion)),
+    commitSetRuleVersion: versions(days.map((d) => d.commitSetRuleVersion)),
+    commits: days.reduce((sum, d) => sum + d.commits, 0),
+    lateNightCommits: days.reduce((sum, d) => sum + d.lateNightCommits, 0),
+    additions: days.reduce((sum, d) => sum + d.additions, 0),
+    removals: days.reduce((sum, d) => sum + d.removals, 0),
+    changedLinesPerCommit: days.flatMap((d) => [...d.changedLinesPerCommit]),
+    testFileCommits: days.reduce((sum, d) => sum + d.testFileCommits, 0),
+    changedLinesByExtension: sumBy(
+      days.flatMap((d) => d.changedLinesByExtension),
+      (row) => row.extension,
+      (into, from) => {
+        into.changedLines += from.changedLines;
+      },
+      (row) => ({ ...row })
+    ).sort((a, b) => a.extension.localeCompare(b.extension)),
+    withheldExtensionLines: days.reduce(
+      (sum, d) => sum + d.withheldExtensionLines,
+      0
+    ),
+    weekdayHourCells: foldCells(
+      days.flatMap((d) => d.weekdayHourCells),
+      "commits"
+    )
+  };
+}
+function foldWorkflowDays(days, options) {
+  if (days.length === 0) return void 0;
+  const byHarness = /* @__PURE__ */ new Map();
+  for (const day of days) {
+    for (const harness of day.harnesses) {
+      const held = byHarness.get(harness.harness) ?? [];
+      held.push(harness);
+      byHarness.set(harness.harness, held);
+    }
+  }
+  const parallelProjectDays = days.flatMap(
+    (day) => day.parallelProjects === void 0 ? [] : [day.parallelProjects]
+  );
+  const webSearchDays = days.filter(
+    (day) => day.harnesses.some((harness) => harness.webSearches !== void 0)
+  ).length;
+  return {
+    aggregateVersion: options.aggregateVersion,
+    ...options.utcOffsetMinutes === void 0 ? {} : { utcOffsetMinutes: options.utcOffsetMinutes },
+    dates: [...new Set(days.map((day) => day.date))].sort(),
+    harnesses: [...byHarness.values()].map(foldHarnessDays).sort((a, b) => a.harness.localeCompare(b.harness)),
+    git: foldGitDays(days.map((day) => day.git)),
+    ...parallelProjectDays.length === 0 ? {} : { parallelProjects: Math.max(...parallelProjectDays) },
+    parallelProjectDays,
+    webSearchDays
+  };
+}
+
+// ../workflow-rules/src/reading.ts
+function playbookHarnesses(reading) {
+  return reading.harnesses.filter((harness) => harness.phase !== void 0);
+}
+function startHoursUtc(reading) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const harness of reading.harnesses) {
+    for (const cell of harness.startHours) {
+      counts.set(cell.hourUtc, (counts.get(cell.hourUtc) ?? 0) + cell.sessions);
+    }
+  }
+  return counts;
+}
+function ownerLocalHour(hourUtc, offsetMinutes) {
+  return Math.floor(((hourUtc * 60 + offsetMinutes) / 60 % 24 + 24) % 24);
+}
+function modalStartHour(reading) {
+  const offsetMinutes = reading.utcOffsetMinutes;
+  if (offsetMinutes === void 0) return void 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const [hourUtc, sessions] of startHoursUtc(reading)) {
+    const hour = ownerLocalHour(hourUtc, offsetMinutes);
+    counts.set(hour, (counts.get(hour) ?? 0) + sessions);
+  }
+  if (counts.size === 0) return void 0;
+  return [...counts.entries()].sort(
+    (a, b) => b[1] - a[1] || a[0] - b[0]
+  )[0]?.[0];
 }
+
+// ../workflow-rules/src/componentRules.ts
+var COMPONENT_RULES_V2 = "component-rules/v2";
+var gitCoverage = () => 1;
+function harnessShare(input, counts) {
+  const synced = input.reading.harnesses.length;
+  if (synced === 0) return 0;
+  return counts(input) / synced;
+}
+function topShare(entries) {
+  const total = entries.reduce((sum, entry) => sum + entry.value, 0);
+  if (total <= 0) return void 0;
+  const top = Math.max(...entries.map((entry) => entry.value));
+  return top / total;
+}
+var COMPONENT_RULES = [
+  {
+    id: "activity-heatmap",
+    version: COMPONENT_RULES_V2,
+    label: "of events fall in the three busiest hours of the day",
+    unit: "share",
+    // Three of twenty-four hours is an eighth of the clock. A day spread evenly
+    // lands near it; a night owl runs far above it.
+    band: { low: 0.125, high: 0.35 },
+    evaluate: ({ reading }) => {
+      const byHour = /* @__PURE__ */ new Map();
+      for (const harness of reading.harnesses) {
+        for (const cell of harness.activity) {
+          byHour.set(
+            cell.hourUtc,
+            (byHour.get(cell.hourUtc) ?? 0) + cell.events
+          );
+        }
+      }
+      const total = [...byHour.values()].reduce((sum, n) => sum + n, 0);
+      if (total <= 0) return void 0;
+      const busiest = [...byHour.values()].sort((a, b) => b - a).slice(0, 3);
+      return busiest.reduce((sum, n) => sum + n, 0) / total;
+    },
+    coverage: (input) => harnessShare(
+      input,
+      ({ reading }) => reading.harnesses.filter((harness) => harness.activity.length > 0).length
+    )
+  },
+  {
+    id: "start-hours",
+    version: COMPONENT_RULES_V2,
+    label: "is the most common start hour",
+    unit: "hour",
+    // A band on a clock face means little; the row is never ranked, and the
+    // figure is a position rather than a size. Kept for shape.
+    band: { low: 9, high: 18 },
+    evaluate: ({ reading }) => modalStartHour(reading),
+    coverage: (input) => harnessShare(
+      input,
+      ({ reading }) => reading.harnesses.filter((harness) => harness.startHours.length > 0).length
+    )
+  },
+  {
+    id: "phase-playbook",
+    version: COMPONENT_RULES_V2,
+    label: "median measured session",
+    unit: "minutes",
+    band: { low: 10, high: 60 },
+    evaluate: ({ reading }) => {
+      const bucket = medianBucket(
+        playbookHarnesses(reading).flatMap(
+          (harness) => (harness.phase?.lengths ?? []).map((row) => ({
+            bucket: row.bucket,
+            count: row.sessions
+          }))
+        )
+      );
+      return bucket === void 0 ? void 0 : bucketMid(bucket);
+    },
+    coverage: (input) => harnessShare(input, ({ reading }) => playbookHarnesses(reading).length)
+  },
+  {
+    id: "git-ledger",
+    version: COMPONENT_RULES_V2,
+    label: "of changed lines are removals",
+    unit: "share",
+    // Most work adds more than it takes away. A ledger that removes as much as
+    // it adds is the surprising one, and so is one that never removes.
+    band: { low: 0.15, high: 0.35 },
+    evaluate: ({ reading }) => {
+      const changed = reading.git.additions + reading.git.removals;
+      return changed > 0 ? reading.git.removals / changed : void 0;
+    },
+    coverage: gitCoverage
+  },
+  {
+    id: "coding-languages",
+    version: COMPONENT_RULES_V2,
+    label: "of changed lines are one file type",
+    unit: "share",
+    band: { low: 0.35, high: 0.7 },
+    evaluate: ({ reading }) => {
+      const named = reading.git.changedLinesByExtension.map((row) => ({
+        value: row.changedLines
+      }));
+      const total = named.reduce((sum, row) => sum + row.value, 0) + reading.git.withheldExtensionLines;
+      if (total <= 0 || named.length === 0) return void 0;
+      return Math.max(...named.map((row) => row.value)) / total;
+    },
+    coverage: gitCoverage
+  },
+  {
+    id: "kit",
+    version: COMPONENT_RULES_V2,
+    label: "of skill and MCP calls go to one artifact",
+    unit: "share",
+    band: { low: 0.15, high: 0.4 },
+    evaluate: ({ kit }) => {
+      if (!kit) return void 0;
+      const byName = /* @__PURE__ */ new Map();
+      for (const harness of kit) {
+        for (const atom of [...harness.skills, ...harness.mcpServers]) {
+          byName.set(atom.name, (byName.get(atom.name) ?? 0) + atom.callShare);
+        }
+      }
+      return topShare([...byName.values()].map((share) => ({ value: share })));
+    },
+    coverage: (input) => harnessShare(
+      input,
+      ({ kit }) => (kit ?? []).filter(
+        (harness) => harness.skills.length > 0 || harness.mcpServers.length > 0
+      ).length
+    )
+  },
+  {
+    id: "model-routing",
+    version: COMPONENT_RULES_V2,
+    label: "of main-loop tokens run on one model",
+    unit: "share",
+    band: { low: 0.4, high: 0.85 },
+    evaluate: ({ reading }) => {
+      const main = reading.harnesses.flatMap((harness) => [
+        ...harness.routing?.main ?? []
+      ]);
+      const byModel = /* @__PURE__ */ new Map();
+      for (const row of main) {
+        byModel.set(row.model, (byModel.get(row.model) ?? 0) + row.tokens);
+      }
+      return topShare(
+        [...byModel.values()].map((tokens) => ({ value: tokens }))
+      );
+    },
+    coverage: (input) => harnessShare(
+      input,
+      ({ reading }) => reading.harnesses.filter((harness) => harness.routing).length
+    )
+  },
+  {
+    id: "delegation",
+    version: COMPONENT_RULES_V2,
+    label: "of tool calls run inside a subagent",
+    unit: "share",
+    band: { low: 0, high: 0.3 },
+    evaluate: ({ reading }) => {
+      let main = 0;
+      let subagents = 0;
+      for (const harness of reading.harnesses) {
+        main += harness.delegation?.mainToolCalls ?? 0;
+        subagents += harness.delegation?.subagentToolCalls ?? 0;
+      }
+      const total = main + subagents;
+      return total > 0 ? subagents / total : void 0;
+    },
+    coverage: (input) => harnessShare(
+      input,
+      ({ reading }) => reading.harnesses.filter((harness) => harness.delegation).length
+    )
+  }
+];
+
+// ../workflow-rules/src/metricRules.ts
+var METRIC_RULES_V2 = "metric-rules/v2";
 var METRIC_RULES = [
   {
     id: "late-night-commits",
-    version: METRIC_RULES_V1,
+    version: METRIC_RULES_V2,
     label: "of commits land between 23:00 and 03:00",
     kind: "exact",
     unit: "share",
-    harnessSupport: "all",
-    // Most commit activity clusters in daytime hours; a wide late-night
-    // share is the surprising case this metric exists to surface.
+    counts: "all",
     band: { low: 0, high: 0.15 },
-    evaluate: (facts) => {
-      const git = facts.git;
-      if (!git || git.totalCommits === 0) return void 0;
-      return git.lateNightCommits / git.totalCommits;
+    evaluate: (reading) => {
+      const git = reading.git;
+      if (git.commits === 0) return void 0;
+      return git.lateNightCommits / git.commits;
     }
   },
   {
     id: "parallel-projects",
-    version: METRIC_RULES_V1,
+    version: METRIC_RULES_V2,
     label: "projects run in parallel on a median active day",
     kind: "proxy",
     unit: "count",
-    harnessSupport: "all",
+    counts: "all",
     band: { low: 1, high: 1.5 },
-    evaluate: (facts) => {
-      const days = facts.activeDays;
-      if (!days || days.length === 0) return void 0;
-      return median(days.map((d) => d.parallelProjectCount));
-    }
-  },
-  {
-    id: "model-switches-mid-run",
-    version: METRIC_RULES_V1,
-    label: "of sessions switch model mid-run",
-    kind: "exact",
-    unit: "share",
-    harnessSupport: "all",
-    band: { low: 0, high: 0.1 },
-    evaluate: (facts) => shareOf(
-      facts.sessions?.filter(
-        (session) => session.modelSwitched !== void 0
-      ),
-      (session) => session.modelSwitched === true
-    )
+    evaluate: (reading) => median(reading.parallelProjectDays)
   },
   {
     id: "thinking-share",
-    version: METRIC_RULES_V1,
+    version: METRIC_RULES_V2,
     label: "of response tokens are thinking",
     kind: "proxy",
     unit: "share",
-    harnessSupport: ["codex", "opencode", "pi-mono"],
+    counts: (harness) => harness.thinking !== void 0,
     band: { low: 0.1, high: 0.3 },
-    evaluate: (facts) => {
-      const sessions = facts.sessions?.filter(
-        (session) => session.harness !== "claude-code" && session.thinkingTokens !== void 0 && session.responseTokens !== void 0
-      );
-      if (!sessions || sessions.length === 0) return void 0;
+    evaluate: (reading) => {
       let thinking = 0;
       let response = 0;
-      for (const s of sessions) {
-        thinking += s.thinkingTokens ?? 0;
-        response += s.responseTokens ?? 0;
+      for (const harness of reading.harnesses) {
+        thinking += harness.thinking?.thinkingTokens ?? 0;
+        response += harness.thinking?.responseTokens ?? 0;
       }
       return response > 0 ? thinking / response : void 0;
     }
   },
   {
-    id: "high-effort-turns",
-    version: METRIC_RULES_V1,
+    id: "effort-levels",
+    version: METRIC_RULES_V2,
     label: "of turns run at high effort",
     kind: "exact",
     unit: "share",
-    // Only Claude Code and Codex record an effort field (#196 research).
-    harnessSupport: ["claude-code", "codex"],
+    counts: (harness) => harness.effort !== void 0,
     band: { low: 0.2, high: 0.5 },
-    evaluate: (facts) => {
-      const sessions = facts.sessions?.filter((s) => s.effortTurns);
-      if (!sessions || sessions.length === 0) return void 0;
+    evaluate: (reading) => {
       let high = 0;
       let total = 0;
-      for (const s of sessions) {
-        high += s.effortTurns?.high ?? 0;
-        total += s.effortTurns?.total ?? 0;
+      for (const harness of reading.harnesses) {
+        for (const row of harness.effort ?? []) {
+          total += row.turns;
+          if (row.level === "high") high += row.turns;
+        }
       }
       return total > 0 ? high / total : void 0;
     }
   },
   {
-    id: "effort-changes-mid-run",
-    version: METRIC_RULES_V1,
-    label: "of sessions change effort mid-run",
-    kind: "exact",
-    unit: "share",
-    harnessSupport: ["claude-code", "codex"],
-    band: { low: 0, high: 0.1 },
-    evaluate: (facts) => shareOf(
-      facts.sessions?.filter((s) => s.effortTurns),
-      (s) => s.effortChangedMidRun === true
-    )
-  },
-  {
-    id: "longest-turn-duration",
-    version: METRIC_RULES_V1,
-    label: "longest recorded turn duration",
+    id: "turn-duration",
+    version: METRIC_RULES_V2,
+    label: "median turn duration",
     kind: "exact",
     unit: "minutes",
-    // Only Claude Code and opencode record per-turn duration (#196 research).
-    harnessSupport: ["claude-code", "opencode"],
-    band: { low: 5, high: 15 },
-    evaluate: (facts) => {
-      const durations = (facts.sessions ?? []).map((s) => s.longestTurnDurationSec).filter((v) => v !== void 0);
-      if (durations.length === 0) return void 0;
-      return Math.max(...durations) / 60;
+    counts: (harness) => harness.turnDurations !== void 0,
+    band: { low: 0.25, high: 2 },
+    evaluate: (reading) => {
+      const bucket = medianBucket(
+        reading.harnesses.flatMap(
+          (harness) => (harness.turnDurations?.buckets ?? []).map((row) => ({
+            bucket: row.bucket,
+            count: row.turns
+          }))
+        )
+      );
+      return bucket === void 0 ? void 0 : bucketMid(bucket) / 60;
     }
   },
   {
     id: "question-back-share",
-    version: METRIC_RULES_V1,
+    version: METRIC_RULES_V2,
     label: "of turns end with a question back to the human",
     kind: "proxy",
     unit: "share",
-    harnessSupport: ["claude-code", "codex", "opencode"],
+    counts: (harness) => harness.questions !== void 0,
     band: { low: 0, high: 0.15 },
-    evaluate: (facts) => {
-      const sessions = facts.sessions?.filter(
-        (session) => session.questionBackTurns !== void 0 && session.totalTurns !== void 0
-      );
-      if (!sessions || sessions.length === 0) return void 0;
+    evaluate: (reading) => {
       let asked = 0;
       let turns = 0;
-      for (const s of sessions) {
-        asked += s.questionBackTurns ?? 0;
-        turns += s.totalTurns ?? 0;
+      for (const harness of reading.harnesses) {
+        asked += harness.questions?.asked ?? 0;
+        turns += harness.questions?.turns ?? 0;
       }
       return turns > 0 ? asked / turns : void 0;
     }
   },
   {
     id: "web-searches-per-active-day",
-    version: METRIC_RULES_V1,
+    version: METRIC_RULES_V2,
     label: "web searches per active day, inside the harness",
     kind: "proxy",
     unit: "count",
-    harnessSupport: ["claude-code", "codex", "opencode"],
+    counts: (harness) => harness.webSearches !== void 0,
     band: { low: 0, high: 4 },
-    evaluate: (facts) => {
-      const days = facts.activeDays?.filter(
-        (day) => day.webSearches !== void 0
+    evaluate: (reading) => {
+      if (reading.webSearchDays === 0) return void 0;
+      const total = reading.harnesses.reduce(
+        (sum, harness) => sum + (harness.webSearches ?? 0),
+        0
       );
-      if (!days || days.length === 0) return void 0;
-      const total = days.reduce((sum, d) => sum + (d.webSearches ?? 0), 0);
-      return total / days.length;
+      return total / reading.webSearchDays;
     }
   }
 ];
 
 // ../workflow-rules/src/types.ts
-function harnessLabel(name) {
-  switch (name) {
-    case "claude-code":
-      return "Claude Code";
-    case "codex":
-      return "Codex";
-    case "opencode":
-      return "opencode";
-    case "pi-mono":
-      return "Pi";
-  }
-}
 var PHASES = [
   "scout",
   "build",
@@ -2327,39 +2763,6 @@ var PHASES = [
   "unknown"
 ];
 
-// ../workflow-rules/src/fit.ts
-function coverageFor(harnessSupport, syncedHarnesses) {
-  if (harnessSupport === "all") return 1;
-  if (syncedHarnesses.length === 0) return 0;
-  const supported = new Set(harnessSupport);
-  const counted = syncedHarnesses.filter((h) => supported.has(h));
-  return counted.length / syncedHarnesses.length;
-}
-function coverageTag(harnessSupport, syncedHarnesses) {
-  if (harnessSupport === "all") return void 0;
-  const supported = new Set(harnessSupport);
-  const counted = syncedHarnesses.filter((h) => supported.has(h));
-  if (counted.length === 0 || counted.length === syncedHarnesses.length)
-    return void 0;
-  return `counts: ${counted.map(harnessLabel).join(" \xB7 ")}`;
-}
-function buildFitInputs(facts, syncedHarnesses) {
-  const rows = [];
-  for (const rule of METRIC_RULES) {
-    const value = rule.evaluate(facts);
-    if (value === void 0) continue;
-    rows.push({
-      metricId: rule.id,
-      ruleVersion: rule.version,
-      value,
-      band: rule.band,
-      coverage: coverageFor(rule.harnessSupport, syncedHarnesses),
-      coverageTag: coverageTag(rule.harnessSupport, syncedHarnesses)
-    });
-  }
-  return rows;
-}
-
 // ../workflow-rules/src/phaseRules.ts
 var PHASE_RULES_V1 = "phase-rules/v1";
 var UNKNOWN_GATE = 0.2;
@@ -2778,8 +3181,49 @@ function deriveSessionPhases(events, ruleSet = PHASE_RULES_V1, harness) {
   };
 }
 
-// ../workflow-rules/src/playbook.ts
-var MIN_PER_SEC = 1 / 60;
+// ../workflow-rules/src/workflowRows.ts
+function metricRowId(metricId) {
+  return `metric:${metricId}`;
+}
+function componentRowId(componentId) {
+  return `component:${componentId}`;
+}
+var WORKFLOW_ROW_ORDER = [
+  {
+    rowId: "component:activity-heatmap",
+    name: "When work happens",
+    flat: false
+  },
+  { rowId: "component:start-hours", name: "Session start times", flat: false },
+  {
+    rowId: "metric:late-night-commits",
+    name: "Late-night commits",
+    flat: true
+  },
+  { rowId: "component:phase-playbook", name: "Session length", flat: false },
+  { rowId: "component:git-ledger", name: "Lines changed", flat: false },
+  { rowId: "component:coding-languages", name: "Languages", flat: false },
+  { rowId: "component:kit", name: "Skills and MCP", flat: false },
+  { rowId: "component:model-routing", name: "Models used", flat: false },
+  { rowId: "component:delegation", name: "Subagents", flat: false },
+  { rowId: "metric:effort-levels", name: "Effort levels", flat: false },
+  { rowId: "metric:thinking-share", name: "Thinking tokens", flat: false },
+  { rowId: "metric:turn-duration", name: "Turn length", flat: false },
+  { rowId: "metric:question-back-share", name: "Questions asked", flat: true },
+  {
+    rowId: "metric:web-searches-per-active-day",
+    name: "Web searches",
+    flat: true
+  },
+  { rowId: "metric:parallel-projects", name: "Parallel projects", flat: true }
+];
+var ORDER_INDEX = new Map(
+  WORKFLOW_ROW_ORDER.map((row, index) => [row.rowId, index])
+);
+var KNOWN_ROW_IDS = /* @__PURE__ */ new Set([
+  ...METRIC_RULES.map((rule) => metricRowId(rule.id)),
+  ...COMPONENT_RULES.map((rule) => componentRowId(rule.id))
+]);
 
 // src/harness/shared/window.ts
 var DEFAULT_WINDOW_DAYS = 30;
@@ -3040,19 +3484,8 @@ function buildPayload(input) {
 function toPayloadWorkflow(extraction) {
   return {
     aggregateVersion: extraction.aggregateVersion,
-    harnesses: extraction.harnesses.map(
-      ({ facts: _local, aggregateVersion: _stamped, ...rest }) => rest
-    ),
-    git: extraction.git,
-    metrics: extraction.metricInputs.map((row) => ({
-      metricId: row.metricId,
-      ruleVersion: row.ruleVersion,
-      value: row.value,
-      band: row.band,
-      coverage: row.coverage,
-      ...row.coverageTag === void 0 ? {} : { coverageTag: row.coverageTag }
-    })),
-    utcOffsetMinutes: extraction.utcOffsetMinutes
+    utcOffsetMinutes: extraction.utcOffsetMinutes,
+    days: extraction.days
   };
 }
 function mergeKeptPrivate(halves) {
@@ -3085,7 +3518,7 @@ function buildSyncBody(built, syncConfig, autoSync, trigger = "manual", workflow
 }
 
 // src/workflow/reducer.ts
-var WORKFLOW_AGGREGATE_VERSION = "workflow-aggregates/v1";
+var WORKFLOW_AGGREGATE_VERSION = WORKFLOW_AGGREGATES_V2;
 function createWorkflowLocalSources() {
   return { projectWorkspaces: /* @__PURE__ */ new Set(), activeProjectDays: /* @__PURE__ */ new Map() };
 }
@@ -3097,10 +3530,10 @@ var emptyPhase = () => ({
   unknown: 0
 });
 var finiteNonnegative = (value) => value !== void 0 && Number.isFinite(value) && value > 0 ? value : 0;
-var isHighEffort = (effort) => ["high", "xhigh", "max", "ultra"].includes(effort.toLowerCase());
 var bump2 = (map, key, amount = 1) => {
   map.set(key, (map.get(key) ?? 0) + amount);
 };
+var utcDateOf = (ms) => new Date(ms).toISOString().slice(0, 10);
 var PHASE_RANK = {
   verify: 4,
   handoff: 3,
@@ -3145,18 +3578,9 @@ function reduceEventBatches(recorded, harness) {
   }
   return output;
 }
-var verifyRuns = (events, harness) => {
-  const phases = events.map(
-    (event) => deriveSessionPhases([event], PHASE_RULES_V1, harness).phaseEvents.verify > 0 ? "verify" : "other"
-  );
-  let runs = 0;
-  let inside = false;
-  for (const phase of phases) {
-    if (phase === "verify" && !inside) runs++;
-    inside = phase === "verify";
-  }
-  return runs;
-};
+var hasVerifyRun = (events, harness) => events.some(
+  (event) => deriveSessionPhases([event], PHASE_RULES_V1, harness).phaseEvents.verify > 0
+);
 function shellIncludes(arg, head) {
   return arg.split(/(?:&&|\|\||;|\|)/).some((part) => part.trim() === head || part.trim().startsWith(`${head} `));
 }
@@ -3174,10 +3598,47 @@ function sessionState() {
     lastTs: void 0
   };
 }
+function dayState() {
+  return {
+    sessions: 0,
+    startHours: /* @__PURE__ */ new Map(),
+    phase: {
+      sessions: 0,
+      phaseSec: emptyPhase(),
+      phaseEvents: emptyPhase(),
+      waitingSec: 0,
+      idleSec: 0,
+      sessionsWithVerify: 0,
+      sessionsWithHandoff: 0,
+      lengths: /* @__PURE__ */ new Map()
+    },
+    routing: { main: /* @__PURE__ */ new Map(), subagents: /* @__PURE__ */ new Map() },
+    hasRouting: false,
+    delegation: {
+      mainToolCalls: 0,
+      subagentToolCalls: 0,
+      widestFanOut: 0,
+      mostSubagents: 0
+    },
+    hasDelegation: false,
+    activity: /* @__PURE__ */ new Map(),
+    effort: /* @__PURE__ */ new Map(),
+    hasEffort: false,
+    thinking: { thinkingTokens: 0, responseTokens: 0 },
+    hasThinking: false,
+    turnDurations: /* @__PURE__ */ new Map(),
+    hasDurations: false,
+    questions: { asked: 0, turns: 0 },
+    hasQuestions: false,
+    webSearches: 0,
+    hasWebSearches: false
+  };
+}
 function createHarnessWorkflowReducer(harness, localSources = createWorkflowLocalSources()) {
   const sessions = /* @__PURE__ */ new Map();
-  const activity = /* @__PURE__ */ new Map();
+  const eventCells = /* @__PURE__ */ new Map();
   const webSearchesByDate = /* @__PURE__ */ new Map();
+  const eventDates = /* @__PURE__ */ new Set();
   let finished;
   const getSession = (key) => {
     let state = sessions.get(key);
@@ -3197,7 +3658,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
       state.parentSession ??= observation.parentSession;
       state.sidechain ||= observation.sidechain === true;
       const at = new Date(observation.tsMs);
-      const date = at.toISOString().slice(0, 10);
+      const date = utcDateOf(observation.tsMs);
       if (observation.projectWorkspace) {
         state.projectWorkspaces.add(observation.projectWorkspace);
         localSources.projectWorkspaces.add(observation.projectWorkspace);
@@ -3208,7 +3669,10 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
           event: [observation.tsMs, observation.tool, arg],
           ...observation.batchId ? { batchId: observation.batchId } : {}
         });
-        bump2(activity, `${at.getUTCDay()}:${at.getUTCHours()}`);
+        eventDates.add(date);
+        const cells = eventCells.get(date) ?? /* @__PURE__ */ new Map();
+        bump2(cells, `${at.getUTCDay()}:${at.getUTCHours()}`);
+        eventCells.set(date, cells);
         if (["WebSearch", "web_search", "websearch"].includes(observation.tool))
           bump2(webSearchesByDate, date);
       } else if (observation.type === "response") {
@@ -3234,135 +3698,118 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
     },
     finish() {
       if (finished) return finished;
-      const phaseSec = emptyPhase();
-      const phaseEvents = emptyPhase();
-      const sessionRows2 = [];
-      const facts = [];
-      const modelTokens = {
-        main: /* @__PURE__ */ new Map(),
-        subagents: /* @__PURE__ */ new Map()
+      const days = /* @__PURE__ */ new Map();
+      const dayOf = (date) => {
+        let state = days.get(date);
+        if (!state) {
+          state = dayState();
+          days.set(date, state);
+        }
+        return state;
       };
-      let waitingSec = 0;
-      let idleSec = 0;
-      let mainToolCalls = 0;
-      let subagentToolCalls = 0;
+      const windowPhaseSec = emptyPhase();
       let phaseSessionCount = 0;
       for (const state of sessions.values()) {
+        if (state.firstTs === void 0) continue;
+        const day = dayOf(utcDateOf(state.firstTs));
         const events = reduceEventBatches(state.events, harness);
         const responses = [...state.responses.values()];
-        const efforts = responses.flatMap(
-          (response) => response.effort ? [response.effort] : []
-        );
-        const models = new Set(
-          responses.flatMap(
-            (response) => response.model ? [response.model] : []
-          )
-        );
-        const thinkingResponses = responses.filter(
-          (response) => response.thinkingTokens !== void 0
-        );
-        const outputResponses = responses.filter(
-          (response) => response.responseTokens !== void 0
+        day.sessions++;
+        const startHour = new Date(state.firstTs).getUTCHours();
+        day.startHours.set(startHour, (day.startHours.get(startHour) ?? 0) + 1);
+        const phases = deriveSessionPhases(events, PHASE_RULES_V1, harness);
+        if (state.events.length > 0) phaseSessionCount++;
+        day.phase.sessions++;
+        for (const phase of PHASES) {
+          day.phase.phaseSec[phase] += phases.phaseSec[phase];
+          day.phase.phaseEvents[phase] += phases.phaseEvents[phase];
+          windowPhaseSec[phase] += phases.phaseSec[phase];
+        }
+        day.phase.waitingSec += phases.waitingSec;
+        day.phase.idleSec += phases.idleSec;
+        if (phases.phaseEvents.verify > 0) day.phase.sessionsWithVerify++;
+        if (phases.phaseEvents.handoff > 0) day.phase.sessionsWithHandoff++;
+        const measuredSec = PHASES.reduce(
+          (sum, phase) => sum + phases.phaseSec[phase],
+          0
         );
-        const durations = responses.flatMap(
-          (response) => response.durationSec === void 0 ? [] : [response.durationSec]
+        const bucket = logBucket(measuredSec / 60);
+        const merged = events.some(
+          ([, tool, arg]) => ["Bash", "bash", "shell", "local_shell", "exec_command"].includes(
+            tool
+          ) && shellIncludes(arg, "gh pr merge")
         );
-        const sessionFact = {
-          harness,
-          ...models.size > 0 ? { modelSwitched: models.size > 1 } : {},
-          ...thinkingResponses.length > 0 ? {
-            thinkingTokens: thinkingResponses.reduce(
-              (sum, response) => sum + (response.thinkingTokens ?? 0),
-              0
-            )
-          } : {},
-          ...outputResponses.length > 0 ? {
-            responseTokens: outputResponses.reduce(
-              (sum, response) => sum + (response.responseTokens ?? 0),
-              0
-            )
-          } : {},
-          ...harness === "pi-mono" ? {} : {
-            questionBackTurns: [...state.turns.values()].filter(Boolean).length,
-            totalTurns: state.turns.size
-          }
+        const verified = hasVerifyRun(events, harness);
+        const openedWithScout = (events[0] ? deriveSessionPhases([events[0]], PHASE_RULES_V1, harness).phaseEvents.scout : 0) > 0;
+        const length = day.phase.lengths.get(bucket) ?? {
+          bucket,
+          sessions: 0,
+          phaseSec: emptyPhase(),
+          merged: 0,
+          verified: 0,
+          mergedVerified: 0,
+          openedWithScout: 0
         };
-        if (efforts.length > 0) {
-          sessionFact.effortTurns = {
-            high: efforts.filter(isHighEffort).length,
-            total: efforts.length
-          };
-          sessionFact.effortChangedMidRun = new Set(efforts).size > 1;
-        }
-        if (durations.length > 0)
-          sessionFact.longestTurnDurationSec = Math.max(...durations);
-        facts.push(sessionFact);
+        length.sessions++;
+        for (const phase of PHASES)
+          length.phaseSec[phase] += phases.phaseSec[phase];
+        if (merged) length.merged++;
+        if (verified) length.verified++;
+        if (merged && verified) length.mergedVerified++;
+        if (openedWithScout) length.openedWithScout++;
+        day.phase.lengths.set(bucket, length);
         const routing = state.sidechain || state.parentSession ? "subagents" : "main";
         for (const response of responses) {
           if (!response.model) continue;
+          day.hasRouting = true;
           bump2(
-            modelTokens[routing],
+            day.routing[routing],
             response.model,
             response.routingTokens ?? response.responseTokens ?? 0
           );
         }
-        if (routing === "subagents") subagentToolCalls += state.events.length;
-        else mainToolCalls += state.events.length;
-        if (state.events.length > 0) phaseSessionCount++;
-        const phases = deriveSessionPhases(events, PHASE_RULES_V1, harness);
-        for (const phase of PHASES) {
-          phaseSec[phase] += phases.phaseSec[phase];
-          phaseEvents[phase] += phases.phaseEvents[phase];
+        if (routing === "subagents") {
+          day.delegation.subagentToolCalls += state.events.length;
+          day.hasDelegation ||= state.events.length > 0;
+        } else day.delegation.mainToolCalls += state.events.length;
+        for (const response of responses) {
+          if (response.effort) {
+            day.hasEffort = true;
+            const level = effortLevelOf(response.effort);
+            day.effort.set(level, (day.effort.get(level) ?? 0) + 1);
+          }
+          if (response.thinkingTokens !== void 0) {
+            day.hasThinking = true;
+            day.thinking.thinkingTokens += response.thinkingTokens;
+            day.thinking.responseTokens += response.responseTokens ?? 0;
+          }
+          if (response.durationSec !== void 0) {
+            day.hasDurations = true;
+            const durationBucket = logBucket(response.durationSec);
+            day.turnDurations.set(
+              durationBucket,
+              (day.turnDurations.get(durationBucket) ?? 0) + 1
+            );
+          }
+        }
+        if (harness !== "pi-mono") {
+          day.hasQuestions = true;
+          day.questions.turns += state.turns.size;
+          day.questions.asked += [...state.turns.values()].filter(
+            Boolean
+          ).length;
         }
-        waitingSec += phases.waitingSec;
-        idleSec += phases.idleSec;
-        const first = state.firstTs;
-        const classifications = events.map(
-          (event) => deriveSessionPhases([event], PHASE_RULES_V1, harness)
-        );
-        sessionRows2.push({
-          startHourUtc: first === void 0 ? 0 : new Date(first).getUTCHours(),
-          eventCount: events.length,
-          phaseSec: phases.phaseSec,
-          phaseEvents: phases.phaseEvents,
-          waitingSec: phases.waitingSec,
-          idleSec: phases.idleSec,
-          merged: events.some(
-            ([, tool, arg]) => ["Bash", "bash", "shell", "local_shell", "exec_command"].includes(
-              tool
-            ) && shellIncludes(arg, "gh pr merge")
-          ),
-          verifyRuns: verifyRuns(events, harness),
-          reviewRounds: events.filter(
-            ([, tool]) => ["mcp__curia__request_review", "request_review"].includes(tool)
-          ).length,
-          openedWithScout: (classifications[0]?.phaseEvents.scout ?? 0) > 0
-        });
       }
-      const attributed = PHASES.reduce(
-        (sum, phase) => sum + phaseSec[phase],
-        0
-      );
-      const unknown = attributed === 0 ? 0 : phaseSec.unknown / attributed;
-      localSources.activeProjectDays.clear();
-      for (const state of sessions.values()) {
-        if (state.firstTs === void 0 || state.lastTs === void 0) continue;
-        let day = Date.parse(
-          `${new Date(state.firstTs).toISOString().slice(0, 10)}T00:00:00Z`
-        );
-        const lastDay = Date.parse(
-          `${new Date(state.lastTs).toISOString().slice(0, 10)}T00:00:00Z`
-        );
-        while (day <= lastDay) {
-          const date = new Date(day).toISOString().slice(0, 10);
-          const projects = localSources.activeProjectDays.get(date) ?? /* @__PURE__ */ new Set();
-          for (const project of state.projectWorkspaces) projects.add(project);
-          if (projects.size > 0)
-            localSources.activeProjectDays.set(date, projects);
-          day += 864e5;
+      for (const date of eventDates) {
+        const day = dayOf(date);
+        for (const [key, events] of eventCells.get(date) ?? []) {
+          bump2(day.activity, key, events);
+        }
+        if (harness !== "pi-mono") {
+          day.hasWebSearches = true;
+          day.webSearches = webSearchesByDate.get(date) ?? 0;
         }
       }
-      const projectsByDate = localSources.activeProjectDays;
       const childrenByParent = /* @__PURE__ */ new Map();
       for (const state of sessions.values()) {
         if (!state.parentSession) continue;
@@ -3370,10 +3817,16 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
         children.push(state);
         childrenByParent.set(state.parentSession, children);
       }
-      let widestFanOut = 0;
-      let mostSubagents = 0;
-      for (const children of childrenByParent.values()) {
-        mostSubagents = Math.max(mostSubagents, children.length);
+      for (const [parentKey, children] of childrenByParent) {
+        const parent = sessions.get(parentKey);
+        const anchor = parent?.firstTs ?? Math.min(...children.map((child) => child.firstTs ?? Infinity));
+        if (!Number.isFinite(anchor)) continue;
+        const day = dayOf(utcDateOf(anchor));
+        day.hasDelegation = true;
+        day.delegation.mostSubagents = Math.max(
+          day.delegation.mostSubagents,
+          children.length
+        );
         const boundaries = children.flatMap((child) => [
           { ts: child.firstTs ?? 0, delta: 1 },
           { ts: child.lastTs ?? child.firstTs ?? 0, delta: -1 }
@@ -3382,61 +3835,109 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
         let active = 0;
         for (const boundary of boundaries) {
           active += boundary.delta;
-          widestFanOut = Math.max(widestFanOut, active);
+          day.delegation.widestFanOut = Math.max(
+            day.delegation.widestFanOut,
+            active
+          );
         }
       }
+      localSources.activeProjectDays.clear();
+      for (const state of sessions.values()) {
+        if (state.firstTs === void 0 || state.lastTs === void 0) continue;
+        let day = Date.parse(`${utcDateOf(state.firstTs)}T00:00:00Z`);
+        const lastDay = Date.parse(`${utcDateOf(state.lastTs)}T00:00:00Z`);
+        while (day <= lastDay) {
+          const date = utcDateOf(day);
+          const projects = localSources.activeProjectDays.get(date) ?? /* @__PURE__ */ new Set();
+          for (const project of state.projectWorkspaces) projects.add(project);
+          if (projects.size > 0)
+            localSources.activeProjectDays.set(date, projects);
+          day += 864e5;
+        }
+      }
+      const attributed = PHASES.reduce(
+        (sum, phase) => sum + windowPhaseSec[phase],
+        0
+      );
+      const unknown = attributed === 0 ? 0 : windowPhaseSec.unknown / attributed;
+      const routesModels = harness === "claude-code" || harness === "opencode";
       const asRows = (map) => {
         const safe = /* @__PURE__ */ new Map();
         for (const [model, tokens] of map) {
           bump2(safe, sanitizeModelId(model), tokens);
         }
-        return [...safe].map(([model, tokens]) => ({ model, tokens }));
+        return [...safe].map(([model, tokens]) => ({ model, tokens })).sort(
+          (a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model)
+        );
       };
-      const hasDelegation = subagentToolCalls > 0 || mostSubagents > 0 || widestFanOut > 0;
       finished = {
         aggregateVersion: WORKFLOW_AGGREGATE_VERSION,
         harness,
-        phase: {
+        gate: {
           ruleVersion: PHASE_RULES_V1,
           publishable: phaseSessionCount > 0 && unknown <= UNKNOWN_GATE,
           sessions: sessions.size,
-          phaseSec,
-          phaseEvents,
-          waitingSec,
-          idleSec,
-          unknownShare: unknown,
-          sessionRows: sessionRows2
-        },
-        facts: {
-          sessions: facts,
-          activeDays: [...projectsByDate].sort(([a], [b]) => a.localeCompare(b)).map(([date, projects]) => ({
-            date,
-            parallelProjectCount: projects.size,
-            ...harness === "pi-mono" ? {} : { webSearches: webSearchesByDate.get(date) ?? 0 }
-          }))
+          unknownShare: unknown
         },
-        ...harness === "claude-code" || harness === "opencode" ? {
-          routing: {
-            main: asRows(modelTokens.main),
-            subagents: asRows(modelTokens.subagents)
-          }
-        } : {},
-        ...hasDelegation ? {
-          delegation: {
-            mainToolCalls,
-            subagentToolCalls,
-            widestFanOut,
-            mostSubagents
-          }
-        } : {},
-        activity: [...activity].map(([key, events]) => {
-          const [weekdayUtc, hourUtc] = key.split(":").map(Number);
-          return { weekdayUtc, hourUtc, events };
-        }).sort((a, b) => a.weekdayUtc - b.weekdayUtc || a.hourUtc - b.hourUtc)
+        days: [...days].sort(([a], [b]) => a.localeCompare(b)).map(([date, day]) => ({
+          date,
+          harness,
+          sessions: day.sessions,
+          startHours: [...day.startHours].map(([hourUtc, count]) => ({ hourUtc, sessions: count })).sort((a, b) => a.hourUtc - b.hourUtc),
+          ...day.phase.sessions > 0 ? {
+            phase: {
+              ruleVersion: PHASE_RULES_V1,
+              sessions: day.phase.sessions,
+              phaseSec: day.phase.phaseSec,
+              phaseEvents: day.phase.phaseEvents,
+              waitingSec: day.phase.waitingSec,
+              idleSec: day.phase.idleSec,
+              sessionsWithVerify: day.phase.sessionsWithVerify,
+              sessionsWithHandoff: day.phase.sessionsWithHandoff,
+              bucketRuleVersion: LOG_BUCKETS_V1,
+              lengths: [...day.phase.lengths.values()].sort(
+                (a, b) => a.bucket - b.bucket
+              )
+            }
+          } : {},
+          ...routesModels && day.hasRouting ? {
+            routing: {
+              main: asRows(day.routing.main),
+              subagents: asRows(day.routing.subagents)
+            }
+          } : {},
+          ...day.hasDelegation ? { delegation: day.delegation } : {},
+          activity: [...day.activity].map(([key, events]) => {
+            const [weekdayUtc, hourUtc] = key.split(":").map(Number);
+            return {
+              weekdayUtc: weekdayUtc ?? 0,
+              hourUtc: hourUtc ?? 0,
+              events
+            };
+          }).sort(
+            (a, b) => a.weekdayUtc - b.weekdayUtc || a.hourUtc - b.hourUtc
+          ),
+          ...day.hasEffort ? {
+            effort: EFFORT_LEVELS.flatMap((level) => {
+              const turns = day.effort.get(level) ?? 0;
+              return turns > 0 ? [{ level, turns }] : [];
+            })
+          } : {},
+          ...day.hasThinking ? { thinking: day.thinking } : {},
+          ...day.hasDurations ? {
+            turnDurations: {
+              bucketRuleVersion: LOG_BUCKETS_V1,
+              buckets: [...day.turnDurations].map(([bucket, turns]) => ({ bucket, turns })).sort((a, b) => a.bucket - b.bucket)
+            }
+          } : {},
+          ...day.hasQuestions ? { questions: day.questions } : {},
+          ...day.hasWebSearches ? { webSearches: day.webSearches } : {}
+        }))
       };
       sessions.clear();
-      activity.clear();
+      eventCells.clear();
       webSearchesByDate.clear();
+      eventDates.clear();
       return finished;
     }
   };
@@ -5962,11 +6463,11 @@ var defaultRunner = (cwd, args) => {
     return null;
   }
 };
-var emptyResult = () => ({
+var emptyGitDay = () => ({
   testFileRuleVersion: TEST_FILE_RULE_VERSION,
   fileTypeRuleVersion: FILE_TYPE_RULE_VERSION,
   commitSetRuleVersion: COMMIT_SET_RULE_VERSION,
-  totalCommits: 0,
+  commits: 0,
   lateNightCommits: 0,
   additions: 0,
   removals: 0,
@@ -6116,9 +6617,25 @@ function extractGitWorkflow(options) {
     const root = run(directory, ["rev-parse", "--show-toplevel"])?.trim();
     if (root) roots.add(root);
   }
-  const result = emptyResult();
-  const extensionLines = /* @__PURE__ */ new Map();
-  const cells = /* @__PURE__ */ new Map();
+  const days = /* @__PURE__ */ new Map();
+  const dayOf = (date) => {
+    let day = days.get(date);
+    if (!day) {
+      const {
+        changedLinesByExtension: _extensions,
+        weekdayHourCells: _cells,
+        ...rest
+      } = emptyGitDay();
+      day = {
+        ...rest,
+        changedLinesPerCommit: [],
+        extensionLines: /* @__PURE__ */ new Map(),
+        cells: /* @__PURE__ */ new Map()
+      };
+      days.set(date, day);
+    }
+    return day;
+  };
   const seenCommits = /* @__PURE__ */ new Set();
   for (const root of roots) {
     const history = run(root, [
@@ -6133,17 +6650,25 @@ function extractGitWorkflow(options) {
     let current;
     const finishCommit = () => {
       if (!current?.included || !current.authored) return;
-      result.totalCommits++;
-      result.additions += current.additions;
-      result.removals += current.removals;
-      result.changedLinesPerCommit.push(current.changedLines);
-      if (current.touchesTest) result.testFileCommits++;
+      const day = dayOf(current.date);
+      day.commits++;
+      day.additions += current.additions;
+      day.removals += current.removals;
+      day.changedLinesPerCommit.push(current.changedLines);
+      if (current.touchesTest) day.testFileCommits++;
       const { weekdayUtc, hourUtc } = current.cell;
       if (isLateNight(localHour(hourUtc, options.utcOffsetMinutes))) {
-        result.lateNightCommits++;
+        day.lateNightCommits++;
       }
       const cellKey = `${weekdayUtc}:${hourUtc}`;
-      cells.set(cellKey, (cells.get(cellKey) ?? 0) + 1);
+      day.cells.set(cellKey, (day.cells.get(cellKey) ?? 0) + 1);
+      day.withheldExtensionLines += current.withheldLines;
+      for (const [extension, lines2] of current.extensionLines) {
+        day.extensionLines.set(
+          extension,
+          (day.extensionLines.get(extension) ?? 0) + lines2
+        );
+      }
     };
     const fields = history.split("\0");
     for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex++) {
@@ -6156,12 +6681,15 @@ function extractGitWorkflow(options) {
         const included = Number.isFinite(authoredMs) && authoredMs >= options.fromMs && authoredMs <= options.toMs && !seenCommits.has(hash);
         current = {
           included,
+          date: included ? new Date(authoredMs).toISOString().slice(0, 10) : "",
           cell: utcCell(included ? authoredMs : 0),
           authored: false,
           additions: 0,
           removals: 0,
           changedLines: 0,
-          touchesTest: false
+          touchesTest: false,
+          withheldLines: 0,
+          extensionLines: /* @__PURE__ */ new Map()
         };
         if (included) seenCommits.add(hash);
         continue;
@@ -6184,20 +6712,34 @@ function extractGitWorkflow(options) {
       if (fileChangedLines <= 0) continue;
       const extension = path6.extname(file).toLowerCase();
       if (APPROVED_EXTENSIONS.has(extension)) {
-        extensionLines.set(
+        current.extensionLines.set(
           extension,
-          (extensionLines.get(extension) ?? 0) + fileChangedLines
+          (current.extensionLines.get(extension) ?? 0) + fileChangedLines
         );
-      } else result.withheldExtensionLines += fileChangedLines;
+      } else current.withheldLines += fileChangedLines;
     }
     finishCommit();
   }
-  result.changedLinesByExtension = [...extensionLines].map(([extension, changedLines]) => ({ extension, changedLines })).sort((a, b) => a.extension.localeCompare(b.extension));
-  result.weekdayHourCells = [...cells].map(([key, commits]) => {
-    const [weekdayUtc, hourUtc] = key.split(":").map(Number);
-    return { weekdayUtc: weekdayUtc ?? 0, hourUtc: hourUtc ?? 0, commits };
-  }).sort((a, b) => a.weekdayUtc - b.weekdayUtc || a.hourUtc - b.hourUtc);
-  return result;
+  return {
+    days: [...days].sort(([a], [b]) => a.localeCompare(b)).map(([date, day]) => {
+      const { extensionLines, cells, ...rest } = day;
+      return {
+        date,
+        ...rest,
+        changedLinesByExtension: [...extensionLines].map(([extension, changedLines]) => ({ extension, changedLines })).sort((a, b) => a.extension.localeCompare(b.extension)),
+        weekdayHourCells: [...cells].map(([key, commits]) => {
+          const [weekdayUtc, hourUtc] = key.split(":").map(Number);
+          return {
+            weekdayUtc: weekdayUtc ?? 0,
+            hourUtc: hourUtc ?? 0,
+            commits
+          };
+        }).sort(
+          (a, b) => a.weekdayUtc - b.weekdayUtc || a.hourUtc - b.hourUtc
+        )
+      };
+    })
+  };
 }
 
 // src/workflow/extract.ts
@@ -6218,50 +6760,44 @@ function machineUtcOffsetMinutes(now = /* @__PURE__ */ new Date()) {
   return -now.getTimezoneOffset();
 }
 function buildWorkflowExtraction(harnessWorkflows, git, utcOffsetMinutes = machineUtcOffsetMinutes()) {
+  const harnessDays = /* @__PURE__ */ new Map();
   const projectDays = /* @__PURE__ */ new Map();
-  const webSearches = /* @__PURE__ */ new Map();
-  const webSearchDays = /* @__PURE__ */ new Set();
-  const sessions = [];
-  for (const { aggregate: workflow, local } of harnessWorkflows) {
-    sessions.push(...workflow.facts.sessions);
+  for (const { aggregate, local } of harnessWorkflows) {
+    for (const { date, ...day } of aggregate.days) {
+      const rows = harnessDays.get(date) ?? [];
+      const { phase, ...safe } = day;
+      rows.push(
+        aggregate.gate.publishable && phase ? { ...safe, phase } : safe
+      );
+      harnessDays.set(date, rows);
+    }
     for (const [date, workspaces] of local.activeProjectDays) {
       const projects = projectDays.get(date) ?? /* @__PURE__ */ new Set();
       for (const project of workspaces) projects.add(project);
       projectDays.set(date, projects);
     }
-    for (const day of workflow.facts.activeDays) {
-      if (day.webSearches === void 0) continue;
-      webSearchDays.add(day.date);
-      webSearches.set(
-        day.date,
-        (webSearches.get(day.date) ?? 0) + day.webSearches
-      );
-    }
   }
-  const facts = {
-    git: {
-      totalCommits: git.totalCommits,
-      lateNightCommits: git.lateNightCommits
-    },
-    sessions,
-    activeDays: [...projectDays].sort(([a], [b]) => a.localeCompare(b)).map(([date, projects]) => ({
-      date,
-      parallelProjectCount: projects.size,
-      ...webSearchDays.has(date) ? { webSearches: webSearches.get(date) ?? 0 } : {}
-    }))
-  };
-  const syncedHarnesses = [
-    ...new Set(harnessWorkflows.map(({ aggregate }) => aggregate.harness))
-  ];
+  const gitDays = /* @__PURE__ */ new Map();
+  for (const { date, ...day } of git.days) gitDays.set(date, day);
+  const dates = [
+    .../* @__PURE__ */ new Set([
+      ...harnessDays.keys(),
+      ...gitDays.keys(),
+      ...projectDays.keys()
+    ])
+  ].sort();
   return {
-    aggregateVersion: WORKFLOW_AGGREGATE_VERSION,
-    harnesses: harnessWorkflows.map(({ aggregate }) => {
-      const { phase, ...safe } = aggregate;
-      return phase.publishable ? { ...safe, phase } : safe;
-    }),
-    git,
-    metricInputs: buildFitInputs(facts, syncedHarnesses),
-    utcOffsetMinutes
+    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    utcOffsetMinutes,
+    days: dates.map((date) => {
+      const projects = projectDays.get(date)?.size;
+      return {
+        date,
+        harnesses: harnessDays.get(date) ?? [],
+        git: gitDays.get(date) ?? emptyGitDay(),
+        ...projects === void 0 ? {} : { parallelProjects: projects }
+      };
+    })
   };
 }
 
@@ -6472,16 +7008,23 @@ var MODEL_ROLLUP = 0.01;
 var PHASE_ORDER = ["scout", "build", "verify", "handoff", "unknown"];
 function workflowBlock(workflow, host) {
   const out = [];
-  const withPlaybook = workflow.harnesses.filter((h) => h.phase);
-  const sessions = withPlaybook.reduce(
-    (a, h) => a + (h.phase?.sessions ?? 0),
-    0
-  );
+  const folded = foldWorkflowDays(workflow.days, {
+    aggregateVersion: workflow.aggregateVersion,
+    utcOffsetMinutes: workflow.utcOffsetMinutes
+  });
+  const harnesses = folded?.harnesses ?? [];
+  const withPlaybook = harnesses.filter((h) => h.phase);
+  const sessions = harnesses.reduce((a, h) => a + h.sessions, 0);
   const ruleVersions = [
     ...new Set(withPlaybook.map((h) => h.phase?.ruleVersion ?? ""))
   ].filter(Boolean);
   out.push(
-    `workflow  ${workflow.harnesses.length} harness${workflow.harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${workflow.aggregateVersion}`
+    `workflow  ${harnesses.length} harness${harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${workflow.aggregateVersion}`
+  );
+  const first = folded?.dates[0];
+  const last = folded?.dates.at(-1);
+  out.push(
+    `days      ${workflow.days.length} day${workflow.days.length === 1 ? "" : "s"}${first && last ? ` \xB7 ${first} to ${last}` : ""}`
   );
   const seconds = PHASE_ORDER.map(
     (phase) => withPlaybook.reduce((a, h) => a + (h.phase?.phaseSec[phase] ?? 0), 0)
@@ -6493,12 +7036,9 @@ function workflowBlock(workflow, host) {
     ).join(" \xB7 ");
     out.push(`          ${mix} \xB7 ${ruleVersions.join(", ")}`);
   }
-  const git = workflow.git;
-  out.push(
-    `git       ${git.totalCommits} commits \xB7 ${fmtTokens(git.additions + git.removals)} lines changed`
-  );
+  const git = folded?.git;
   out.push(
-    `metrics   ${workflow.metrics.length} measured \xB7 ${[...new Set(workflow.metrics.map((m) => m.ruleVersion))].join(", ")}`
+    `git       ${git?.commits ?? 0} commits \xB7 ${fmtTokens((git?.additions ?? 0) + (git?.removals ?? 0))} lines changed`
   );
   out.push(`          (Publish workflow is on for ${host})`);
   return out;