claudish 14.6.0 → 14.8.0

package/dist/index.js

@@ -114,6 +114,7 @@ var init_launch_env = __esm(() => {
     "CLAUDISH_PANE_CWD",
     "CLAUDISH_HOOK_INBOX",
     "CLAUDISH_HOOK_SESSION",
+    "CLAUDISH_PARENT_SESSION",
     "CLAUDISH_BIN"
   ];
 });
@@ -166,6 +167,7 @@ var init_config = __esm(() => {
     CLAUDISH_PANE_CHILD: "CLAUDISH_PANE_CHILD",
     CLAUDISH_PANE_ENV: "CLAUDISH_PANE_ENV",
     CLAUDISH_PANE_CWD: "CLAUDISH_PANE_CWD",
+    CLAUDISH_PARENT_SESSION: "CLAUDISH_PARENT_SESSION",
     CLAUDISH_PANE_ROOT: "CLAUDISH_PANE_ROOT"
   };
 });
@@ -216,7 +218,8 @@ function applyPaneEnvSnapshot(env) {
     ENV.CLAUDISH_PANE_CHILD,
     ENV.CLAUDISH_PANE_CWD,
     HOOK_INBOX_VAR,
-    HOOK_SESSION_VAR
+    HOOK_SESSION_VAR,
+    ENV.CLAUDISH_PARENT_SESSION
   ]);
   for (const key of Object.keys(env)) {
     if (Object.hasOwn(snapshot, key) || keep.has(key) || isPaneShellManagedKey(key))
@@ -298,7 +301,8 @@ var init_child_env = __esm(() => {
     ENV.CLAUDISH_PANE_ENV,
     ENV.CLAUDISH_PANE_CWD,
     HOOK_INBOX_VAR,
-    HOOK_SESSION_VAR
+    HOOK_SESSION_VAR,
+    ENV.CLAUDISH_PARENT_SESSION
   ];
   PANE_SHELL_MANAGED_KEYS = [
     "COLUMNS",
@@ -5394,7 +5398,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.6.0";
+var VERSION = "14.8.0";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -16038,7 +16042,7 @@ var init_minimax_model_dialect = __esm(() => {
 });
 
 // src/auth/accounts/allowance-report-schema.ts
-var ALLOWANCE_REPORT_SCHEMA = "claudish.allowance.v1", iso, fraction, finite, nonNegative, quantilesOf = (t) => object({ p10: t, p25: t, p50: t, p75: t, p90: t }), alertLevel, strategyName, evidence, unit, provenance, semantics, gapKind, exactness, accountSchema, remedySchema, alertSchema, trajectorySchema, sessionSchema, allowanceReportSchema, allowanceStatusAnswerSchema;
+var ALLOWANCE_REPORT_SCHEMA = "claudish.allowance.v1", iso, fraction, finite, nonNegative, quantilesOf = (t) => object({ p10: t, p25: t, p50: t, p75: t, p90: t }), alertLevel, strategyName, evidence, unit, provenance, semantics, gapKind, exactness, accountSchema, remedySchema, alertSchema, historyPoint, trajectorySchema, sessionSchema, allowanceReportSchema, ALLOWANCE_REPORT_SECTIONS, partialReport, allowanceStatusAnswerSchema;
 var init_allowance_report_schema = __esm(() => {
   init_zod();
   iso = exports_iso.datetime({ offset: true });
@@ -16068,7 +16072,10 @@ var init_allowance_report_schema = __esm(() => {
       semantics
     })),
     lambda: union([literal(0), literal(1)]).nullable(),
-    calibration: object({ beta: string2(), kappa: string2().nullable() })
+    calibration: object({ beta: string2(), kappa: string2().nullable() }),
+    active: boolean2().optional(),
+    order: number2().int().min(0).optional(),
+    lostAtReset: object({ at: iso, p10: fraction, p50: fraction, p90: fraction }).nullable().optional()
   });
   remedySchema = object({
     kind: _enum(["cut", "pause", "not-addressable"]),
@@ -16089,19 +16096,34 @@ var init_allowance_report_schema = __esm(() => {
     binding: array(object({ account: string2(), window: string2() })),
     remedy: remedySchema
   });
+  historyPoint = object({
+    at: iso,
+    remaining: finite,
+    provenance: _enum(["observed", "reset-inferred"])
+  });
   trajectorySchema = object({
-    history: array(object({
-      at: iso,
-      remaining: finite,
-      provenance: _enum(["observed", "reset-inferred"])
-    })),
+    history: array(historyPoint),
+    historyByAccount: array(object({ accountId: string2(), history: array(historyPoint) })).optional(),
     forecast: array(object({ at: iso, p10: finite, p50: finite, p90: finite, pBlocked: fraction })),
     resets: array(object({ at: iso, account: string2(), window: string2(), projected: boolean2() })),
     blocked: array(object({ from: iso, to: iso, kind: gapKind, probability: fraction })),
+    switches: array(object({
+      accountId: string2(),
+      soonest: iso,
+      usual: iso,
+      latest: iso,
+      probability: fraction,
+      likelihood: object({
+        start: iso,
+        stepHours: literal(1),
+        p: array(number2().min(0).max(1)).min(1)
+      }).optional()
+    })).optional(),
     spark48: string2().regex(/^[\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588\u2592\u2593\u250A ]*$/u)
   });
   sessionSchema = object({
     session: union([string2().max(8), literal("unattributed")]),
+    parent: union([string2().max(8), _null3()]).optional(),
     account: string2(),
     window: string2(),
     share: fraction,
@@ -16143,11 +16165,41 @@ var init_allowance_report_schema = __esm(() => {
     trajectory: trajectorySchema,
     sessions: array(sessionSchema)
   });
+  ALLOWANCE_REPORT_SECTIONS = [
+    "accounts",
+    "alerts",
+    "burn",
+    "combined",
+    "sessions",
+    "trajectory"
+  ];
+  partialReport = allowanceReportSchema.partial({
+    accounts: true,
+    alerts: true,
+    burn: true,
+    combined: true,
+    sessions: true,
+    trajectory: true
+  });
   allowanceStatusAnswerSchema = object({
     contract_version: literal(1),
     capabilities: array(string2()),
-    allowance: allowanceReportSchema.nullable(),
+    sections: array(_enum(ALLOWANCE_REPORT_SECTIONS)).min(1).optional(),
+    allowance: partialReport.nullable(),
     reason: string2().optional()
+  }).superRefine((answer, ctx) => {
+    if (answer.allowance === null)
+      return;
+    const wanted = answer.sections ?? ALLOWANCE_REPORT_SECTIONS;
+    for (const section of wanted) {
+      if (answer.allowance[section] === undefined) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["allowance", section],
+          message: `section ${section} is missing`
+        });
+      }
+    }
   });
 });
 
@@ -16599,7 +16651,7 @@ function cuOf(tokens, cfg) {
   const uncached = Math.max(0, tokens.input - tokens.cacheRead - tokens.cacheWrite);
   return uncached + w.cacheRead * tokens.cacheRead + w.cacheWrite * tokens.cacheWrite + w.output * tokens.output;
 }
-var PROVIDER_COST_PRIORS, MINUTE_MS2 = 60000, HOUR_MS2, DEFAULT_ALLOWANCE_CONFIG, LOOKAHEAD_TRAJ_PATHS = 40;
+var PROVIDER_COST_PRIORS, MINUTE_MS2 = 60000, HOUR_MS2, DEFAULT_ALLOWANCE_CONFIG, LOOKAHEAD_TRAJ_PATHS = 40, MIN_PATH_SHARE = 0.1, PACE_MAX_MULT = 64, PACE_BISECT_STEPS = 4;
 var init_constants = __esm(() => {
   PROVIDER_COST_PRIORS = {
     "openai-codex": { cacheRead: 0.1, cacheWrite: 1, output: 4 },
@@ -17092,7 +17144,7 @@ function fold(s, e, cfg, seen) {
         insertServed(account, e.at, cu);
         addDemand(s, hourOf(e.at), cu, 1);
         if (e.session !== null)
-          addSession(s, e.session, e.at, e.account, cu, e.tokens, e.model, 1);
+          addSession(s, e.session, e.at, e.account, cu, e.tokens, e.model, 1, e.parent ?? null);
       }
       if (e.outcome === "ok")
         closeCensor(s, e.at);
@@ -17141,13 +17193,13 @@ function fold(s, e, cfg, seen) {
       if (cu > 0) {
         insertServed(account, mid, cu);
         if (e.session !== null)
-          addSession(s, e.session, mid, e.account, cu, e.tokens, e.model, e.n);
+          addSession(s, e.session, mid, e.account, cu, e.tokens, e.model, e.n, e.parent ?? null);
       }
       const bucket = addDemand(s, e.hour, cu, e.n);
       bucket.censoredMinutes = Math.min(60, Math.max(bucket.censoredMinutes, e.censoredMinutes));
-      if (e.first !== null)
+      if (e.first !== null && e.n > 1)
         applySnapshot(account, e.hour, e.first, cfg);
-      if (e.last !== null && e.n > 1)
+      if (e.last !== null)
         applySnapshot(account, e.hour + HOUR_MS4 - 1, e.last, cfg);
       touch(s, e.hour + HOUR_MS4 - 1);
       return;
@@ -17225,7 +17277,7 @@ function sealCensor(s, from, to) {
     bucket.censoredMinutes = Math.min(60, Math.max(bucket.censoredMinutes, overlap / MINUTE_MS4));
   }
 }
-function addSession(s, session, at, account, cu, tokens, model, n) {
+function addSession(s, session, at, account, cu, tokens, model, n, parent) {
   let track = s.sessions[session];
   if (!track) {
     track = {
@@ -17250,6 +17302,8 @@ function addSession(s, session, at, account, cu, tokens, model, n) {
   track.tokens.cacheWrite += tokens.cacheWrite;
   track.tokens.output += tokens.output;
   track.models[model] = (track.models[model] ?? 0) + n;
+  if (parent !== null && (track.parent ?? null) === null)
+    track.parent = parent;
 }
 function applySnapshot(account, at, readings, cfg) {
   const current = account.lastCompleteAt === null || at >= account.lastCompleteAt;
@@ -19221,18 +19275,88 @@ function pauseGrid(horizonMs) {
     out.push(hours * HOUR_MS11);
   return out.filter((p) => p <= Math.max(horizonMs, HOUR_MS11));
 }
-function* remedyScan(ctx, rateLong, cfg) {
-  const zero = ctx.factors.map(() => 0);
-  const externalStarts = gapsOn(ctx, zero, cfg).filter((g) => g.kind === "7d" && g.lengthMs >= REMEDY_MIN_GAP_MS).map((g) => g.start);
-  yield;
+function* cutScan(ctx, rate, cfg) {
   let cut = null;
   for (const phi of CUT_GRID) {
-    const gs = gapsOn(ctx, ctx.factors.map((f) => phi * rateLong * f), cfg);
+    const gs = gapsOn(ctx, ctx.factors.map((f) => phi * rate * f), cfg);
     yield;
     if (hasGap(gs))
       break;
     cut = phi;
   }
+  return cut;
+}
+function refillThroughput(ctx) {
+  let total = 0;
+  for (const v of ctx.views.filter(isRead)) {
+    const g = v.windows.find((w) => w.key === v.governing);
+    if (!g || g.lengthMinutes === null || g.lengthMinutes <= 0)
+      continue;
+    const beta = ctx.unit === "cu" ? v.beta[g.key]?.value : undefined;
+    const capacity = beta !== undefined && beta > 0 ? 1 / beta : 1;
+    total += capacity / (g.lengthMinutes / 60);
+  }
+  return total;
+}
+function* paceScan(ctx, ev, rates, cfg) {
+  const rhoL = Number.isFinite(rates.long) && rates.long > 0 ? rates.long : 0;
+  if (rhoL > 0 && hasGap(ev.long)) {
+    const cut = yield* cutScan(ctx, rhoL, cfg);
+    return { rate: cut === null ? 0 : cut * rhoL, basis: "cut-scan" };
+  }
+  const anchor = Math.max(rhoL, refillThroughput(ctx));
+  if (!(anchor > 0) || !Number.isFinite(anchor))
+    return null;
+  const clean = (rho) => !hasGap(gapsOn(ctx, ctx.factors.map((f) => rho * f), cfg));
+  if (anchor > rhoL) {
+    const ok = clean(anchor);
+    yield;
+    if (!ok)
+      return { rate: yield* bisect(rhoL, anchor, clean), basis: "bisect" };
+  }
+  const up = yield* bracketUp(anchor, clean);
+  if (up.hi === null)
+    return { rate: up.lo, basis: "capped" };
+  return { rate: yield* bisect(up.lo, up.hi, clean), basis: "bracket" };
+}
+function* bracketUp(anchor, clean) {
+  let lo = anchor;
+  for (let mult = 2;mult <= PACE_MAX_MULT; mult *= 2) {
+    const ok = clean(mult * anchor);
+    yield;
+    if (!ok)
+      return { lo, hi: mult * anchor };
+    lo = mult * anchor;
+  }
+  return { lo, hi: null };
+}
+function* bisect(lo, hi, clean) {
+  let low = lo;
+  let high = hi;
+  for (let i = 0;i < PACE_BISECT_STEPS; i++) {
+    const mid = (low + high) / 2;
+    const ok = clean(mid);
+    yield;
+    if (ok)
+      low = mid;
+    else
+      high = mid;
+  }
+  return low;
+}
+function paceInCuPerHour(pace, burnLong) {
+  if (pace.phi !== null && Number.isFinite(burnLong) && burnLong > 0) {
+    return Math.max(0, pace.phi * burnLong);
+  }
+  if (pace.unit === "cu")
+    return Math.max(0, pace.rate);
+  return null;
+}
+function* remedyScan(ctx, rateLong, cfg) {
+  const zero = ctx.factors.map(() => 0);
+  const externalStarts = gapsOn(ctx, zero, cfg).filter((g) => g.kind === "7d" && g.lengthMs >= REMEDY_MIN_GAP_MS).map((g) => g.start);
+  yield;
+  const cut = yield* cutScan(ctx, rateLong, cfg);
   let pauseMs = null;
   const h0 = hourStart(ctx.now);
   for (const p of pauseGrid(ctx.horizonMs)) {
@@ -19273,6 +19397,25 @@ function remedyText(r, gapStart, formatTime) {
 function rateBin(n) {
   return Number.isFinite(n) && n > 0 ? String(Math.round(8 * Math.log2(n))) : "0";
 }
+function* paceFor(ctx, ev, rates, inputsKey, cfg, opts) {
+  if (!opts.pace || opts.payload === false)
+    return null;
+  const key = fnvHex([inputsKey, "pace"].join("|"));
+  if (opts.paceReuse?.key === key)
+    return opts.paceReuse;
+  const found = yield* paceScan(ctx, ev, rates, cfg);
+  if (found === null)
+    return null;
+  const simLong = rates.long;
+  return {
+    key,
+    rate: found.rate,
+    simLong,
+    phi: Number.isFinite(simLong) && simLong > 0 ? found.rate / simLong : null,
+    unit: ctx.unit,
+    basis: found.basis
+  };
+}
 function* alertsSliced(s, now, prior, cal, cfg, fc, opts = {}) {
   const base = prior ?? initialAlertMemory();
   if (evidenceOf(s, now) === "none") {
@@ -19281,7 +19424,8 @@ function* alertsSliced(s, now, prior, cal, cfg, fc, opts = {}) {
       active: [],
       transitions: [],
       blockedNow: false,
-      status: "insufficient-evidence"
+      status: "insufficient-evidence",
+      pace: null
     };
   }
   const ctx = gapContext(s, now, cal, cfg);
@@ -19318,7 +19462,8 @@ function* alertsSliced(s, now, prior, cal, cfg, fc, opts = {}) {
   const active = [];
   const raised = ["critical", "warn"].filter((l) => memory[l].raised);
   if (raised.length === 0 || opts.payload === false) {
-    return { memory, active, transitions, blockedNow, status: "ok" };
+    const pace = yield* paceFor(ctx, ev, rates, inputsKey, cfg, opts);
+    return { memory, active, transitions, blockedNow, status: "ok", pace };
   }
   const seed = seedOf(s, now, cfg);
   const key = fnvHex([inputsKey, seed, raised.join(","), alertPaths(cfg)].join("|"));
@@ -19360,9 +19505,10 @@ function* alertsSliced(s, now, prior, cal, cfg, fc, opts = {}) {
       remedy: r
     });
   }
-  return { memory, active, transitions, blockedNow, status: "ok", payload };
+  const pace = active.length === 0 ? yield* paceFor(ctx, ev, rates, inputsKey, cfg, opts) : null;
+  return { memory, active, transitions, blockedNow, status: "ok", payload, pace };
 }
-var HOUR_MS11 = 3600000, REMEDY_MIN_GAP_MS, CUT_GRID, MIN_PATH_SHARE = 0.1, EPISODE_BUCKET_MS;
+var HOUR_MS11 = 3600000, REMEDY_MIN_GAP_MS, CUT_GRID, EPISODE_BUCKET_MS;
 var init_alerts = __esm(() => {
   init_capacity();
   init_constants();
@@ -19613,6 +19759,7 @@ function contributions(s, q, cfg) {
     const share = calibrated ? observed > 0 ? r.fraction / observed : 0 : totalCu > 0 ? r.cu / totalCu : 0;
     return {
       session: r.session,
+      parent: track?.parent ?? null,
       account: r.accounts.size === 1 && single ? single.account : account,
       window: r.window,
       usedFraction: calibrated && single ? r.fraction : null,
@@ -19631,6 +19778,7 @@ function contributions(s, q, cfg) {
   const lasts = spent.map((x) => x.lastAt).filter((t) => t !== null);
   out.push({
     session: "unattributed",
+    parent: null,
     account,
     window: window2,
     usedFraction: calibrated && single ? unattributed : null,
@@ -19706,7 +19854,7 @@ function deliverableIn(view, unit) {
   const beta = view.governing === null ? undefined : view.beta[view.governing];
   return isStrong(beta) && beta.value > 0 ? d / beta.value : d;
 }
-function historyOf(s, views, now, unit) {
+function historyFrom(views, now) {
   let from = now - WEEK_MS4;
   for (const v of views) {
     const g = v.windows.find((w) => w.key === v.governing);
@@ -19714,23 +19862,38 @@ function historyOf(s, views, now, unit) {
       continue;
     from = Math.min(from, g.resetAt - g.lengthMinutes * MINUTE_MS10);
   }
+  return from;
+}
+function historyAt(s, views, t, unit, byAccount) {
+  let remaining = 0;
+  let any = false;
+  let inferred = false;
+  for (const v of views) {
+    const at = viewAt(s, v, t);
+    if (!at)
+      continue;
+    any = true;
+    inferred ||= at.inferred;
+    const own = deliverableIn(at.view, unit);
+    remaining += own;
+    byAccount[v.account]?.push({ at: t, remaining: own, provenance: provenanceOf(at.inferred) });
+  }
+  return any ? { at: t, remaining, provenance: provenanceOf(inferred) } : null;
+}
+function historyOf(s, views, now, unit) {
+  const from = historyFrom(views, now);
   const out = [];
+  const byAccount = {};
+  for (const v of views)
+    byAccount[v.account] = [];
   for (let t = now;t >= from; t -= HOUR_MS14) {
-    let remaining = 0;
-    let any = false;
-    let inferred = false;
-    for (const v of views) {
-      const at = viewAt(s, v, t);
-      if (!at)
-        continue;
-      any = true;
-      inferred ||= at.inferred;
-      remaining += deliverableIn(at.view, unit);
-    }
-    if (any)
-      out.push({ at: t, remaining, provenance: inferred ? "reset-inferred" : "observed" });
+    const point = historyAt(s, views, t, unit, byAccount);
+    if (point)
+      out.push(point);
   }
-  return out.reverse();
+  for (const list of Object.values(byAccount))
+    list.reverse();
+  return { history: out.reverse(), byAccount };
 }
 function resetsOf(views, now, end) {
   const out = [];
@@ -19779,13 +19942,115 @@ function blockedRuns(results, forecast) {
   }
   return out;
 }
+function firstTakeovers(r, from, now, end) {
+  const taken = new Map;
+  let prev = from;
+  for (const d of r.decisions) {
+    if (d.account === null || d.cu <= 0 || d.account === prev)
+      continue;
+    const switched = prev !== null;
+    prev = d.account;
+    if (!switched)
+      continue;
+    const t = Math.max(now, r.start + d.k * HOUR_MS14);
+    if (t > end)
+      break;
+    if (!taken.has(d.account))
+      taken.set(d.account, t);
+  }
+  return taken;
+}
+function likelihoodOf(times, q, h0, hours) {
+  const x = times.map((t) => (t - h0) / HOUR_MS14);
+  const n = x.length;
+  const mean = x.reduce((a, b) => a + b, 0) / Math.max(1, n);
+  const sd = Math.sqrt(x.reduce((a, b) => a + (b - mean) ** 2, 0) / Math.max(1, n - 1));
+  const iqr = (q.p75 - q.p25) / HOUR_MS14 / 1.34;
+  const spread = iqr > 0 ? Math.min(sd, iqr) : 0;
+  const bandwidth = 0.9 * spread * n ** -0.2;
+  const p = new Array(Math.max(0, hours)).fill(0);
+  if (bandwidth < MIN_BANDWIDTH_H) {
+    for (const xi of x) {
+      const i = Math.floor(xi);
+      if (i >= 0 && i < p.length)
+        p[i] = (p[i] ?? 0) + 1;
+    }
+  } else {
+    for (let i = 0;i < p.length; i++) {
+      let f = 0;
+      for (const xi of x)
+        f += Math.exp(-0.5 * ((i + 0.5 - xi) / bandwidth) ** 2);
+      p[i] = f;
+    }
+  }
+  const peak = Math.max(0, ...p);
+  return peak > 0 ? p.map((v) => v / peak) : p;
+}
+function switchesOf2(results, views, poolActive, now, end) {
+  const order = new Map(views.map((v, i) => [v.account, i]));
+  const from = poolActive !== null && order.has(poolActive) ? poolActive : null;
+  const times = new Map;
+  for (const r of results) {
+    for (const [account, t] of firstTakeovers(r, from, now, end)) {
+      const list = times.get(account) ?? [];
+      list.push(t);
+      times.set(account, list);
+    }
+  }
+  const paths = Math.max(1, results.length);
+  const h0 = hourStart(now);
+  const hours = Math.floor((end - h0) / HOUR_MS14) + 1;
+  const out = [];
+  for (const [account, list] of times) {
+    const probability = list.length / paths;
+    if (probability < MIN_PATH_SHARE)
+      continue;
+    const q = quantilesOf2(list);
+    out.push({
+      account,
+      q,
+      probability: Math.min(1, probability),
+      likelihood: { start: h0, p: likelihoodOf(list, q, h0, hours) }
+    });
+  }
+  return out.sort((a, b) => a.q.p50 - b.q.p50 || (order.get(a.account) ?? 0) - (order.get(b.account) ?? 0));
+}
+function lostAtResetOf(results, views) {
+  const out = {};
+  const paths = Math.max(1, results.length);
+  for (const v of views) {
+    const g = v.windows.find((w) => w.key === v.governing);
+    if (!g || g.remaining === null || g.resetAt === null || g.semantics === "sliding")
+      continue;
+    const values = [];
+    for (const r of results) {
+      const left = r.leftoverAtReset[v.account];
+      if (left !== null && left !== undefined && Number.isFinite(left)) {
+        values.push(Math.min(1, Math.max(0, left)));
+      }
+    }
+    if (values.length === 0 || values.length < MIN_PATH_SHARE * paths)
+      continue;
+    out[v.account] = { at: g.resetAt, q: quantilesOf2(values) };
+  }
+  return out;
+}
 function trajectory(s, now, horizonMs, cal, cfg) {
   const all = accountViews(s, now, cfg).filter(isRead);
   const unit = strongBetas(all) ? "cu" : "account-fraction";
-  const history = historyOf(s, all, now, unit);
+  const { history, byAccount: historyByAccount } = historyOf(s, all, now, unit);
   const end = now + Math.max(0, horizonMs);
   const resets = resetsOf(all, now, end);
-  const empty = { unit, history, forecast: [], resets, blocked: [] };
+  const empty = {
+    unit,
+    history,
+    forecast: [],
+    resets,
+    blocked: [],
+    switches: [],
+    lostAtReset: {},
+    historyByAccount
+  };
   if (evidenceOf(s, now) === "none" || all.length === 0)
     return empty;
   const views = unit === "cu" ? all : all.map(inFractions);
@@ -19823,7 +20088,16 @@ function trajectory(s, now, horizonMs, cal, cfg) {
     }
     forecast.push({ at, q: quantilesOf2(values), pBlocked: blocked / paths });
   }
-  return { unit, history, forecast, resets, blocked: blockedRuns(results, forecast) };
+  return {
+    unit,
+    history,
+    forecast,
+    resets,
+    blocked: blockedRuns(results, forecast),
+    switches: switchesOf2(results, views, s.poolActive ?? null, now, end),
+    lostAtReset: lostAtResetOf(results, views),
+    historyByAccount
+  };
 }
 function sparkline(t, cells) {
   const n = Math.max(0, Math.floor(cells));
@@ -19886,7 +20160,7 @@ function sparkline(t, cells) {
     return LEVELS[Math.max(0, level)] ?? " ";
   }).join("");
 }
-var MINUTE_MS10 = 60000, HOUR_MS14 = 3600000, WEEK_MS4, BLOCKED_SHARE = 0.5, WIDE_BAND = 0.15, LEVELS;
+var MINUTE_MS10 = 60000, HOUR_MS14 = 3600000, WEEK_MS4, BLOCKED_SHARE = 0.5, WIDE_BAND = 0.15, LEVELS, provenanceOf = (inferred) => inferred ? "reset-inferred" : "observed", MIN_BANDWIDTH_H = 0.5;
 var init_trajectory = __esm(() => {
   init_alerts();
   init_calibrate();
@@ -20032,6 +20306,9 @@ function buildResponseRow(input) {
     finalInTok: count(input.finalInput),
     windows: readingsOf(input.provider, input.usage)
   };
+  const parent = input.parent;
+  if (parent && SESSION_PATTERN.test(parent) && parent !== row.session)
+    row.parent = parent;
   return responseRowSchema.safeParse(row).success ? row : null;
 }
 function buildNoEligibleRow(provider, at) {
@@ -20085,7 +20362,8 @@ function toEvent(row) {
         tokens: tokensOf(row),
         finalInput: row.finalInTok,
         windows: row.windows,
-        outcome: row.outcome
+        outcome: row.outcome,
+        parent: row.parent ?? null
       };
     case "no-eligible":
       return row.until === undefined ? { kind: "no-eligible", at: row.at } : {
@@ -20106,7 +20384,8 @@ function toEvent(row) {
         tokens: { ...row.tokens },
         first: row.first,
         last: row.last,
-        censoredMinutes: row.censoredMinutes
+        censoredMinutes: row.censoredMinutes,
+        parent: row.parent ?? null
       };
   }
 }
@@ -20189,7 +20468,8 @@ var init_ledger_row = __esm(() => {
     cacheWriteTok: tokenCount,
     outTok: tokenCount,
     finalInTok: tokenCount,
-    windows: array(windowReadingSchema).max(16).nullable()
+    windows: array(windowReadingSchema).max(16).nullable(),
+    parent: string2().regex(SESSION_PATTERN).nullable().optional()
   });
   noEligibleRowSchema = object({
     v: literal(LEDGER_ROW_VERSION),
@@ -20218,7 +20498,8 @@ var init_ledger_row = __esm(() => {
     tokens: tokenCountsSchema,
     first: array(windowReadingSchema).max(16).nullable(),
     last: array(windowReadingSchema).max(16).nullable(),
-    censoredMinutes: number2().finite().min(0).max(60)
+    censoredMinutes: number2().finite().min(0).max(60),
+    parent: string2().regex(SESSION_PATTERN).nullable().optional()
   });
   ledgerRowSchema = discriminatedUnion("kind", [
     responseRowSchema,
@@ -20736,6 +21017,7 @@ function* rollupDaySteps(day, rows, openAtStart) {
       }
     }
     const hh = String(new Date(hour).getUTCHours()).padStart(2, "0");
+    const parent = group.find((r) => r.parent)?.parent ?? null;
     const rollup = {
       v: LEDGER_ROW_VERSION,
       kind: "rollup",
@@ -20754,7 +21036,8 @@ function* rollupDaySteps(day, rows, openAtStart) {
       },
       first: first.size > 0 ? [...first.values()] : null,
       last: last.size > 0 ? [...last.values()] : null,
-      censoredMinutes: censored.get(head.provider)?.get(hour) ?? 0
+      censoredMinutes: censored.get(head.provider)?.get(hour) ?? 0,
+      ...parent ? { parent } : {}
     };
     lines.push(JSON.stringify(rollup));
   }
@@ -21858,6 +22141,12 @@ function readAlertsFile(env) {
     return emptyAlertsFile();
   }
 }
+function delegatingSession(env) {
+  const value = env[ENV.CLAUDISH_PARENT_SESSION];
+  if (!value || !isPaneChild(env))
+    return null;
+  return SESSION_PATTERN.test(value) ? value : null;
+}
 
 class AllowanceService {
   env;
@@ -21870,9 +22159,12 @@ class AllowanceService {
   nextFlight = 0;
   threads = new Map;
   models = new Map;
+  reportStateStore = null;
+  parentSession;
   constructor(env = process.env, clock = Date.now) {
     this.env = env;
     this.clock = clock;
+    this.parentSession = delegatingSession(env);
   }
   record(attempt) {
     try {
@@ -21890,7 +22182,8 @@ class AllowanceService {
         outcome: attempt.outcome,
         tokens: attempt.tokens,
         finalInput: attempt.finalInput,
-        usage: attempt.usage
+        usage: attempt.usage,
+        parent: this.parentSession
       });
       if (!row) {
         this.warnOnce("a usage row failed its guards and was not written");
@@ -22070,9 +22363,21 @@ class AllowanceService {
       cal: m.cal,
       fc: m.fc,
       alerts: m.lastAlerts,
-      labels
+      labels,
+      poolActive: this.activeNow(provider, s)
     });
   }
+  activeNow(provider, s) {
+    try {
+      this.reportStateStore ??= new StateStore({ path: statePath(this.env) });
+      const read = this.reportStateStore.read();
+      if (read.kind === "failed")
+        return s.poolActive ?? null;
+      return read.state.providers[provider]?.active ?? null;
+    } catch {
+      return s.poolActive ?? null;
+    }
+  }
   modelFor(provider) {
     let m = this.models.get(provider);
     if (!m) {
@@ -22103,7 +22408,8 @@ class AllowanceService {
         sinks: new Set,
         label: undefined,
         payload: null,
-        lastAlerts: { active: [], blockedNow: false, status: "insufficient-evidence" }
+        pace: null,
+        lastAlerts: { active: [], blockedNow: false, status: "insufficient-evidence", pace: null }
       };
       this.models.set(provider, m);
     }
@@ -22296,14 +22602,21 @@ class AllowanceService {
     let won = [];
     let landed = null;
     for (let attempt = 0;attempt < ALERTS_CAS_ATTEMPTS && landed === null; attempt++) {
-      const result = await runSliced(alertsSliced(state, now, peek, m.cal, m.cfg, fc, { reuse: m.payload }));
+      const result = await runSliced(alertsSliced(state, now, peek, m.cal, m.cfg, fc, {
+        reuse: m.payload,
+        pace: !announce,
+        paceReuse: m.pace
+      }));
       if (result.payload)
         m.payload = result.payload;
+      if (result.pace)
+        m.pace = result.pace;
       if (!announce) {
         m.lastAlerts = {
           active: result.active,
           blockedNow: result.blockedNow,
-          status: result.status
+          status: result.status,
+          pace: result.pace
         };
         return [];
       }
@@ -22354,7 +22667,12 @@ class AllowanceService {
       log(`[allowance] ${provider}: the alert memory kept moving; step skipped`);
       return [];
     }
-    m.lastAlerts = { active: landed.active, blockedNow: landed.blockedNow, status: landed.status };
+    m.lastAlerts = {
+      active: landed.active,
+      blockedNow: landed.blockedNow,
+      status: landed.status,
+      pace: null
+    };
     const active = landed.active;
     const status = landed.status;
     const accounts = accountViews(m.state, now, m.cfg).length;
@@ -22490,19 +22808,37 @@ function poolRemaining(views) {
   }
   return { remainingNow: now.value, capacity, unit: now.unit };
 }
+function likelihoodView(l) {
+  const p = l.p.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 1000) / 1000);
+  const first = p.findIndex((v) => v > 0);
+  if (first < 0)
+    return;
+  let last = p.length - 1;
+  while (last > first && p[last] === 0)
+    last--;
+  return { start: iso2(l.start + first * HOUR_MS16), stepHours: 1, p: p.slice(first, last + 1) };
+}
+function sustainableOf(top, pace, burnLong) {
+  const long = Number.isFinite(burnLong) ? Math.max(0, burnLong) : 0;
+  if (top)
+    return top.remedy.kind === "cut" ? top.remedy.cutToFraction * long : 0;
+  return pace ? paceInCuPerHour(pace, long) : null;
+}
 function buildReport(input) {
   const { s, now, cfg, cal, fc } = input;
   const horizonMs = Math.min(168 * HOUR_MS16, Math.max(HOUR_MS16, input.horizonMs));
   const evidence = evidenceOf(s, now);
   const none = evidence === "none";
   const views = accountViews(s, now, cfg);
-  const traj = trajectory(s, now, horizonMs, cal, cfg);
+  const poolActive = input.poolActive !== undefined ? input.poolActive : s.poolActive ?? null;
+  const traj = trajectory({ ...s, poolActive }, now, horizonMs, cal, cfg);
   const unit = fc?.unit ?? traj.unit;
   const burn = none ? { long: 0, short: 0 } : burnRates(s, now, cal, cfg);
   const ledgerHours = ledgerDays(s, now) * 24;
   const label = (id) => input.labels.get(id) ?? id;
   const pool = poolRemaining(views);
   const top = input.alerts.active[0];
+  const status = none ? "insufficient-evidence" : input.alerts.status;
   const fmt = (at) => formatLocalTime(at);
   const report = {
     schema: ALLOWANCE_REPORT_SCHEMA,
@@ -22518,6 +22854,7 @@ function buildReport(input) {
     accounts: views.map((v) => {
       const g = v.governing === null ? undefined : v.beta[v.governing];
       const k = v.binding === null || v.binding === v.governing ? undefined : v.kappa[v.binding];
+      const lost = traj.lostAtReset[v.account];
       return {
         label: label(v.account),
         id: v.account,
@@ -22533,7 +22870,15 @@ function buildReport(input) {
           semantics: w.semantics
         })),
         lambda: null,
-        calibration: { beta: g?.quality ?? "prior", kappa: k?.quality ?? null }
+        calibration: { beta: g?.quality ?? "prior", kappa: k?.quality ?? null },
+        active: poolActive !== null && v.account === poolActive,
+        order: v.order,
+        lostAtReset: lost ? {
+          at: iso2(lost.at),
+          p10: Math.min(1, Math.max(0, lost.q.p10)),
+          p50: Math.min(1, Math.max(0, lost.q.p50)),
+          p90: Math.min(1, Math.max(0, lost.q.p90))
+        } : null
       };
     }),
     combined: {
@@ -22543,7 +22888,7 @@ function buildReport(input) {
     burn: {
       long: ledgerHours < cfg.BURN_LONG_HL_H ? null : burn.long,
       short: ledgerHours < cfg.BURN_SHORT_HL_H ? null : burn.short,
-      sustainable: top ? top.burn.sustainable : null,
+      sustainable: status === "ok" ? sustainableOf(top, input.alerts.pace ?? null, burn.long) : null,
       unit: "cu/h"
     },
     alerts: none ? [] : input.alerts.active.map((a) => {
@@ -22579,7 +22924,7 @@ function buildReport(input) {
       };
     }),
     blockedNow: none ? false : input.alerts.blockedNow,
-    status: none ? "insufficient-evidence" : input.alerts.status,
+    status,
     trajectory: {
       history: traj.history.map((h) => ({
         at: iso2(h.at),
@@ -22605,6 +22950,18 @@ function buildReport(input) {
         kind: b.kind,
         probability: b.probability
       })),
+      historyByAccount: none ? [] : views.filter((v) => traj.historyByAccount[v.account] !== undefined).map((v) => ({
+        accountId: v.account,
+        history: (traj.historyByAccount[v.account] ?? []).filter((h) => h.at >= now - 24 * HOUR_MS16).map((h) => ({ at: iso2(h.at), remaining: h.remaining, provenance: h.provenance }))
+      })),
+      switches: traj.switches.map((sw) => ({
+        accountId: sw.account,
+        soonest: iso2(sw.q.p10),
+        usual: iso2(sw.q.p50),
+        latest: iso2(sw.q.p90),
+        probability: Math.min(1, Math.max(0, sw.probability)),
+        likelihood: likelihoodView(sw.likelihood)
+      })),
       spark48: sparkline({
         ...traj,
         history: traj.history.filter((h) => h.at >= now - 24 * HOUR_MS16),
@@ -22613,6 +22970,7 @@ function buildReport(input) {
     },
     sessions: none ? [] : contributions(s, { now, window: "binding" }, cfg).map((c) => ({
       session: c.session === "unattributed" ? "unattributed" : c.session.slice(0, 8),
+      parent: c.parent === null ? null : c.parent.slice(0, 8),
       account: c.account === "all" ? "all" : label(c.account),
       window: c.window,
       share: Math.min(1, Math.max(0, c.share)),
@@ -22682,7 +23040,9 @@ function getAllowanceService() {
 }
 var THREAD_MAP_MAX = 512, THREAD_IDLE_MS, HOUR_MS16 = 3600000, DAY_MS6, LOAD_HISTORY_MS, LOAD_RAW_MS, LOAD_DEFER_MS = 1000, REFRESH_MIN_MS = 60000, SERVED_RECENTLY_MS, ALERTS_LOCK_WAIT_MS = 200, ALERTS_LOCK_STALE_MS = 1e4, ALERTS_CAS_ATTEMPTS = 3, IN_FLIGHT_MAX_MS, PENDING_MAX = 4096, LOAD_RETRY_MIN_MS = 60000, LOAD_RETRY_MAX_MS, ANNOUNCED_MAX = 256, CALENDAR_FUTURE_MS, DECLINE = () => null, iso2 = (at) => new Date(at).toISOString(), instance, safeRankerWarned = false;
 var init_allowance_service = __esm(() => {
+  init_config();
   init_logger();
+  init_child_env();
   init_allowance_report_schema();
   init_alerts();
   init_capacity();
@@ -90904,6 +91264,7 @@ function buildPaneEnv(input) {
     env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
   if (input.parentEnv.CLAUDE_CODE_NATIVE_CURSOR === undefined)
     env.CLAUDE_CODE_NATIVE_CURSOR = "1";
+  delete env[ENV.CLAUDISH_PARENT_SESSION];
   Object.assign(env, input.slotEnv);
   if (input.configFile !== null)
     env.CLAUDISH_CONFIG = input.configFile;
@@ -97980,7 +98341,8 @@ async function startModelsIn(flight, sessionPath, opts) {
             kind: "team",
             id: `${runId}:${e.id}`,
             role: kind === "judge" ? "judge" : "slot"
-          })
+          }),
+          ...opts.parentClaudeSessionId ? { [ENV.CLAUDISH_PARENT_SESSION]: opts.parentClaudeSessionId } : {}
         },
         shape: "one-shot",
         initialPrompt: inputContent,
@@ -98207,6 +98569,7 @@ async function judgeResponses(sessionPath, opts = {}) {
   await runModels(judgePath, {
     claudeFlags: opts.claudeFlags,
     kind: "judge",
+    ...opts.parentClaudeSessionId ? { parentClaudeSessionId: opts.parentClaudeSessionId } : {},
     ...opts.parentEnv ? { parentEnv: opts.parentEnv } : {},
     ...opts.paneTimings ? { paneTimings: opts.paneTimings } : {}
   });
@@ -99026,7 +99389,8 @@ class SessionManager {
         [ENV.CLAUDISH_TOKEN_FILE]: entry.tokenFile,
         [UPSTREAM_ERROR_LOG_ENV]: entry.upstreamErrorLogPath,
         ...entry.inboxPath ? { [HOOK_INBOX_ENV]: entry.inboxPath } : {},
-        [HOOK_SESSION_ENV]: JSON.stringify({ kind: "channel", id: info.sessionId, role: null })
+        [HOOK_SESSION_ENV]: JSON.stringify({ kind: "channel", id: info.sessionId, role: null }),
+        ...info.parentClaudeSessionId ? { [ENV.CLAUDISH_PARENT_SESSION]: info.parentClaudeSessionId } : {}
       },
       shape: info.shape,
       ...opts.prompt ? { initialPrompt: opts.prompt } : {},
@@ -100854,9 +101218,32 @@ async function allowanceStatus(horizonMs) {
     return { ...meta, allowance: null, reason: `the allowance report failed: ${message}` };
   }
 }
+function allowanceSectionsArg(value) {
+  if (value === undefined)
+    return;
+  const known = ALLOWANCE_REPORT_SECTIONS;
+  if (!Array.isArray(value) || value.length === 0)
+    throw new ContractErrorException("invalid_args", `'sections' must be a non-empty array of ${known.join(", ")}`);
+  for (const name of value) {
+    if (typeof name !== "string" || !known.includes(name))
+      throw new ContractErrorException("invalid_args", `'sections' has an unknown section ${JSON.stringify(name)}; known: ${known.join(", ")}`);
+  }
+  return [...new Set(value)].sort();
+}
+function allowanceSections(answer, sections) {
+  if (sections === undefined || answer.allowance === null)
+    return answer;
+  const dropped = new Set(ALLOWANCE_REPORT_SECTIONS.filter((section) => !sections.includes(section)));
+  const allowance = Object.fromEntries(Object.entries(answer.allowance).filter(([key]) => !dropped.has(key)));
+  const { contract_version, capabilities, ...rest } = answer;
+  return { contract_version, capabilities, sections, ...rest, allowance };
+}
 function contractAnswer(value) {
   return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }
+function compactAnswer(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
 function contractErrorAnswer(e) {
   const err = e instanceof ContractErrorException ? e : new ContractErrorException("invalid_args", e instanceof Error ? e.message : String(e));
   return {
@@ -101443,11 +101830,15 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
           models?.[givenModels?.indexOf(m) ?? -1] ?? m,
           level
         ])) : undefined;
+        const runsModels = mode === "run" || mode === "run-and-judge";
+        const runsJudges = mode === "judge" || mode === "run-and-judge";
+        const parentClaudeSessionId = runsModels || runsJudges ? await parentSessionForCall({ hostPid: sessionManager.hostPid }) : undefined;
         const runOpts = {
           requirePattern,
           minOutputBytes,
           claudeFlags: childFlags,
           efforts,
+          parentClaudeSessionId,
           onProgress: (u) => {
             ctx.reportProgress(`team: ${u.phase}`);
           }
@@ -101458,8 +101849,6 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
           const existing = join56(resolved, "input.md");
           return existsSync39(existing) ? readFileSync45(existing, "utf-8") : undefined;
         };
-        const runsModels = mode === "run" || mode === "run-and-judge";
-        const runsJudges = mode === "judge" || mode === "run-and-judge";
         const choice = modelChoiceStop([
           ...runsModels && givenModels && models ? givenModels.map((given, i) => ({ given, spec: models[i] })) : [],
           ...runsJudges && givenJudges && judges ? givenJudges.map((given, i) => ({ given, spec: judges[i] })) : []
@@ -101484,9 +101873,6 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
               requirePattern
             });
             setupSession(resolved, models, input);
-            const parentClaudeSessionId = await parentSessionForCall({
-              hostPid: sessionManager.hostPid
-            });
             const monitorRecord = sessionManager.recordTeamRun({
               teamPath: resolved,
               slots: models.length,
@@ -101539,7 +101925,11 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
             };
           }
           case "judge": {
-            const verdict = await judgeResponses(resolved, { judges, claudeFlags: childFlags });
+            const verdict = await judgeResponses(resolved, {
+              judges,
+              claudeFlags: childFlags,
+              parentClaudeSessionId
+            });
             const out = providerNote ? { ...verdict, provider_note: providerNote } : verdict;
             return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
           }
@@ -101557,7 +101947,11 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
             const handle = await startModels(resolved, runOpts);
             await handle.done;
             const run = teamRunRow(resolved, handle.runId);
-            const verdict = await judgeResponses(resolved, { judges, claudeFlags: childFlags });
+            const verdict = await judgeResponses(resolved, {
+              judges,
+              claudeFlags: childFlags,
+              parentClaudeSessionId
+            });
             return {
               content: [
                 {
@@ -101743,7 +102137,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "allowance_status",
-    description: "Report the local Codex account pool's allowance: {contract_version, capabilities, allowance, reason?}. `allowance` is the claudish.allowance.v1 report of THIS machine's claudish sessions (accounts, remaining capacity, burn rate, projected gaps with remedies, trajectory, per-session shares), or null with a `reason` when there is no account pool. Read-only; it sends nothing to any vendor.",
+    description: 'Report the local Codex account pool\'s allowance: {contract_version, capabilities, allowance, reason?}. `allowance` is the claudish.allowance.v1 report of THIS machine\'s claudish sessions (accounts, remaining capacity, burn rate, projected gaps with remedies, trajectory, per-session shares), or null with a `reason` when there is no account pool. `sections` limits the report to those parts (accounts, combined, burn, alerts, trajectory, sessions) beside its header, and the answer then lists them in `sections`; a frequent poll should pass ["accounts","burn","alerts"]. Read-only; it sends nothing to any vendor.',
     inputSchema: {
       type: "object",
       properties: {
@@ -101755,6 +102149,15 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
         horizon_hours: {
           type: "number",
           description: "Forecast horizon in hours, 1\u2013168 (default: 168)"
+        },
+        sections: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [...ALLOWANCE_REPORT_SECTIONS]
+          },
+          minItems: 1,
+          description: 'Report only these parts beside the header (default: all). Poll with ["accounts","burn","alerts"]; the trajectory and sessions are most of the bytes.'
         }
       }
     },
@@ -101767,7 +102170,8 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
         const hours = args.horizon_hours ?? 168;
         if (typeof hours !== "number" || !Number.isFinite(hours) || hours < 1 || hours > 168)
           throw new ContractErrorException("invalid_args", "'horizon_hours' must be a number from 1 to 168");
-        return contractAnswer(await allowanceStatus(hours * 3600000));
+        const sections = allowanceSectionsArg(args.sections);
+        return compactAnswer(allowanceSections(await allowanceStatus(hours * 3600000), sections));
       } catch (e) {
         return contractErrorAnswer(e);
       }
@@ -102241,6 +102645,7 @@ var init_mcp_server = __esm(() => {
   init_types3();
   init_base_api_format();
   init_model_catalog();
+  init_allowance_report_schema();
   init_prehydrate();
   init_prompt_role();
   init_fs_atomic();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "14.6.0",
+  "version": "14.8.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,10 +71,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "14.6.0",
-    "@claudish/magmux-darwin-x64": "14.6.0",
-    "@claudish/magmux-linux-arm64": "14.6.0",
-    "@claudish/magmux-linux-x64": "14.6.0"
+    "@claudish/magmux-darwin-arm64": "14.8.0",
+    "@claudish/magmux-darwin-x64": "14.8.0",
+    "@claudish/magmux-linux-arm64": "14.8.0",
+    "@claudish/magmux-linux-x64": "14.8.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",