clementine-agent 1.18.181 → 1.18.183

package/dist/agent/run-skill.js

@@ -219,18 +219,26 @@ function shouldAutoDelegate(skill, source) {
     return true;
 }
 /**
- * Resolve the model string to use for an autonomous run. The 1M-context
- * variant gives the worker subagent 5× the room of the standard 200K
- * window — enough headroom that compaction is rare and the
- * "refetch-after-compact" loop pattern (seen in the 2026-05-11
- * imessage-triage failures) never occurs in practice.
+ * Resolve the model string to use for an autonomous run.
  *
- * The actual 1M routing is gated by the user's plan (see
- * config.ts:usesOneMillionContext) and the model family — Haiku doesn't
- * support 1M, and Sonnet 1M needs the [1m] suffix. We return the full
- * Sonnet model ID with [1m] appended; downstream
- * normalizeClaudeSdkOptionsForOneMillionContext strips it back off when
- * the plan doesn't support it.
+ * **Default: plain Sonnet (200K).** Sonnet `[1m]` is the "Extra Usage
+ * path" on Anthropic's billing — it is NOT covered by Max/Team/Enterprise
+ * subscriptions, regardless of `CLEMENTINE_1M_CONTEXT_MODE` (the mode
+ * flag only governs Opus long-context, which Max does cover). Defaulting
+ * autonomous work to Sonnet [1m] silently routes cron, scheduled-skill,
+ * heartbeat, and team-task runs onto a separate metered bill — surprising
+ * on Max plans where the standard Sonnet meter stays quiet but weekly
+ * usage climbs.
+ *
+ * Compaction risk on the 200K window is mitigated by the auto-delegating
+ * wrapper (1.18.173): the worker subagent runs in an isolated context
+ * containing only the skill body + its own tool turns, so even
+ * data-heavy procedures comfortably fit.
+ *
+ * Skills that genuinely need 1M (rare — verify the workload first) opt
+ * in explicitly via frontmatter `clementine.limits.model:
+ * claude-sonnet-4-6[1m]` (Extra Usage) or `claude-opus-4-7[1m]` (covered
+ * by Max). Callers may also override per-invocation via `options.model`.
  */
 function resolveAutonomousModel(explicitModel, skillModel) {
     // Caller's explicit model wins.
@@ -239,22 +247,17 @@ function resolveAutonomousModel(explicitModel, skillModel) {
     // Skill-declared model wins next.
     if (skillModel)
         return skillModel;
-    // Default: Sonnet [1m]. The normalizer will strip [1m] if the user's
-    // plan doesn't include it, falling back to standard Sonnet — still
-    // works, just with less headroom.
-    const base = MODELS.sonnet;
-    if (!base)
-        return undefined;
-    if (/\[1m\]/i.test(base))
-        return base;
-    return `${base}[1m]`;
+    // Default: plain Sonnet (no [1m]). Stays on the standard Sonnet meter
+    // covered by Max plans; no Extra Usage exposure.
+    return MODELS.sonnet;
 }
 /**
  * Build the AgentDefinition for the `skill-worker` subagent that
  * executes this skill in an isolated context. The subagent's system
  * prompt is the skill body; its tools are the skill's computed
- * allowlist; its model is the same 1M-context model the parent uses
- * (the worker is where the real data flows — the parent stays tiny).
+ * allowlist; its model is whatever resolveAutonomousModel returned —
+ * by default plain Sonnet 200K, which the isolated worker context
+ * comfortably fits without compaction.
  *
  * `description` is what the SDK shows the parent for routing decisions.
  * Since the parent is `forceSubagent`'d to this worker, the description
@@ -275,8 +278,9 @@ function buildSkillWorkerAgent(skill, renderedProcedure, effectiveTools, model,
             `## Procedure\n\n${renderedProcedure}`,
         tools: effectiveTools,
         // SDK accepts 'sonnet' / 'opus' / 'haiku' tier aliases OR full model
-        // IDs. We pass the full ID with [1m] when present; the SDK strips
-        // [1m] internally for plans that don't support it.
+        // IDs. Default is plain Sonnet (200K); when a skill or caller opts
+        // into a [1m] variant explicitly, we pass it through and the SDK
+        // strips [1m] internally for plans that don't support it.
         ...(model ? { model } : {}),
         effort: 'medium',
         maxTurns: workerMaxTurns,
@@ -368,10 +372,12 @@ export async function runSkill(name, options = {}) {
         ...(skill.layout === 'folder' ? [path.dirname(skill.filePath)] : []),
     ];
     const mutatingSkill = effectiveTools.some((t) => t === 'Write' || t === 'Edit' || t === 'Bash' || /__(write|edit|update|create|delete|send|post|patch|set)/i.test(t));
-    // 1.18.173: resolve the effective model. Autonomous runs default to
-    // Sonnet [1m] (1M context window) so the worker subagent has 5× the
-    // room of a standard 200K-window model. resolveAutonomousModel honors
-    // explicit overrides + skill-declared limits.model first.
+    // 1.18.182: resolve the effective model. Autonomous runs default to
+    // plain Sonnet (200K) — covered by the standard Sonnet meter on Max,
+    // no Extra Usage exposure. Worker-subagent isolation (1.18.173) keeps
+    // the 200K window comfortably under compaction even for heavy skills.
+    // resolveAutonomousModel honors explicit overrides + skill-declared
+    // limits.model first, so a skill that genuinely needs 1M can opt in.
     const skillModel = skill.frontmatter?.clementine?.limits?.model;
     const effectiveModel = autoDelegate
         ? resolveAutonomousModel(options.model, skillModel)

package/dist/cli/dashboard.js

@@ -10667,7 +10667,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     // ── Token Usage API ──────────────────────────────────────────────
     app.get('/api/metrics/usage', async (_req, res) => {
         if (!existsSync(MEMORY_DB_PATH)) {
-            res.json({ error: 'No DB', totalTokens: 0, byModel: [], bySource: [], byDay: [] });
+            res.json({ error: 'No DB', totalTokens: 0, byModel: [], bySource: [], byDay: [], byBucket: [], bucketTotals: { planCostCents: 0, extraCostCents: 0 } });
             return;
         }
         const Database = (await import('better-sqlite3')).default;
@@ -10676,32 +10676,86 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             // Check if table exists
             const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='usage_log'").get();
             if (!tableExists) {
-                res.json({ totalTokens: 0, totalInput: 0, totalOutput: 0, byModel: [], bySource: [], byDay: [] });
+                res.json({ totalTokens: 0, totalInput: 0, totalOutput: 0, byModel: [], bySource: [], byDay: [], byBucket: [], bucketTotals: { planCostCents: 0, extraCostCents: 0 } });
                 return;
             }
+            // 1.18.183: cost_cents may not exist on older installs (added via
+            // ALTER at store.ts:675). Probe before referencing so we degrade
+            // to "no cost data" rather than erroring out.
+            const columns = new Set(db.prepare('PRAGMA table_info(usage_log)').all().map((c) => c.name));
+            const costExpr = columns.has('cost_cents') ? 'COALESCE(SUM(cost_cents), 0)' : '0';
             const totals = db.prepare(`SELECT COALESCE(SUM(input_tokens), 0) as ti, COALESCE(SUM(output_tokens), 0) as to_,
-                COALESCE(SUM(cache_read_tokens), 0) as tcr, COALESCE(SUM(cache_creation_tokens), 0) as tcc
+                COALESCE(SUM(cache_read_tokens), 0) as tcr, COALESCE(SUM(cache_creation_tokens), 0) as tcc,
+                ${costExpr} as cost
          FROM usage_log`).get();
-            const byModel = db.prepare(`SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output, SUM(cache_read_tokens) as cacheRead
+            const byModel = db.prepare(`SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output,
+                SUM(cache_read_tokens) as cacheRead, ${costExpr} as costCents, COUNT(*) as queries
          FROM usage_log GROUP BY model ORDER BY input DESC`).all();
             const bySource = db.prepare(`SELECT source, SUM(input_tokens) as input, SUM(output_tokens) as output
          FROM usage_log GROUP BY source ORDER BY input DESC`).all();
             const byDay = db.prepare(`SELECT date(created_at) as day, SUM(input_tokens) as input, SUM(output_tokens) as output
          FROM usage_log WHERE created_at >= date('now', '-7 days')
          GROUP BY date(created_at) ORDER BY day`).all();
+            // 1.18.183: per-bucket aggregation. Same byModel rows, classified
+            // by billing bucket (Sonnet 200K / Sonnet 1M Extra Usage / Opus /
+            // Opus 1M / Haiku) so the dashboard can render Max-meter vs
+            // Extra-Usage breakdown. See src/lib/billing-buckets.ts.
+            const { classifyBillingBucket, BUCKET_DISPLAY_ORDER } = await import('../lib/billing-buckets.js');
+            const bucketMap = new Map();
+            for (const row of byModel) {
+                const b = classifyBillingBucket(row.model);
+                const existing = bucketMap.get(b.id);
+                if (existing) {
+                    existing.costCents += Number(row.costCents) || 0;
+                    existing.inputTokens += Number(row.input) || 0;
+                    existing.outputTokens += Number(row.output) || 0;
+                    existing.queries += Number(row.queries) || 0;
+                    if (!existing.models.includes(row.model))
+                        existing.models.push(row.model);
+                }
+                else {
+                    bucketMap.set(b.id, {
+                        id: b.id,
+                        label: b.label,
+                        family: b.family,
+                        context: b.context,
+                        meteredOnMax: b.meteredOnMax,
+                        costCents: Number(row.costCents) || 0,
+                        inputTokens: Number(row.input) || 0,
+                        outputTokens: Number(row.output) || 0,
+                        queries: Number(row.queries) || 0,
+                        models: [row.model],
+                    });
+                }
+            }
+            // Render in canonical order (Extra Usage anchors last so callouts
+            // hit the eye after the in-plan rows).
+            const byBucket = BUCKET_DISPLAY_ORDER
+                .map((id) => bucketMap.get(id))
+                .filter((b) => b !== undefined);
+            const bucketTotals = byBucket.reduce((acc, b) => {
+                if (b.meteredOnMax === 'extra')
+                    acc.extraCostCents += b.costCents;
+                else
+                    acc.planCostCents += b.costCents;
+                return acc;
+            }, { planCostCents: 0, extraCostCents: 0 });
             res.json({
                 totalInput: totals.ti,
                 totalOutput: totals.to_,
                 totalCacheRead: totals.tcr,
                 totalCacheCreation: totals.tcc,
                 totalTokens: totals.ti + totals.to_,
+                totalCostCents: totals.cost,
                 byModel,
                 bySource,
                 byDay,
+                byBucket,
+                bucketTotals,
             });
         }
         catch (err) {
-            res.json({ error: String(err), totalTokens: 0, byModel: [], bySource: [], byDay: [] });
+            res.json({ error: String(err), totalTokens: 0, byModel: [], bySource: [], byDay: [], byBucket: [], bucketTotals: { planCostCents: 0, extraCostCents: 0 } });
         }
         finally {
             db.close();
@@ -37199,6 +37253,16 @@ function formatTokens(n) {
   return String(n);
 }
 
+// 1.18.183: dollars for the billing-bucket panel. Cents in, "$X.XX"
+// out. Sub-cent values render as "<$0.01" so a tiny but nonzero
+// Extra Usage line still reads as "you have exposure" rather than "$0".
+function formatCents(cents) {
+  var c = Number(cents) || 0;
+  if (c === 0) return '$0.00';
+  if (c > 0 && c < 1) return '<$0.01';
+  return '$' + (c / 100).toFixed(2);
+}
+
 function formatBytes(n) {
   if (n == null) return '—';
   if (n < 1024) return n + ' B';
@@ -38610,6 +38674,65 @@ async function refreshMetrics() {
     html += statTile(cacheEff + '%', 'Cache Hit Rate', cacheEff >= 50 ? 'var(--green)' : cacheEff >= 20 ? 'var(--yellow)' : 'var(--text-muted)');
     html += '</div>';
 
+    // 1.18.183: Spend by Billing Bucket — separates Max-covered usage
+    // from Extra Usage exposure (Sonnet [1m] etc.). Surfaces the bucket
+    // a model lives in, not just its token count, so a quiet Sonnet
+    // meter no longer hides rising weekly spend on a separate billing
+    // line. See src/lib/billing-buckets.ts.
+    if (u.byBucket && u.byBucket.length > 0) {
+      var planCost = (u.bucketTotals && u.bucketTotals.planCostCents) || 0;
+      var extraCost = (u.bucketTotals && u.bucketTotals.extraCostCents) || 0;
+      var totalCost = planCost + extraCost;
+      var hasExtra = extraCost > 0;
+
+      html += '<div class="card" style="margin-top:16px"><div class="card-header">'
+        + 'Spend by Billing Bucket'
+        + '<span style="float:right;font-size:11px;color:var(--text-muted);font-weight:400">'
+        + 'In-plan ' + esc(formatCents(planCost))
+        + ' &middot; Extra Usage ' + (hasExtra
+          ? '<span style="color:var(--orange,#f80);font-weight:600">' + esc(formatCents(extraCost)) + '</span>'
+          : esc(formatCents(extraCost)))
+        + '</span></div><div class="card-body">';
+
+      // Banner when Extra Usage > 0 — this is the whole point of the
+      // panel. Max plans don't comp Sonnet [1m]; surfacing it here means
+      // the user can spot it without checking the Anthropic Console.
+      if (hasExtra) {
+        html += '<div style="margin-bottom:12px;padding:10px 12px;border-radius:6px;'
+          + 'background:rgba(255,128,0,0.08);border-left:3px solid var(--orange,#f80);'
+          + 'font-size:12px;line-height:1.5">'
+          + '<strong>Extra Usage detected.</strong> '
+          + esc(formatCents(extraCost))
+          + ' of recent spend is on the Anthropic Extra Usage path (typically Sonnet 1M), '
+          + 'which is <strong>not</strong> covered by Max / Team / Enterprise subscriptions. '
+          + 'Switch heavy autonomous skills to <code>claude-opus-4-7[1m]</code> via skill frontmatter '
+          + '<code>clementine.limits.model</code>, or drop <code>[1m]</code> to stay on the standard Sonnet meter.'
+          + '</div>';
+      }
+
+      var maxBucketCost = Math.max.apply(null, u.byBucket.map(function(b) { return b.costCents || 0; }).concat([1]));
+      for (var bi = 0; bi < u.byBucket.length; bi++) {
+        var bk = u.byBucket[bi];
+        var bkPct = maxBucketCost > 0 ? Math.round(((bk.costCents || 0) / maxBucketCost) * 100) : 0;
+        var bkColor = bk.meteredOnMax === 'extra' ? 'var(--orange,#f80)'
+          : (bk.family === 'opus' ? 'var(--purple)'
+            : (bk.family === 'sonnet' ? 'var(--blue)'
+              : (bk.family === 'haiku' ? 'var(--green)' : 'var(--text-muted)')));
+        var bkShareNum = totalCost > 0 ? Math.round(((bk.costCents || 0) / totalCost) * 100) : 0;
+        html += '<div style="margin-bottom:10px">'
+          + '<div class="kv-row">'
+          + '<span class="kv-key">' + esc(bk.label) + '</span>'
+          + '<span class="kv-val" title="' + esc(formatTokens(bk.inputTokens || 0)) + ' input &middot; ' + esc(formatTokens(bk.outputTokens || 0)) + ' output &middot; ' + (bk.queries || 0) + ' calls">'
+          + esc(formatCents(bk.costCents || 0))
+          + '<span style="color:var(--text-muted);font-size:11px;margin-left:6px">' + bkShareNum + '%</span>'
+          + '</span>'
+          + '</div>'
+          + '<div class="metric-bar-track"><div class="metric-bar-fill" style="width:' + bkPct + '%;background:' + bkColor + '"></div></div>'
+          + '</div>';
+      }
+      html += '</div></div>';
+    }
+
     // Tokens by Model
     if (u.byModel && u.byModel.length > 0) {
       html += '<div class="card"><div class="card-header">Tokens by Model</div><div class="card-body">';

package/dist/lib/billing-buckets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Anthropic billing-bucket classifier.
+ *
+ * Maps a Claude model string (full ID or SDK tier alias) to the metering
+ * bucket Anthropic bills against. The headline distinction on Max /
+ * Team / Enterprise plans is in-plan (covered by the subscription's
+ * usage allowance) vs. Extra Usage (billed separately, surprises the
+ * meter watcher).
+ *
+ * **Why this matters (2026-05-11)**: Sonnet `[1m]` is on the Extra Usage
+ * path even with Max. Max covers Opus long-context but not Sonnet 1M.
+ * Without per-bucket aggregation, the dashboard cost number conflates
+ * "covered by my plan" with "billed separately" and the user has no way
+ * to spot Extra Usage exposure until the invoice arrives. See
+ * memory/feedback_sonnet_1m_extra_usage.md.
+ *
+ * Pure function, no I/O. Safe to call from any layer.
+ */
+export type BillingBucketId = 'sonnet' | 'sonnet-1m' | 'opus' | 'opus-1m' | 'haiku' | 'other';
+export type BillingBucketMetering = 
+/** Counts against the Max/Team/Enterprise plan's usage allowance. */
+'plan'
+/** Billed separately as Extra Usage even when the user has Max. */
+ | 'extra';
+export interface BillingBucket {
+    /** Stable bucket id, suitable for grouping/keys. */
+    id: BillingBucketId;
+    /** Human-readable label for UI ("Sonnet 200K", "Sonnet 1M — Extra Usage"). */
+    label: string;
+    /** Model family irrespective of context window. */
+    family: 'sonnet' | 'opus' | 'haiku' | 'other';
+    /** Context window class. */
+    context: '200k' | '1m';
+    /** How Anthropic bills this on a Max plan. */
+    meteredOnMax: BillingBucketMetering;
+}
+/**
+ * Classify a model string into its billing bucket.
+ *
+ * Accepts:
+ *  - Full model IDs: `claude-sonnet-4-6`, `claude-sonnet-4-6[1m]`,
+ *    `claude-opus-4-7[1m]`, `claude-haiku-4-5-20251001`, etc.
+ *  - SDK tier aliases: `sonnet`, `opus`, `haiku` (no `[1m]` form for
+ *    tier aliases — they always resolve to standard context).
+ *  - Empty / unknown / non-Claude strings → `'other'` bucket.
+ */
+export declare function classifyBillingBucket(model: string | undefined | null): BillingBucket;
+/** Canonical render order for the dashboard panel. */
+export declare const BUCKET_DISPLAY_ORDER: readonly BillingBucketId[];
+/** Convenience: is this bucket on the Extra Usage path for Max plans? */
+export declare function isExtraUsage(bucket: BillingBucket): boolean;
+//# sourceMappingURL=billing-buckets.d.ts.map

package/dist/lib/billing-buckets.js

@@ -0,0 +1,108 @@
+/**
+ * Anthropic billing-bucket classifier.
+ *
+ * Maps a Claude model string (full ID or SDK tier alias) to the metering
+ * bucket Anthropic bills against. The headline distinction on Max /
+ * Team / Enterprise plans is in-plan (covered by the subscription's
+ * usage allowance) vs. Extra Usage (billed separately, surprises the
+ * meter watcher).
+ *
+ * **Why this matters (2026-05-11)**: Sonnet `[1m]` is on the Extra Usage
+ * path even with Max. Max covers Opus long-context but not Sonnet 1M.
+ * Without per-bucket aggregation, the dashboard cost number conflates
+ * "covered by my plan" with "billed separately" and the user has no way
+ * to spot Extra Usage exposure until the invoice arrives. See
+ * memory/feedback_sonnet_1m_extra_usage.md.
+ *
+ * Pure function, no I/O. Safe to call from any layer.
+ */
+/**
+ * Classify a model string into its billing bucket.
+ *
+ * Accepts:
+ *  - Full model IDs: `claude-sonnet-4-6`, `claude-sonnet-4-6[1m]`,
+ *    `claude-opus-4-7[1m]`, `claude-haiku-4-5-20251001`, etc.
+ *  - SDK tier aliases: `sonnet`, `opus`, `haiku` (no `[1m]` form for
+ *    tier aliases — they always resolve to standard context).
+ *  - Empty / unknown / non-Claude strings → `'other'` bucket.
+ */
+export function classifyBillingBucket(model) {
+    const m = String(model ?? '').toLowerCase().trim();
+    if (!m)
+        return OTHER;
+    const is1m = /\[1m\]/i.test(m);
+    // Tier aliases — no context-window suffix possible.
+    if (m === 'sonnet')
+        return SONNET_200K;
+    if (m === 'opus')
+        return OPUS_200K;
+    if (m === 'haiku')
+        return HAIKU;
+    // Full model IDs. Order matters — check opus before sonnet because
+    // "opusplan" contains "opus" but not "sonnet"; reverse would still be
+    // safe today, but explicit ordering is more robust to future names.
+    if (m.includes('opus'))
+        return is1m ? OPUS_1M : OPUS_200K;
+    if (m.includes('sonnet'))
+        return is1m ? SONNET_1M : SONNET_200K;
+    if (m.includes('haiku'))
+        return HAIKU; // 1M not supported on Haiku
+    return { ...OTHER, label: model || 'Unknown' };
+}
+/** Stable singletons so equality checks and bucket-key lookups are cheap. */
+const SONNET_200K = {
+    id: 'sonnet',
+    label: 'Sonnet (200K)',
+    family: 'sonnet',
+    context: '200k',
+    meteredOnMax: 'plan',
+};
+const SONNET_1M = {
+    id: 'sonnet-1m',
+    label: 'Sonnet (1M) — Extra Usage',
+    family: 'sonnet',
+    context: '1m',
+    meteredOnMax: 'extra',
+};
+const OPUS_200K = {
+    id: 'opus',
+    label: 'Opus (200K)',
+    family: 'opus',
+    context: '200k',
+    meteredOnMax: 'plan',
+};
+const OPUS_1M = {
+    id: 'opus-1m',
+    label: 'Opus (1M)',
+    family: 'opus',
+    context: '1m',
+    meteredOnMax: 'plan',
+};
+const HAIKU = {
+    id: 'haiku',
+    label: 'Haiku',
+    family: 'haiku',
+    context: '200k',
+    meteredOnMax: 'plan',
+};
+const OTHER = {
+    id: 'other',
+    label: 'Unknown',
+    family: 'other',
+    context: '200k',
+    meteredOnMax: 'plan',
+};
+/** Canonical render order for the dashboard panel. */
+export const BUCKET_DISPLAY_ORDER = [
+    'sonnet',
+    'haiku',
+    'opus',
+    'opus-1m',
+    'sonnet-1m', // Extra Usage stays last so it visually anchors the callout
+    'other',
+];
+/** Convenience: is this bucket on the Extra Usage path for Max plans? */
+export function isExtraUsage(bucket) {
+    return bucket.meteredOnMax === 'extra';
+}
+//# sourceMappingURL=billing-buckets.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.181",
+  "version": "1.18.183",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",