@use-aistack/cli 0.8.0 → 0.10.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.10.0" : "0.0.0-dev";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
@@ -122,6 +122,29 @@ async function syncPublish(token, bodyJson) {
   }
   return res.json();
 }
+async function fetchDayManifest(baseUrl, token) {
+  const res = await fetch(`${baseUrl}/api/cli/sync-manifest`, {
+    headers: { "Content-Type": "application/json", ...authHeaders(token) }
+  });
+  if (res.status === 404) return null;
+  if (res.status === 401)
+    throw new Error(
+      "Authentication expired. Run `npx @use-aistack/cli login` again."
+    );
+  if (res.status === 403 || res.status === 429)
+    throw failure("Manifest fetch failed", res);
+  if (!res.ok) {
+    throw new Error(await formatHttpError(res, "Manifest fetch failed"));
+  }
+  const body = await res.json();
+  const retentionDays = typeof body.retentionDays === "number" && body.retentionDays > 0 ? body.retentionDays : 400;
+  const aggregateVersion = typeof body.aggregateVersion === "string" ? body.aggregateVersion : "";
+  const days = Array.isArray(body.days) ? body.days.flatMap((d) => {
+    const row = d;
+    return typeof row?.date === "string" && typeof row?.fingerprint === "string" ? [{ date: row.date, fingerprint: row.fingerprint }] : [];
+  }) : [];
+  return { retentionDays, aggregateVersion, days };
+}
 async function setAutoSync(token, flag) {
   const res = await request("/api/cli/auto-sync", {
     method: "POST",
@@ -1592,6 +1615,64 @@ var asName = (v) => {
   const s = asStr(v);
   return s === null ? null : cleanName(s);
 };
+var utcDateOf = (ms) => new Date(ms).toISOString().slice(0, 10);
+function usageDayAcc(agg, tsMs) {
+  const date = utcDateOf(tsMs);
+  let day = agg.usageDays.get(date);
+  if (!day) {
+    day = {
+      models: /* @__PURE__ */ new Map(),
+      subagentTokens: 0,
+      syntheticTokens: 0,
+      projectDirs: /* @__PURE__ */ new Set()
+    };
+    agg.usageDays.set(date, day);
+  }
+  return day;
+}
+function noteUsageResponse(agg, response, sign = 1) {
+  if (response.tsMs === null) return;
+  const day = usageDayAcc(agg, response.tsMs);
+  let m = day.models.get(response.modelKey);
+  if (!m) {
+    m = {
+      counts: {
+        input: 0,
+        output: 0,
+        cacheWrite5m: 0,
+        cacheWrite1h: 0,
+        cacheWriteUnsplit: 0,
+        cacheRead: 0
+      },
+      costUSD: 0,
+      unpricedTokens: 0
+    };
+    day.models.set(response.modelKey, m);
+  }
+  const c = response.counts;
+  m.counts.input += sign * c.input;
+  m.counts.output += sign * c.output;
+  m.counts.cacheWrite5m += sign * c.cacheWrite5m;
+  m.counts.cacheWrite1h += sign * c.cacheWrite1h;
+  m.counts.cacheWriteUnsplit += sign * c.cacheWriteUnsplit;
+  m.counts.cacheRead += sign * c.cacheRead;
+  if (response.costUSD === null) m.unpricedTokens += sign * countsTotal(c);
+  else m.costUSD += sign * response.costUSD;
+  if (response.sidechain) day.subagentTokens += sign * countsTotal(c);
+}
+function noteSyntheticTokens(agg, tsMs, tokens) {
+  if (tsMs === null) return;
+  usageDayAcc(agg, tsMs).syntheticTokens += tokens;
+}
+function noteSessionStart(agg, sessionId, tsMs) {
+  if (tsMs === null) return;
+  const held = agg.sessionStarts.get(sessionId);
+  if (held === void 0 || tsMs < held) agg.sessionStarts.set(sessionId, tsMs);
+}
+function noteProjectDay(agg, directory, tsMs) {
+  if (tsMs === null) return;
+  usageDayAcc(agg, tsMs).projectDirs.add(directory);
+}
 function createAggregate() {
   return {
     files: 0,
@@ -1631,7 +1712,9 @@ function createAggregate() {
     textBlocks: 0,
     webSearchRequests: 0,
     webFetchRequests: 0,
-    seen: /* @__PURE__ */ new Map()
+    seen: /* @__PURE__ */ new Map(),
+    usageDays: /* @__PURE__ */ new Map(),
+    sessionStarts: /* @__PURE__ */ new Map()
   };
 }
 var bump = (m, k, n = 1) => m.set(k, (m.get(k) ?? 0) + n);
@@ -1649,7 +1732,16 @@ function emptyUsage() {
   };
 }
 var countsTotal = (t) => t.input + t.output + t.cacheWrite5m + t.cacheWrite1h + t.cacheWriteUnsplit + t.cacheRead;
-function addModelUsage(agg, modelKey, counts, costUSD, messages = 1) {
+function addModelUsage(agg, modelKey, counts, costUSD, messages = 1, at) {
+  if (at) {
+    noteUsageResponse(agg, {
+      tsMs: at.tsMs,
+      modelKey,
+      counts,
+      costUSD,
+      ...at.sidechain ? { sidechain: true } : {}
+    });
+  }
   let m = agg.byModel.get(modelKey);
   if (!m) {
     m = emptyUsage();
@@ -2133,192 +2225,634 @@ 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,
+    gitDays: [...days].sort((a, b) => a.date.localeCompare(b.date)).map((day) => ({
+      date: day.date,
+      additions: day.git.additions,
+      removals: day.git.removals,
+      commits: day.git.commits
+    })),
+    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 +2861,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 +3279,81 @@ function deriveSessionPhases(events, ruleSet = PHASE_RULES_V1, harness) {
   };
 }
 
-// ../workflow-rules/src/playbook.ts
-var MIN_PER_SEC = 1 / 60;
+// ../workflow-rules/src/usage.ts
+var MEASURED_DAYS_V1 = "measured-days/v1";
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function fnv1a64(text) {
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  let hash = 0xcbf29ce484222325n;
+  const bytes = new TextEncoder().encode(text);
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function dayFingerprint(day) {
+  return fnv1a64(
+    canonicalJson({
+      version: MEASURED_DAYS_V1,
+      date: day.date,
+      usage: day.usage,
+      workflow: day.workflow
+    })
+  );
+}
+
+// ../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;
@@ -3037,23 +3611,23 @@ 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
-  };
+function applyDayConsent(days, syncConfig) {
+  return days.map((day) => {
+    const { workflow, usage, ...rest } = day;
+    const out = { ...rest };
+    if (usage) {
+      out.usage = syncConfig.publishCost ? usage : {
+        harnesses: usage.harnesses.map((h) => ({
+          ...h,
+          models: h.models.map(
+            ({ usd: _usd, pricingTable: _table, ...model }) => model
+          )
+        }))
+      };
+    }
+    if (workflow && syncConfig.publishWorkflow) out.workflow = workflow;
+    return out;
+  });
 }
 function mergeKeptPrivate(halves) {
   const out = {};
@@ -3072,11 +3646,18 @@ function mergeKeptPrivate(halves) {
   }
   return out;
 }
-function buildSyncBody(built, syncConfig, autoSync, trigger = "manual", workflow, cliVersion) {
+function buildSyncBody(built, syncConfig, autoSync, trigger = "manual", measuredDays, cliVersion) {
   const payloads = built.map((b) => b.payload);
   const base = autoSync ? { payloads, autoSync, trigger } : { payloads, trigger };
-  const withWorkflow = workflow && syncConfig.publishWorkflow ? { ...base, workflow: toPayloadWorkflow(workflow) } : base;
-  const withVersion = cliVersion ? { ...withWorkflow, cliVersion } : withWorkflow;
+  const withDays = measuredDays ? {
+    ...base,
+    measuredDays: {
+      aggregateVersion: MEASURED_DAYS_V1,
+      utcOffsetMinutes: measuredDays.utcOffsetMinutes,
+      days: applyDayConsent(measuredDays.days, syncConfig)
+    }
+  } : base;
+  const withVersion = cliVersion ? { ...withDays, cliVersion } : withDays;
   if (!syncConfig.reviewKeptPrivate) return withVersion;
   return {
     ...withVersion,
@@ -3085,7 +3666,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 +3678,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 utcDateOf2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 var PHASE_RANK = {
   verify: 4,
   handoff: 3,
@@ -3145,18 +3726,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 +3746,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 +3806,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 = utcDateOf2(observation.tsMs);
       if (observation.projectWorkspace) {
         state.projectWorkspaces.add(observation.projectWorkspace);
         localSources.projectWorkspaces.add(observation.projectWorkspace);
@@ -3208,7 +3817,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 +3846,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(utcDateOf2(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 +3965,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(utcDateOf2(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 +3983,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(`${utcDateOf2(state.firstTs)}T00:00:00Z`);
+        const lastDay = Date.parse(`${utcDateOf2(state.lastTs)}T00:00:00Z`);
+        while (day <= lastDay) {
+          const date = utcDateOf2(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;
     }
   };
@@ -3460,7 +4109,8 @@ function ingestRecord(agg, raw, ctx) {
   const rec = asObj(raw);
   if (!rec) return;
   agg.records++;
-  agg.projectDirs.add(projectWorkspaceDirectory(rec) ?? ctx.projectDir);
+  const projectDir = projectWorkspaceDirectory(rec) ?? ctx.projectDir;
+  agg.projectDirs.add(projectDir);
   const version = asStr(rec.version);
   if (version) agg.ccVersions.add(cleanName(version));
   const sessionId = asStr(rec.sessionId);
@@ -3476,6 +4126,8 @@ function ingestRecord(agg, raw, ctx) {
       agg.lastTs = agg.lastTs === null ? ts : Math.max(agg.lastTs, ts);
     }
   }
+  if (sessionId) noteSessionStart(agg, sessionId, tsMs);
+  noteProjectDay(agg, projectDir, tsMs);
   const type = asStr(rec.type);
   if (type === "assistant") {
     ingestClaudeWorkflow(agg, rec, ctx, tsMs);
@@ -3587,7 +4239,9 @@ function ingestAssistant(agg, rec, tsMs) {
   const model = asName(msg.model) ?? "(unknown)";
   if (model.startsWith("<")) {
     agg.syntheticRecords++;
-    agg.syntheticTokens += countsTotal(readCounts(usage));
+    const synthetic = countsTotal(readCounts(usage));
+    agg.syntheticTokens += synthetic;
+    noteSyntheticTokens(agg, tsMs, synthetic);
     return;
   }
   if (tsMs === null) agg.untimestampedResponses++;
@@ -3687,6 +4341,7 @@ function buildContribution(usage, model, sidechain, tsMs) {
     entries,
     total: entries.reduce((a, e) => a + countsTotal(e.counts), 0),
     sidechain,
+    tsMs,
     webSearch: serverTools ? asNum(serverTools.web_search_requests) : 0,
     webFetch: serverTools ? asNum(serverTools.web_fetch_requests) : 0,
     mirroredIterationTypes: [...mirrored],
@@ -3710,6 +4365,11 @@ function applyContribution(agg, c, sign) {
     m.cacheRead += sign * counts.cacheRead;
     if (costUSD === null) m.unpricedTokens += sign * countsTotal(counts);
     else m.costUSD += sign * costUSD;
+    noteUsageResponse(
+      agg,
+      { tsMs: c.tsMs, modelKey, counts, costUSD, sidechain: c.sidechain },
+      sign
+    );
   });
   if (c.sidechain) agg.sidechainTokens += sign * c.total;
   else agg.mainTokens += sign * c.total;
@@ -3976,12 +4636,14 @@ function ingestLine(agg, raw, state, sinceMs) {
     agg.firstTs = agg.firstTs === null ? tsMs : Math.min(agg.firstTs, tsMs);
     agg.lastTs = agg.lastTs === null ? tsMs : Math.max(agg.lastTs, tsMs);
   }
-  noteActivity(agg, state);
+  noteActivity(agg, state, tsMs);
+  noteProjectDay(agg, state.cwd ?? "(unknown)", tsMs);
   if (type === "event_msg" && payload) ingestEvent(agg, payload, state, tsMs);
   else if (type === "response_item" && payload)
     ingestItem(agg, payload, state, tsMs);
 }
-function noteActivity(agg, state) {
+function noteActivity(agg, state, tsMs) {
+  if (state.sessionId) noteSessionStart(agg, state.sessionId, tsMs);
   if (state.counted) return;
   state.counted = true;
   if (state.sessionId) agg.sessions.add(state.sessionId);
@@ -4012,7 +4674,9 @@ function ingestEvent(agg, payload, state, tsMs) {
     agg,
     modelKey,
     counts,
-    apiEquivalentCost(modelKey, counts, tsMs)
+    apiEquivalentCost(modelKey, counts, tsMs),
+    1,
+    { tsMs }
   );
   agg.mainTokens += total;
   if (tsMs !== null && state.sessionId) {
@@ -4415,10 +5079,14 @@ function ingestMessageRow(agg, state, row) {
   const session = sessionId ? state.sessions.get(sessionId) : void 0;
   if (sessionId) {
     agg.sessions.add(sessionId);
+    noteSessionStart(agg, sessionId, tsMs);
     if (session?.version) agg.ccVersions.add(cleanName(session.version));
   }
   const cwd = asStr(row.cwd);
-  if (cwd) agg.projectDirs.add(cwd);
+  if (cwd) {
+    agg.projectDirs.add(cwd);
+    noteProjectDay(agg, cwd, tsMs);
+  }
   if (asStr(row.role) !== "assistant") return;
   agg.assistantRecords++;
   agg.distinctResponses++;
@@ -4441,7 +5109,9 @@ function ingestMessageRow(agg, state, row) {
     agg,
     modelKey,
     counts,
-    apiEquivalentCost(modelKey, counts, tsMs)
+    apiEquivalentCost(modelKey, counts, tsMs),
+    1,
+    { tsMs, sidechain: Boolean(session?.parentId) }
   );
   if (sessionId && tsMs !== null) {
     const completed = asNum(row.completedTsMs);
@@ -4917,7 +5587,8 @@ function ingestEntry(agg, raw, state, fold, sinceMs) {
     agg.firstTs = agg.firstTs === null ? tsMs : Math.min(agg.firstTs, tsMs);
     agg.lastTs = agg.lastTs === null ? tsMs : Math.max(agg.lastTs, tsMs);
   }
-  noteActivity2(agg, state);
+  noteActivity2(agg, state, tsMs);
+  noteProjectDay(agg, state.cwd ?? "(unknown)", tsMs);
   if (role === "assistant" && message) {
     agg.assistantRecords++;
     const served = asStr(message.responseModel);
@@ -4964,7 +5635,8 @@ function ingestEntry(agg, raw, state, fold, sinceMs) {
     countUsage(agg, fold, rec, 0, rec.usage, state.modelKey, tsMs);
   }
 }
-function noteActivity2(agg, state) {
+function noteActivity2(agg, state, tsMs) {
+  if (state.sessionId) noteSessionStart(agg, state.sessionId, tsMs);
   if (state.counted) return;
   state.counted = true;
   if (state.sessionId) agg.sessions.add(state.sessionId);
@@ -4993,7 +5665,9 @@ function countUsage(agg, fold, rec, msgTsMs, usageRaw, modelKey, tsMs, priceable
     agg,
     key,
     counts,
-    priceable ? apiEquivalentCost(key, counts, tsMs) : null
+    priceable ? apiEquivalentCost(key, counts, tsMs) : null,
+    1,
+    { tsMs }
   );
   agg.mainTokens += total;
   return "counted";
@@ -5944,6 +6618,152 @@ import { dirname as dirname7, join as join10 } from "path";
 // src/sync/stage.ts
 import { createHash as createHash2 } from "crypto";
 
+// src/usage/days.ts
+var round6 = (n) => Math.round(n * 1e6) / 1e6;
+function buildUsageDays(input) {
+  const { aggregate: agg, harness, publishCost, projectWorkspaceId } = input;
+  const sessionsByDay = /* @__PURE__ */ new Map();
+  for (const startMs of agg.sessionStarts.values()) {
+    const date = utcDateOf(startMs);
+    sessionsByDay.set(date, (sessionsByDay.get(date) ?? 0) + 1);
+  }
+  const dates = [
+    .../* @__PURE__ */ new Set([...agg.usageDays.keys(), ...sessionsByDay.keys()])
+  ].sort();
+  const out = /* @__PURE__ */ new Map();
+  for (const date of dates) {
+    const acc = agg.usageDays.get(date);
+    const groups = /* @__PURE__ */ new Map();
+    let unpriced = 0;
+    for (const [modelKey, m] of acc?.models ?? []) {
+      const id = sanitizeModelId(baseModelId(modelKey));
+      let g = groups.get(id);
+      if (!g) {
+        g = {
+          tokens: {
+            input: 0,
+            output: 0,
+            cacheWrite: 0,
+            cacheRead: 0,
+            cacheWriteTtl: { fiveMinute: 0, oneHour: 0, unsplit: 0 }
+          },
+          costUSD: 0,
+          unpricedTokens: 0,
+          table: null
+        };
+        groups.set(id, g);
+      }
+      g.table ??= pricingTableFor(modelKey);
+      g.tokens.input += m.counts.input;
+      g.tokens.output += m.counts.output;
+      g.tokens.cacheRead += m.counts.cacheRead;
+      g.tokens.cacheWrite += m.counts.cacheWrite5m + m.counts.cacheWrite1h + m.counts.cacheWriteUnsplit;
+      g.tokens.cacheWriteTtl.fiveMinute += m.counts.cacheWrite5m;
+      g.tokens.cacheWriteTtl.oneHour += m.counts.cacheWrite1h;
+      g.tokens.cacheWriteTtl.unsplit += m.counts.cacheWriteUnsplit;
+      g.costUSD += m.costUSD;
+      g.unpricedTokens += m.unpricedTokens;
+      unpriced += m.unpricedTokens;
+    }
+    const models = [...groups.entries()].map(([model, g]) => {
+      const { cacheWriteTtl, ...plain } = g.tokens;
+      const tokens = g.tokens.cacheWrite > 0 ? { ...plain, cacheWriteTtl } : plain;
+      const row = { model, tokens };
+      if (publishCost && g.unpricedTokens === 0 && g.table !== null && countsTotalOf(tokens) > 0) {
+        row.usd = round6(g.costUSD);
+        row.pricingTable = g.table;
+      }
+      return row;
+    }).filter((row) => countsTotalOf(row.tokens) > 0).sort(
+      (a, b) => countsTotalOf(b.tokens) - countsTotalOf(a.tokens) || a.model.localeCompare(b.model)
+    );
+    out.set(date, {
+      harness,
+      sessions: sessionsByDay.get(date) ?? 0,
+      projectKeys: [
+        ...new Set([...acc?.projectDirs ?? []].map(projectWorkspaceId))
+      ].sort(),
+      models,
+      subagentTokens: acc?.subagentTokens ?? 0,
+      excludedTokens: { unpriced, synthetic: acc?.syntheticTokens ?? 0 }
+    });
+  }
+  return out;
+}
+var countsTotalOf = (t) => t.input + t.output + t.cacheWrite + t.cacheRead;
+function mergeUsageDays(perHarness) {
+  const out = /* @__PURE__ */ new Map();
+  const dates = [
+    ...new Set(perHarness.flatMap((days) => [...days.keys()]))
+  ].sort();
+  for (const date of dates) {
+    const harnesses = [];
+    for (const days of perHarness) {
+      const day = days.get(date);
+      if (day) harnesses.push(day);
+    }
+    out.set(date, { harnesses });
+  }
+  return out;
+}
+function buildMeasuredDays(input) {
+  const workflowByDate = /* @__PURE__ */ new Map();
+  for (const day of input.workflow ?? []) workflowByDate.set(day.date, day);
+  const dates = [.../* @__PURE__ */ new Set([...input.usage.keys(), ...workflowByDate.keys()])].filter(
+    (d) => /^\d{4}-\d{2}-\d{2}$/.test(d) && d >= input.from && d <= input.to
+  ).sort();
+  return dates.map((date) => {
+    const usage = input.usage.get(date);
+    const workflow = workflowByDate.get(date);
+    return {
+      date,
+      ...usage ? { usage } : {},
+      ...workflow ? { workflow } : {}
+    };
+  });
+}
+
+// src/usage/diff.ts
+var MAX_DAY_WINDOW = 400;
+var DAY_MS = 864e5;
+function retentionFloor(todayUtc, days) {
+  const span = Math.max(1, Math.min(days, MAX_DAY_WINDOW));
+  const todayMs = Date.parse(`${todayUtc}T00:00:00.000Z`);
+  return new Date(todayMs - (span - 1) * DAY_MS).toISOString().slice(0, 10);
+}
+function selectDaysToPublish(input) {
+  const { local, manifest, todayUtc } = input;
+  const retention = manifest?.retentionDays ?? MAX_DAY_WINDOW;
+  const floor = retentionFloor(todayUtc, retention);
+  const comparable = manifest !== null && manifest.aggregateVersion === MEASURED_DAYS_V1;
+  const held = /* @__PURE__ */ new Map();
+  if (comparable) {
+    for (const day of manifest.days) held.set(day.date, day.fingerprint);
+  }
+  const send = [];
+  const skipped = [];
+  for (const day of [...local].sort((a, b) => a.date.localeCompare(b.date))) {
+    if (day.date < floor) {
+      skipped.push({ date: day.date, reason: "expired" });
+      continue;
+    }
+    if (comparable && day.date !== todayUtc) {
+      const fingerprint = held.get(day.date);
+      if (fingerprint !== void 0 && fingerprint === dayFingerprint(day)) {
+        skipped.push({ date: day.date, reason: "unchanged" });
+        continue;
+      }
+    }
+    send.push(day);
+  }
+  return {
+    send,
+    unchanged: skipped.filter((s) => s.reason === "unchanged").length,
+    skipped,
+    mode: comparable ? "diff" : "full"
+  };
+}
+
 // src/workflow/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import path6 from "path";
@@ -5962,11 +6782,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 +6936,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 +6969,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 +7000,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 +7031,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 +7079,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 }
+      };
+    })
   };
 }
 
@@ -6470,18 +7325,25 @@ function payloadBlock(payload, width, ownWindow, stats) {
 }
 var MODEL_ROLLUP = 0.01;
 var PHASE_ORDER = ["scout", "build", "verify", "handoff", "unknown"];
-function workflowBlock(workflow, host) {
+function workflowBlock(workflowDays, utcOffsetMinutes, 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(workflowDays, {
+    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    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_AGGREGATES_V2}`
+  );
+  const first = folded?.dates[0];
+  const last = folded?.dates.at(-1);
+  out.push(
+    `          ${workflowDays.length} day${workflowDays.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,16 +7355,31 @@ 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;
 }
+function daysLine(measuredDays, selection) {
+  const n = measuredDays.days.length;
+  const head = `${n} day${n === 1 ? "" : "s"} to publish`;
+  const unchanged = selection?.unchanged ?? 0;
+  return unchanged > 0 ? `${head}, ${unchanged} unchanged` : head;
+}
+function daysBlock(measuredDays, selection) {
+  const out = [`days      ${daysLine(measuredDays, selection)}`];
+  const first = measuredDays.days[0]?.date;
+  const last = measuredDays.days.at(-1)?.date;
+  const usageDays = measuredDays.days.filter((d) => d.usage).length;
+  if (first && last) {
+    out.push(
+      `          ${first} to ${last} \xB7 ${usageDays} with usage \xB7 ${measuredDays.aggregateVersion}`
+    );
+  }
+  return out;
+}
 function buildGateSummary(ctx) {
   const { body, keptPrivate, config, source, baseUrl } = ctx;
   const { payloads } = body;
@@ -6533,10 +7410,23 @@ function buildGateSummary(ctx) {
     out.push(...payloadBlock(payload, width, windows.size > 1, stats));
   }
   if (out[out.length - 1] === "") out.pop();
+  if (body.measuredDays) {
+    out.push("");
+    out.push(...daysBlock(body.measuredDays, ctx.days));
+  }
   out.push("");
-  out.push(
-    body.workflow ? workflowBlock(body.workflow, host).join("\n") : "workflow  not published"
+  const workflowDays = (body.measuredDays?.days ?? []).flatMap(
+    (d) => d.workflow ? [d.workflow] : []
   );
+  if (!config.publishWorkflow || !body.measuredDays) {
+    out.push("workflow  not published");
+  } else if (workflowDays.length === 0) {
+    out.push("workflow  on, no changed day to publish");
+  } else {
+    out.push(
+      ...workflowBlock(workflowDays, body.measuredDays.utcOffsetMinutes, host)
+    );
+  }
   const n = payloads.reduce((a, p8) => a + withheldCount(p8), 0);
   if (n > 0) {
     out.push("");
@@ -6578,6 +7468,7 @@ function buildGateSummary(ctx) {
 }
 
 // src/sync/stage.ts
+var utcDate2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 function stageId(bodyJson) {
   return createHash2("sha256").update(bodyJson).digest("hex").slice(0, 12);
 }
@@ -6588,20 +7479,33 @@ async function stageSync(deps) {
   const adapters = deps.adaptersImpl ?? detectedAdapters;
   const windowDays = deps.windowDays ?? DEFAULT_WINDOW_DAYS;
   const projectWorkspaceId = deps.getProjectWorkspaceIdImpl ?? getProjectWorkspaceId;
+  const fetchManifest = deps.fetchManifestImpl ?? fetchDayManifest;
   const { config, source } = await loadConfig({
     baseUrl: deps.baseUrl,
     ...token ? { token } : {}
   });
+  let manifest = null;
+  if (token) {
+    try {
+      manifest = await fetchManifest(deps.baseUrl, token);
+    } catch {
+      manifest = null;
+    }
+  }
+  const retentionDays = Math.max(
+    1,
+    Math.min(manifest?.retentionDays ?? MAX_DAY_WINDOW, MAX_DAY_WINDOW)
+  );
   const built = [];
   const scanStats = {};
   const workflowScans = [];
+  const usageScans = [];
   const sinceMs = windowStartMs(now, windowDays);
-  for (const adapter of await adapters(sinceMs)) {
-    const { aggregate, stats, workflow: workflow2, workflowLocal } = await adapter.scan({
-      sinceMs
-    });
+  const daysSinceMs = windowStartMs(now, retentionDays);
+  const active = await adapters(sinceMs);
+  for (const adapter of active) {
+    const { aggregate, stats } = await adapter.scan({ sinceMs });
     scanStats[adapter.name] = stats;
-    workflowScans.push({ aggregate: workflow2, local: workflowLocal });
     built.push(
       buildPayload({
         aggregate,
@@ -6615,19 +7519,51 @@ async function stageSync(deps) {
       })
     );
   }
+  for (const adapter of active) {
+    const { aggregate, workflow: workflow2, workflowLocal } = await adapter.scan({
+      sinceMs: daysSinceMs
+    });
+    workflowScans.push({ aggregate: workflow2, local: workflowLocal });
+    usageScans.push(
+      buildUsageDays({
+        harness: adapter.name,
+        aggregate,
+        publishCost: config.publishCost,
+        projectWorkspaceId
+      })
+    );
+  }
   const settings = (deps.getSettingsImpl ?? getSettings)();
   const workflow = workflowScans.length > 0 && config.publishWorkflow ? extractLocalWorkflow({
     harnesses: workflowScans,
-    fromMs: sinceMs,
+    fromMs: daysSinceMs,
     toMs: now,
     ...deps.gitRunnerImpl ? { run: deps.gitRunnerImpl } : {}
   }) : void 0;
+  const localDays = applyDayConsent(
+    buildMeasuredDays({
+      usage: mergeUsageDays(usageScans),
+      ...workflow ? { workflow: workflow.days } : {},
+      from: utcDate2(daysSinceMs),
+      to: utcDate2(now)
+    }),
+    config
+  );
+  const days = selectDaysToPublish({
+    local: localDays,
+    manifest,
+    todayUtc: utcDate2(now)
+  });
   const body = buildSyncBody(
     built,
     config,
     settings.autoSync,
     deps.trigger,
-    workflow,
+    active.length > 0 ? {
+      aggregateVersion: MEASURED_DAYS_V1,
+      utcOffsetMinutes: workflow?.utcOffsetMinutes ?? machineUtcOffsetMinutes(),
+      days: days.send
+    } : void 0,
     CLI_VERSION
   );
   const bodyJson = JSON.stringify(body);
@@ -6639,6 +7575,7 @@ async function stageSync(deps) {
     source,
     baseUrl: deps.baseUrl,
     scanStats,
+    days,
     // The real terminal, so the inventory rows break where this window ends
     // (#217). A pipe reports nothing and the preview falls back to 80.
     width: process.stdout.columns
@@ -6661,7 +7598,8 @@ async function stageSync(deps) {
     config,
     token,
     stagedAt: now,
-    blockedReason
+    blockedReason,
+    days
   };
 }