@use-aistack/cli 0.9.0 → 0.10.0

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/version.ts
-var CLI_VERSION = true ? "0.9.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();
@@ -2423,6 +2515,12 @@ function foldWorkflowDays(days, options) {
     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
   };
 }
@@ -3181,6 +3279,38 @@ function deriveSessionPhases(events, ruleSet = PHASE_RULES_V1, harness) {
   };
 }
 
+// ../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}`;
@@ -3481,12 +3611,23 @@ function buildPayload(input) {
     }
   };
 }
-function toPayloadWorkflow(extraction) {
-  return {
-    aggregateVersion: extraction.aggregateVersion,
-    utcOffsetMinutes: extraction.utcOffsetMinutes,
-    days: extraction.days
-  };
+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 = {};
@@ -3505,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,
@@ -3533,7 +3681,7 @@ var finiteNonnegative = (value) => value !== void 0 && Number.isFinite(value) &&
 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 utcDateOf2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 var PHASE_RANK = {
   verify: 4,
   handoff: 3,
@@ -3658,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 = utcDateOf(observation.tsMs);
+      const date = utcDateOf2(observation.tsMs);
       if (observation.projectWorkspace) {
         state.projectWorkspaces.add(observation.projectWorkspace);
         localSources.projectWorkspaces.add(observation.projectWorkspace);
@@ -3711,7 +3859,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
       let phaseSessionCount = 0;
       for (const state of sessions.values()) {
         if (state.firstTs === void 0) continue;
-        const day = dayOf(utcDateOf(state.firstTs));
+        const day = dayOf(utcDateOf2(state.firstTs));
         const events = reduceEventBatches(state.events, harness);
         const responses = [...state.responses.values()];
         day.sessions++;
@@ -3821,7 +3969,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
         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));
+        const day = dayOf(utcDateOf2(anchor));
         day.hasDelegation = true;
         day.delegation.mostSubagents = Math.max(
           day.delegation.mostSubagents,
@@ -3844,10 +3992,10 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
       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`);
+        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 = utcDateOf(day);
+          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)
@@ -3961,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);
@@ -3977,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);
@@ -4088,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++;
@@ -4188,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],
@@ -4211,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;
@@ -4477,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);
@@ -4513,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) {
@@ -4916,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++;
@@ -4942,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);
@@ -5418,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);
@@ -5465,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);
@@ -5494,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";
@@ -6445,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";
@@ -7006,11 +7325,11 @@ 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 folded = foldWorkflowDays(workflow.days, {
-    aggregateVersion: workflow.aggregateVersion,
-    utcOffsetMinutes: workflow.utcOffsetMinutes
+  const folded = foldWorkflowDays(workflowDays, {
+    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    utcOffsetMinutes
   });
   const harnesses = folded?.harnesses ?? [];
   const withPlaybook = harnesses.filter((h) => h.phase);
@@ -7019,12 +7338,12 @@ function workflowBlock(workflow, host) {
     ...new Set(withPlaybook.map((h) => h.phase?.ruleVersion ?? ""))
   ].filter(Boolean);
   out.push(
-    `workflow  ${harnesses.length} harness${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(
-    `days      ${workflow.days.length} day${workflow.days.length === 1 ? "" : "s"}${first && last ? ` \xB7 ${first} to ${last}` : ""}`
+    `          ${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)
@@ -7043,6 +7362,24 @@ function workflowBlock(workflow, host) {
   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;
@@ -7073,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("");
@@ -7118,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);
 }
@@ -7128,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,
@@ -7155,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);
@@ -7179,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
@@ -7201,7 +7598,8 @@ async function stageSync(deps) {
     config,
     token,
     stagedAt: now,
-    blockedReason
+    blockedReason,
+    days
   };
 }