mixdog 1.2.1 → 1.2.3

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { getModelMetadataSync } from '../../../../runtime/shared/llm/model-catalog.mjs';
+import { providerCachedModelsSync } from '../../../../runtime/shared/llm/provider-catalog-cache.mjs';
 
 export const CLAUDE_CURRENT_MODE = 'claude-current';
 export const CLAUDE_CURRENT_CHOICE_ID = 'claude-current';
@@ -95,11 +97,21 @@ function snapshotEquivalent(a, b) {
   return keys.every(k => (a[k] ?? null) === (b[k] ?? null));
 }
 
+// The newest roster model of a family, by the roster's own release stamps.
+function newestRosterModel(family) {
+  const stamp = (row) => Date.parse(row.releaseDate) || (Number(row.created) > 0 ? Number(row.created) : 0);
+  const rows = providerCachedModelsSync('anthropic-oauth').filter((row) =>
+    String(row.id).toLowerCase().startsWith(`claude-${family}-`)
+  );
+  rows.sort((a, b) => stamp(b) - stamp(a));
+  return rows[0]?.id || null;
+}
+
 function familyDefaultModel(family) {
   const f = String(family || '').toLowerCase();
   if (!f) return null;
   const envName = `ANTHROPIC_DEFAULT_${f.toUpperCase()}_MODEL`;
-  return cleanString(process.env[envName]) || DEFAULT_FAMILY_MODEL[f] || null;
+  return cleanString(process.env[envName]) || newestRosterModel(f) || DEFAULT_FAMILY_MODEL[f] || null;
 }
 
 export function stripClaudeContextSuffix(model) {
@@ -109,9 +121,7 @@ export function stripClaudeContextSuffix(model) {
 function contextWindowFromRawModel(raw, resolved) {
   const s = cleanString(raw).toLowerCase();
   if (/\[1m\]/.test(s)) return 1000000;
-  if (/^claude-(opus|sonnet)-4-(6|7|8)(?:$|-)/i.test(resolved || '')) return 1000000;
-  if (/^claude-haiku-4-5/i.test(resolved || '')) return 200000;
-  return null;
+  return (resolved && getModelMetadataSync(resolved, 'anthropic-oauth')?.contextWindow) || null;
 }
 
 export function resolveClaudeModelAlias(model) {

package/src/workflows/default/WORKFLOW.md

@@ -6,7 +6,9 @@ description: "Handle tasks as requested."
 
 Consult the user and build the work plan together. Explicit read-only requests
 proceed immediately. When file edits, state mutation, or delegation are
-required, investigate and plan only until the user approves the latest plan.
+required, investigate and plan only until the user approves the latest plan. If the
+plan leaves the user a choice among clear options, ask it with `ask_user`
+before asking for approval.
 
 When user input is required, park only the affected work and continue
 unaffected approved work. Ask pending questions together once no such work

package/src/runtime/memory/lib/memory-session-merge.mjs

@@ -1,32 +0,0 @@
-// Pure, DB-free merge of session-fallback recall rows into the already-ranked
-// global hybrid rows. Extracted into its own module so the starve-prevention +
-// dedupe contract can be unit-tested without booting the memory worker (which
-// has heavy top-level side effects: http server, pg, onnx embedding).
-//
-// Contract:
-//   - APPEND session rows, never prepend. Blind prepend lets session rows
-//     (limit+) starve the global first page and distorts sort/offset/limit.
-//   - Re-apply the SAME sort policy as the global path so global hybrid hits
-//     (carrying a real retrievalScore) keep their rank; session rows
-//     (retrievalScore 0 under importance, ts-ordered under date) only fill
-//     genuinely open slots.
-//   - Dedupe drops any session row whose id already appears as a global row OR
-//     as a global root's inlined chunk member (prevents member/leaf double
-//     output).
-import { compareRecallByScore, compareRecallNewestFirst } from './recall-order.mjs';
-
-export function mergeSessionRowsIntoGlobal(globalRows, sessionRows, { sort = 'importance' } = {}) {
-  const filtered = Array.isArray(globalRows) ? [...globalRows] : [];
-  if (!Array.isArray(sessionRows) || sessionRows.length === 0) return filtered;
-  const seen = new Set(filtered.map((r) => Number(r.id)));
-  for (const r of filtered) {
-    if (Array.isArray(r.members)) {
-      for (const m of r.members) seen.add(Number(m.id));
-    }
-  }
-  const merged = sessionRows.filter((r) => !seen.has(Number(r.id)));
-  if (merged.length === 0) return filtered;
-  const out = [...filtered, ...merged];
-  out.sort(sort === 'date' ? compareRecallNewestFirst : compareRecallByScore);
-  return out;
-}

package/src/runtime/shared/llm/usage-session-history.mjs

@@ -1,266 +0,0 @@
-/**
- * Long-range usage recovered from the durable session stores.
- *
- * The gateway event list is capped by row count and the daily rollup only
- * carries days recorded after rolling up began, so both stores answer "what
- * happened recently" and neither can answer "what did I ever spend on Grok".
- * The session documents can: every session keeps its own lifetime token
- * counters, its route, and its transcript timestamps, and they outlive both
- * telemetry stores.
- *
- * So this module rebuilds per-day totals from those documents. The rebuild is
- * a derivation, not a second recording: a day that the rollup or the raw
- * events already cover is never taken from here, which is what keeps a turn
- * from being counted twice.
- *
- * Two things are approximations, and both are marked `restored` so a surface
- * can say so:
- *   - a session carries ONE set of token counters, so a session that changed
- *     model mid-way is attributed to the route it ended on;
- *   - those counters are not stamped per turn, so a session that spans days is
- *     split across them by how many messages each day holds.
- */
-import { billableInputTokensForProvider, computeCostUsd } from './cost.mjs';
-import { cleanId as clean, isConversationUsageSource, num, round6, usageRollupDayKey } from './usage-rollup.mjs';
-
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-/** Timestamp a transcript message was written at, when it carries one. */
-function messageTimestamp(message) {
-  const direct = num(message?.createdAt);
-  if (direct > 0) return direct;
-  return num(message?.meta?.transcript?.at);
-}
-
-/**
- * Spread `total` across `keys` in proportion to `weights`, keeping the sum
- * exact: the rounding remainder lands on the heaviest day rather than
- * disappearing from the totals.
- */
-function distribute(total, keys, weights, weightSum) {
-  const out = new Map();
-  if (!(total > 0) || !keys.length) return out;
-  if (keys.length === 1 || !(weightSum > 0)) {
-    out.set(keys[0], total);
-    return out;
-  }
-  let assigned = 0;
-  let heaviest = keys[0];
-  let heaviestWeight = -1;
-  for (const key of keys) {
-    const weight = weights.get(key) || 0;
-    const share = Math.floor((total * weight) / weightSum);
-    out.set(key, share);
-    assigned += share;
-    if (weight > heaviestWeight) {
-      heaviest = key;
-      heaviestWeight = weight;
-    }
-  }
-  if (assigned < total) out.set(heaviest, (out.get(heaviest) || 0) + (total - assigned));
-  return out;
-}
-
-/**
- * One session document → the per-day slices it contributes.
- * Returns null for a session that never spent a token, which is most of the
- * short-lived ids a daemon mints.
- */
-export function summarizeSessionUsage(doc) {
-  const provider = clean(doc?.provider);
-  const model = clean(doc?.model);
-  if (!provider || !model) return null;
-
-  const cacheRead = num(doc?.totalCachedReadTokens);
-  const cacheWrite = num(doc?.totalCacheWriteTokens);
-  // `totalUncachedInputTokens` is already the billable part. Where a session
-  // predates that counter the raw input is unpacked the same way the rollup
-  // does it, so a provider that reports the cache inside `input` is not
-  // counted twice.
-  const input =
-    num(doc?.totalUncachedInputTokens) ||
-    billableInputTokensForProvider(provider, num(doc?.totalInputTokens), cacheRead, cacheWrite);
-  const output = num(doc?.totalOutputTokens);
-  if (input + output + cacheRead + cacheWrite <= 0) return null;
-
-  const messages = Array.isArray(doc?.messages) ? doc.messages : [];
-  const weights = new Map();
-  let weightSum = 0;
-  let firstTs = 0;
-  let lastTs = 0;
-  let userTurns = 0;
-  for (const message of messages) {
-    if (message?.role === 'user') userTurns += 1;
-    const ts = messageTimestamp(message);
-    if (ts <= 0) continue;
-    const key = usageRollupDayKey(ts);
-    weights.set(key, (weights.get(key) || 0) + 1);
-    weightSum += 1;
-    firstTs = firstTs > 0 ? Math.min(firstTs, ts) : ts;
-    lastTs = Math.max(lastTs, ts);
-  }
-  // A transcript compacted down to nothing still spent what it spent; the day
-  // it was last used is the only timestamp left to attribute it to.
-  if (!weights.size) {
-    const fallback = num(doc?.updatedAt) || num(doc?.lastUsedAt) || num(doc?.createdAt);
-    if (!fallback) return null;
-    const key = usageRollupDayKey(fallback);
-    weights.set(key, 1);
-    weightSum = 1;
-    firstTs = fallback;
-    lastTs = fallback;
-  }
-
-  const keys = [...weights.keys()].sort();
-  const turns = Math.max(1, userTurns);
-  const byInput = distribute(input, keys, weights, weightSum);
-  const byOutput = distribute(output, keys, weights, weightSum);
-  const byCacheRead = distribute(cacheRead, keys, weights, weightSum);
-  const byCacheWrite = distribute(cacheWrite, keys, weights, weightSum);
-  const byTurns = distribute(turns, keys, weights, weightSum);
-
-  const days = {};
-  for (const key of keys) {
-    const slice = {
-      turns: byTurns.get(key) || 0,
-      input: byInput.get(key) || 0,
-      output: byOutput.get(key) || 0,
-      cacheRead: byCacheRead.get(key) || 0,
-      cacheWrite: byCacheWrite.get(key) || 0,
-      costUsd: 0,
-    };
-    if (slice.turns + slice.input + slice.output + slice.cacheRead + slice.cacheWrite <= 0) continue;
-    let costUsd = 0;
-    try {
-      costUsd = num(
-        computeCostUsd({
-          provider,
-          model,
-          uncachedInputTokens: slice.input,
-          outputTokens: slice.output,
-          cacheReadTokens: slice.cacheRead,
-          cacheWriteTokens: slice.cacheWrite,
-        })
-      );
-    } catch {
-      // An unpriced model still reports its tokens.
-    }
-    slice.costUsd = round6(costUsd);
-    days[key] = slice;
-  }
-  if (!Object.keys(days).length) return null;
-
-  return {
-    provider,
-    model,
-    sessionId: clean(doc?.id),
-    conversation: isConversationUsageSource(doc?.sourceType),
-    firstTs,
-    lastTs,
-    days,
-  };
-}
-
-function emptyRouteTotals() {
-  return { turns: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
-}
-
-function emptyTurnTotals() {
-  return {
-    ...emptyRouteTotals(),
-    costBilled: 0,
-    // Nothing here was priced by a provider invoice: the catalog priced it.
-    costEstimated: 0,
-    costKnownTurns: 0,
-    durationMs: 0,
-    durationTurns: 0,
-  };
-}
-
-/** Rollup-shaped so the stats model folds a restored day with the same code. */
-function emptyHistoryDay() {
-  return {
-    ...emptyTurnTotals(),
-    firstTs: 0,
-    lastTs: 0,
-    conversation: emptyTurnTotals(),
-    conversationPartial: false,
-    sessionsPurged: true,
-    // Tells a reader these numbers were derived from transcripts rather than
-    // recorded turn by turn.
-    restored: true,
-    models: {},
-    sessions: {},
-    sessionTokens: [],
-    sessionsDropped: 0,
-  };
-}
-
-function addRouteTotals(target, slice) {
-  target.turns += slice.turns;
-  target.input += slice.input;
-  target.output += slice.output;
-  target.cacheRead += slice.cacheRead;
-  target.cacheWrite += slice.cacheWrite;
-  target.costUsd = round6(target.costUsd + slice.costUsd);
-}
-
-function addTurnTotals(target, slice) {
-  addRouteTotals(target, slice);
-  if (slice.costUsd > 0) {
-    target.costEstimated = round6(target.costEstimated + slice.costUsd);
-    target.costKnownTurns += slice.turns;
-  }
-}
-
-/** Fold every cached session summary into one day-keyed document. */
-export function buildUsageHistoryDays(entries) {
-  const days = {};
-  for (const entry of entries) {
-    if (!entry?.provider || !entry?.model || !entry?.days) continue;
-    const routeKey = `${entry.provider}/${entry.model}`;
-    for (const [key, slice] of Object.entries(entry.days)) {
-      if (!/^\d{4}-\d{2}-\d{2}$/.test(key)) continue;
-      const day = days[key] || emptyHistoryDay();
-      const normalized = {
-        turns: num(slice?.turns),
-        input: num(slice?.input),
-        output: num(slice?.output),
-        cacheRead: num(slice?.cacheRead),
-        cacheWrite: num(slice?.cacheWrite),
-        costUsd: num(slice?.costUsd),
-      };
-      addTurnTotals(day, normalized);
-      if (entry.conversation) addTurnTotals(day.conversation, normalized);
-
-      const bucket = day.models[routeKey] || {
-        provider: entry.provider,
-        model: entry.model,
-        kind: '',
-        ...emptyRouteTotals(),
-        conversation: emptyRouteTotals(),
-      };
-      addRouteTotals(bucket, normalized);
-      if (entry.conversation) addRouteTotals(bucket.conversation, normalized);
-      day.models[routeKey] = bucket;
-
-      // Only conversation ids count as sessions, matching the rollup: a
-      // background runner mints a fresh id per cycle.
-      if (entry.conversation && entry.sessionId) {
-        const tokens = normalized.input + normalized.output + normalized.cacheRead + normalized.cacheWrite;
-        day.sessions[entry.sessionId] = (day.sessions[entry.sessionId] || 0) + tokens;
-      }
-      const dayStart = Date.parse(`${key}T00:00:00`);
-      if (Number.isFinite(dayStart)) {
-        const first = num(entry.firstTs);
-        const last = num(entry.lastTs);
-        const from = first > dayStart && first < dayStart + DAY_MS ? first : dayStart;
-        const to = last > dayStart && last < dayStart + DAY_MS ? last : dayStart + DAY_MS - 1;
-        day.firstTs = day.firstTs > 0 ? Math.min(day.firstTs, from) : from;
-        day.lastTs = Math.max(day.lastTs, to);
-      }
-      days[key] = day;
-    }
-  }
-  return days;
-}