kiosko-plugin-agents 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1485 @@
+import { createRequire as __pluginRequire } from 'node:module'; const require = __pluginRequire(import.meta.url);
+
+// src/index.ts
+import { defineInterlude, definePlugin, defineSource, defineWidget, t } from "@kiosko/sdk";
+
+// src/demo.ts
+var s = (n) => n * 1e3;
+var min = (n) => n * 6e4;
+function rec(spec, now) {
+  return {
+    schemaVersion: 1,
+    session_id: spec.id,
+    provider: spec.provider ?? "claude",
+    state: spec.state,
+    detail: spec.detail,
+    project: spec.project,
+    cwd: `/home/user/dev/${spec.project}`,
+    since: now - spec.ago,
+    updated: now - (spec.updatedAgo ?? spec.ago),
+    event: "PreToolUse",
+    ...spec.dirty !== void 0 ? { dirty: spec.dirty } : {}
+  };
+}
+function scenario(name, now) {
+  const r = (spec) => rec(spec, now);
+  switch (name) {
+    case "empty":
+      return [];
+    case "one":
+      return [r({ id: "a1b2c3d4-1111", project: "api-gateway", state: "active", detail: "Edit src/routes/orders.ts", ago: s(12), dirty: 4 })];
+    case "two":
+      return [
+        r({ id: "a1b2c3d4-1111", project: "web-app", state: "permission", detail: "Bash: npm publish", ago: min(2) + s(18), dirty: 3 }),
+        r({ id: "b2c3d4e5-2222", project: "api-gateway", state: "active", detail: "Read src/adapters/payments/client.ts", ago: s(24), dirty: 0 })
+      ];
+    case "threeClaim":
+      return [
+        r({ id: "a1b2c3d4-1111", project: "infra", state: "permission", detail: "Bash: sudo systemctl restart nginx --no-block", ago: min(3) + s(41), dirty: 2 }),
+        r({ id: "b2c3d4e5-2222", project: "web-app", state: "waiting", detail: "Waiting for your input", ago: min(18) + s(7), dirty: 11, provider: "gemini" }),
+        r({ id: "c3d4e5f6-3333", project: "api-gateway", state: "ready", detail: "Stop", ago: min(1) + s(4), dirty: 0, provider: "gemini" }),
+        r({ id: "d4e5f6a7-4444", project: "docs-site", state: "active", detail: 'Grep "createServer"', ago: s(9), dirty: 1 })
+      ];
+    case "quiet":
+      return [
+        r({ id: "b8c9d0e1-8888", project: "api-gateway", state: "active", detail: "Bash: npm run build", ago: s(31), dirty: 6 }),
+        r({ id: "c9d0e1f2-9999", project: "web-app", state: "idle", detail: "SessionStart", ago: min(42), dirty: 0, provider: "gemini" })
+      ];
+    case "longNames":
+      return [
+        r({ id: "e5f6a7b8-5555", project: "infrastructure-terraform-production", state: "permission", detail: "Write /etc/systemd/system/app-worker.service with a rather long unit file that will not fit", ago: min(7) + s(22), dirty: 37 }),
+        r({ id: "f6a7b8c9-6666", project: "frontend-monorepo-customer-portal", state: "ready", detail: "SubagentStop", ago: min(2), dirty: 0, provider: "gemini" }),
+        r({ id: "a7b8c9d0-7777", project: "x", state: "active", detail: "Read package.json", ago: s(3), dirty: 0 })
+      ];
+    case "overflow":
+      return [
+        r({ id: "d0e1f2a3-aaaa", project: "infra", state: "permission", detail: "Bash: kubectl rollout restart deploy/api", ago: min(5) + s(13), dirty: 2 }),
+        r({ id: "e1f2a3b4-bbbb", project: "web-app", state: "waiting", detail: "idle_prompt", ago: min(11), dirty: 11, provider: "gemini" }),
+        r({ id: "f2a3b4c5-cccc", project: "api-gateway", state: "waiting", detail: "permission needed for MCP", ago: min(4) + s(51), dirty: 3 }),
+        r({ id: "a3b4c5d6-dddd", project: "docs-site", state: "ready", detail: "Stop", ago: s(48), dirty: 1, provider: "gemini" }),
+        r({ id: "b4c5d6e7-eeee", project: "notes", state: "ready", detail: "Stop", ago: min(3), dirty: 0 }),
+        r({ id: "c5d6e7f8-ffff", project: "scraper", state: "active", detail: "WebFetch example.com", ago: s(6), dirty: 0, provider: "gemini" }),
+        r({ id: "d6e7f8a9-0001", project: "bench", state: "active", detail: "Bash: pytest -q", ago: s(22), dirty: 4 }),
+        r({ id: "e7f8a9b0-0002", project: "archive", state: "idle", detail: "SessionStart", ago: min(30), dirty: 0, provider: "gemini" })
+      ];
+    case "meeting":
+      return [
+        {
+          schemaVersion: 1,
+          session_id: "meeting-1",
+          provider: "calendar",
+          state: "waiting",
+          detail: "",
+          project: "Architecture review",
+          since: now + min(4),
+          updated: now,
+          event: "Meeting",
+          startsAt: now + min(4),
+          endsAt: now + min(64)
+        },
+        r({ id: "a1b2c3d4-1111", project: "web-app", state: "permission", detail: "Bash: npm publish", ago: min(2), dirty: 3 }),
+        r({ id: "b2c3d4e5-2222", project: "api-gateway", state: "active", detail: "Read src/transport.ts", ago: s(24), dirty: 0 })
+      ];
+  }
+}
+var DEMO_VITALS = {
+  cpuTemp: 61,
+  cpuUsage: 0.23,
+  mem: { used: 44 * 1024 ** 3, total: 62 * 1024 ** 3 }
+};
+
+// ../../kiosko/packages/agent-sessions/src/protocol.ts
+var SCHEMA_VERSION = 1;
+var SESSION_STATES = ["permission", "waiting", "ready", "active", "idle"];
+var STATE_PRIORITY = {
+  permission: 4,
+  waiting: 3,
+  ready: 2,
+  active: 1,
+  idle: 0
+};
+var CLAIMS = /* @__PURE__ */ new Set(["permission", "waiting", "ready"]);
+function isSessionRecord(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const r = x;
+  return r.schemaVersion === SCHEMA_VERSION && typeof r.session_id === "string" && typeof r.provider === "string" && SESSION_STATES.includes(r.state) && typeof r.detail === "string" && typeof r.project === "string" && typeof r.since === "number" && typeof r.updated === "number" && typeof r.event === "string";
+}
+
+// ../../kiosko/packages/agent-sessions/src/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function defaultSessionsDir(env = process.env) {
+  return env.AGENT_SESSIONS_DIR ?? join(env.AIMONITOR_DIR ?? join(homedir(), ".aimonitor"), "sessions");
+}
+function sessionFile(dir, sessionId) {
+  return join(dir, `${sessionId}.json`);
+}
+
+// ../../kiosko/packages/agent-sessions/src/reader.ts
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// ../../kiosko/packages/agent-sessions/src/select.ts
+function claims(r) {
+  return CLAIMS.has(r.state);
+}
+function pruneZombies(records, now, zombieMs, staleMs) {
+  return records.filter((r) => now - r.updated <= (r.state === "active" ? zombieMs : staleMs));
+}
+function order(records) {
+  return [...records].sort((a, b) => {
+    const ca = claims(a) ? 1 : 0;
+    const cb = claims(b) ? 1 : 0;
+    if (ca !== cb) return cb - ca;
+    const pa = STATE_PRIORITY[a.state];
+    const pb = STATE_PRIORITY[b.state];
+    if (pa !== pb) return pb - pa;
+    if (ca === 1) return a.since - b.since;
+    return b.updated - a.updated;
+  });
+}
+
+// ../../kiosko/packages/agent-sessions/src/reader.ts
+function readSessions(dir = defaultSessionsDir()) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const rec2 = JSON.parse(readFileSync(join2(dir, name), "utf8"));
+      if (isSessionRecord(rec2)) out.push(rec2);
+    } catch {
+    }
+  }
+  return out;
+}
+function reap(records, now, o, dir = defaultSessionsDir(), onReap = () => {
+}) {
+  const alive = pruneZombies(records, now, o.zombieMs, o.staleMs);
+  if (alive.length === records.length) return alive;
+  const keep = new Set(alive.map((r) => r.session_id));
+  for (const r of records) {
+    if (keep.has(r.session_id)) continue;
+    try {
+      rmSync(sessionFile(dir, r.session_id), { force: true });
+      onReap(r);
+    } catch {
+    }
+  }
+  return alive;
+}
+
+// ../../kiosko/packages/agent-sessions/src/craft.ts
+function longestDefinition(text) {
+  const lines = text.split("\n");
+  const START = /^(export\s+)?(default\s+)?(async\s+)?(function\b|def\s|fn\s|func\s|class\s|const\s+\w+\s*=\s*(async\s*)?\(|(public|private|protected|static)\s)/;
+  let best = 0, from = -1;
+  lines.forEach((l, i) => {
+    if (START.test(l)) {
+      if (from >= 0) best = Math.max(best, i - from);
+      from = i;
+    }
+  });
+  if (from >= 0) best = Math.max(best, lines.length - from);
+  return best;
+}
+var SPAGHETTI_LINES = 500;
+
+// ../../kiosko/packages/agent-sessions/src/providers.ts
+var ALIASES = {};
+function generic(provider) {
+  return (data, cwd) => {
+    const raw = data.hook_event_name || data.event || data.type || "";
+    return {
+      event: ALIASES[provider]?.[raw] ?? raw,
+      sessionId: data.session_id || data.sessionId || "global",
+      cwd: data.cwd || cwd,
+      tool: String(data.tool_name ?? data.tool?.name ?? data.tool ?? ""),
+      toolInput: data.tool_input ?? data.tool?.arguments,
+      toolResponse: data.tool_response,
+      source: String(data.source ?? data.session_start_type ?? ""),
+      notification: String(data.notification_type ?? data.notificationType ?? data.message ?? ""),
+      prompt: String(data.prompt ?? ""),
+      lastMessage: String(data.last_assistant_message ?? ""),
+      fallback: String(data.detail ?? data.message ?? data.command ?? "")
+    };
+  };
+}
+var PROVIDERS = {
+  claude: { name: "claude", normalize: generic("claude") },
+  gemini: { name: "gemini", normalize: generic("gemini") }
+};
+
+// src/format.ts
+function elapsed(fmt, ms, nowWord) {
+  return ms < 6e4 ? nowWord : fmt.duration(ms);
+}
+function shortId(sessionId) {
+  return sessionId.replace(/-/g, "").slice(0, 6).toUpperCase();
+}
+function gigabytes(bytes) {
+  return `${Math.round(bytes / 1024 ** 3)}GB`;
+}
+
+// src/select.ts
+function assignWeights(ordered) {
+  const claiming = ordered.filter(claims);
+  const winner = claiming.find((r) => r.startsAt !== void 0) ?? claiming[0];
+  return ordered.map((record) => {
+    if (!claims(record)) return { record, weight: "quiet" };
+    return { record, weight: record === winner ? "solid" : "marked" };
+  });
+}
+function plan(records, available, o) {
+  const { min: min2, max, gap, summaryWidth } = o;
+  const all = assignWeights(order(records));
+  const fits = (n, reserve2) => (available - reserve2 - (n - 1) * gap) / n >= min2;
+  let visible = o.maxTiles && o.maxTiles > 0 ? Math.min(all.length, Math.floor(o.maxTiles)) : all.length;
+  let reserve = visible < all.length ? summaryWidth + gap : 0;
+  while (visible > 1 && !fits(visible, reserve)) {
+    visible--;
+    reserve = summaryWidth + gap;
+  }
+  if (visible < all.length && reserve === 0) reserve = summaryWidth + gap;
+  const cap = visible < all.length ? Infinity : max;
+  const tileWidth = Math.max(0, Math.min(cap, Math.floor((available - reserve - (visible - 1) * gap) / Math.max(1, visible))));
+  return {
+    tiles: all.slice(0, visible),
+    overflow: all.slice(visible).map((t2) => t2.record),
+    tileWidth,
+    summaryWidth: visible < all.length ? summaryWidth : 0
+  };
+}
+function usedWidth(p, gap) {
+  const tiles = p.tiles.length * p.tileWidth + Math.max(0, p.tiles.length - 1) * gap;
+  return tiles + (p.summaryWidth ? (p.tiles.length ? gap : 0) + p.summaryWidth : 0);
+}
+function spareWidth(p, available, gap) {
+  const used = p.tiles.length * p.tileWidth + Math.max(0, p.tiles.length - 1) * gap;
+  return available - used - (p.summaryWidth ? p.summaryWidth + gap : 0);
+}
+
+// src/texts.ts
+var STATE_LABEL = {
+  permission: { en: "Permission", es: "Permiso" },
+  waiting: { en: "Waiting", es: "Espera" },
+  ready: { en: "Ready", es: "Listo" },
+  active: { en: "Active", es: "Activa" },
+  idle: { en: "Idle", es: "Inactiva" }
+};
+var TEXT = {
+  now: { en: "now", es: "ahora" },
+  meeting: { en: "Meeting", es: "Reuni\xF3n" },
+  gitClean: { en: "git clean", es: "git limpio" },
+  gitDirty: { en: "git {n} uncommitted", es: "git {n} sin commit" },
+  more: { en: "+{n} more", es: "+{n} m\xE1s" },
+  consoles: { en: "{n} consoles", es: "{n} consolas" },
+  console: { en: "1 console", es: "1 consola" },
+  waitingMany: { en: "{n} waiting for you", es: "{n} te esperan" },
+  waitingOne: { en: "1 waiting for you", es: "1 te espera" },
+  nobody: { en: "nobody waiting", es: "nadie espera" },
+  noSessions: { en: "No agent sessions", es: "Sin sesiones de agentes" }
+};
+function fill(text, vars) {
+  return text.replace(/\{(\w+)\}/g, (_, k) => String(vars[k] ?? ""));
+}
+
+// src/types.ts
+import { matchFilter } from "@kiosko/sdk";
+var SESSIONS_SOURCE = "agents/sessions";
+function sessionsOf(sources) {
+  const data = sources[SESSIONS_SOURCE];
+  return Array.isArray(data?.sessions) ? data.sessions : [];
+}
+function filterSessions(sessions, f) {
+  const hidden = new Set(f.hideStates ?? []);
+  return sessions.filter((s2) => {
+    if (hidden.has(s2.state)) return false;
+    if (s2.startsAt !== void 0) return true;
+    return matchFilter([s2.project, s2.repo, s2.cwd].filter((v) => !!v), f.projects);
+  });
+}
+function needsPermission(sessions) {
+  return sessions.some((s2) => s2.state === "permission");
+}
+
+// src/draw.ts
+var REF_H = 374;
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function stateColor(state, c) {
+  switch (state) {
+    case "permission":
+      return c.alert;
+    case "waiting":
+      return c.warn;
+    case "ready":
+      return c.info;
+    case "active":
+      return c.ok;
+    default:
+      return c.inkDim;
+  }
+}
+function alpha(kit, color, a) {
+  return /^#[0-9a-f]{6}$/i.test(color) ? kit.css(kit.hex(color), a) : color;
+}
+function inks(kit, weight, state, c) {
+  if (weight === "solid") {
+    return { strong: c.bg, mid: alpha(kit, c.bg, 0.78), faint: alpha(kit, c.bg, 0.55), rule: alpha(kit, c.bg, 0.28), accent: c.bg };
+  }
+  if (weight === "marked") return { strong: c.ink, mid: c.inkDim, faint: c.inkFaint, rule: c.surfaceEdge, accent: stateColor(state, c) };
+  return { strong: c.inkDim, mid: c.inkFaint, faint: c.inkFaint, rule: c.surfaceEdge, accent: c.inkFaint };
+}
+function hairline(g, x, y, w, color) {
+  g.fillStyle = color;
+  g.fillRect(x, Math.round(y), w, 1);
+}
+function drawTile(g, ctx, tile, x, y, w, h, st) {
+  const { kit, theme, now, t: t2, fmt } = ctx;
+  const c = theme.colors;
+  const f = theme.fonts;
+  const { record: r, weight } = tile;
+  const color = stateColor(r.state, c);
+  const ink = inks(kit, weight, r.state, c);
+  const s2 = st.s;
+  const fs = clamp(Math.min(s2, s2 * w / st.designW), 0.4, 2);
+  const spine = Math.max(3, Math.round(st.spineWidth * fs));
+  if (weight === "solid") {
+    g.fillStyle = color;
+    g.fillRect(x, y, w, h);
+  } else {
+    g.fillStyle = c.surface;
+    g.fillRect(x, y, w, h);
+    g.strokeStyle = c.surfaceEdge;
+    g.lineWidth = 1;
+    g.strokeRect(x + 0.5, y + 0.5, w - 1, h - 1);
+    if (weight === "marked") {
+      g.fillStyle = color;
+      g.fillRect(x, y, spine, h);
+    }
+  }
+  const pad = Math.round(18 * fs);
+  const padL = weight === "marked" ? spine + Math.round(15 * fs) : pad;
+  const cx = x + padL;
+  const cw = Math.max(10, w - padL - pad);
+  const meeting = r.startsAt !== void 0;
+  const labelOpts = { size: Math.max(11, Math.round(21 * fs)), family: f.sansBold, tracking: 3.6 * fs, smallCaps: true, color: ink.accent };
+  const label = kit.truncate(g, t2(meeting ? TEXT.meeting : STATE_LABEL[r.state]), cw, labelOpts);
+  const labelW = kit.drawTracked(g, label, cx, y + 32 * s2, labelOpts);
+  const idOpts = { size: Math.max(10, Math.round(15 * fs)), family: f.mono, color: ink.faint, align: "right" };
+  const ids = meeting ? [fmt.time(r.startsAt)] : st.showId ? [`${String(r.provider).toUpperCase()} \xB7 ${shortId(r.session_id)}`, shortId(r.session_id)] : [];
+  const id = ids.find((txt) => kit.measureTracked(g, txt, idOpts) <= cw - labelW - 12 * fs);
+  if (id) kit.drawTracked(g, id, x + w - pad, y + 31 * s2, idOpts);
+  hairline(g, cx, y + 46 * s2, cw, ink.rule);
+  const footerBase = y + h - 16 * s2;
+  const elapsedSize = Math.round(52 * fs);
+  const elapsedBase = footerBase - 26 * s2;
+  const big = !meeting ? elapsed(fmt, now - r.since, t2(TEXT.now)) : r.startsAt <= now ? t2(TEXT.now) : fmt.duration(r.startsAt - now, { round: "up" });
+  const bigOpts = { size: elapsedSize, family: f.monoBold, color: ink.strong, tracking: -1 * fs };
+  kit.drawClipped(g, big, cx, elapsedBase, cw, bigOpts);
+  const detailOpts = { size: Math.max(10, Math.round(17 * fs)), family: f.mono, color: ink.mid };
+  const lead = Math.round(detailOpts.size * 1.35);
+  const detailBase = elapsedBase - elapsedSize * 0.8 - 14 * s2;
+  const midTop = y + 54 * s2;
+  const projMax = Math.round(48 * fs);
+  const projMin = Math.max(12, Math.round(26 * fs));
+  let maxLines = Math.max(0, st.detailLines);
+  while (maxLines > 1 && detailBase - (maxLines - 1) * lead - 24 * s2 - midTop < projMin * 0.9) maxLines--;
+  const lines = maxLines > 0 && r.detail ? kit.wrapLines(g, r.detail, cw, maxLines, detailOpts) : [];
+  lines.forEach((line, i) => kit.drawTracked(g, line, cx, detailBase - (lines.length - 1 - i) * lead, detailOpts));
+  const detailTop = detailBase - Math.max(0, lines.length - 1) * lead;
+  const midBottom = maxLines > 0 ? detailTop - 24 * s2 : detailBase;
+  const projOpts = { size: projMax, family: f.sansBold, color: ink.strong, tracking: 0.5 * fs };
+  projOpts.size = Math.min(kit.fitSize(g, r.project, cw, projOpts, projMin), Math.max(projMin, Math.floor((midBottom - midTop) / 0.8)));
+  const projBase = Math.round((midTop + midBottom) / 2 + projOpts.size * 0.36);
+  kit.drawClipped(g, r.project, cx, projBase, cw, projOpts);
+  if (st.showGit && r.dirty !== void 0) {
+    const txt = r.dirty === 0 ? t2(TEXT.gitClean) : fill(t2(TEXT.gitDirty), { n: r.dirty });
+    kit.drawClipped(g, txt, cx, footerBase, cw, { size: Math.max(10, Math.round(16 * fs)), family: f.mono, color: ink.faint });
+  }
+}
+function drawOverflow(g, ctx, rest, x, y, w, h, s2) {
+  const { kit, theme, t: t2 } = ctx;
+  const c = theme.colors;
+  const f = theme.fonts;
+  g.fillStyle = c.surface;
+  g.fillRect(x, y, w, h);
+  g.strokeStyle = c.surfaceEdge;
+  g.lineWidth = 1;
+  g.strokeRect(x + 0.5, y + 0.5, w - 1, h - 1);
+  const pad = Math.round(16 * s2);
+  const cx = x + pad;
+  const cw = Math.max(10, w - 2 * pad);
+  const headOpts = { size: Math.max(11, Math.round(21 * s2)), family: f.sansBold, tracking: 3.6 * s2, smallCaps: true, color: c.inkDim };
+  kit.drawClipped(g, fill(t2(TEXT.more), { n: rest.length }), cx, y + 32 * s2, cw, headOpts);
+  hairline(g, cx, y + 46 * s2, cw, c.surfaceEdge);
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of rest) counts.set(r.state, (counts.get(r.state) ?? 0) + 1);
+  const box = Math.max(5, Math.round(9 * s2));
+  const countOpts = { size: Math.max(10, Math.round(17 * s2)), family: f.monoBold, color: c.inkDim, align: "right" };
+  const labelOpts = { size: Math.max(10, Math.round(16 * s2)), family: f.sansBold, tracking: 2 * s2, smallCaps: true, color: c.inkDim };
+  let ry = y + 78 * s2;
+  for (const [state, n] of [...counts].sort((a, b) => b[1] - a[1])) {
+    if (ry > y + h - 6 * s2) break;
+    g.fillStyle = stateColor(state, c);
+    g.fillRect(cx, ry - box, box, box);
+    const countW = kit.drawTracked(g, String(n), x + w - pad, ry, countOpts);
+    const lx = cx + box + Math.round(8 * s2);
+    kit.drawClipped(g, t2(STATE_LABEL[state]), lx, ry, Math.max(0, x + w - pad - countW - 6 * s2 - lx), labelOpts);
+    ry += 28 * s2;
+  }
+}
+function drawQuiet(g, ctx, text) {
+  const { box, kit, theme, t: t2 } = ctx;
+  const size = clamp(Math.round(box.h * 0.08), 12, 26);
+  const o = { size, family: theme.fonts.sansBold, tracking: size * 0.15, smallCaps: true, color: theme.colors.inkFaint, align: "center" };
+  kit.drawTracked(g, kit.truncate(g, t2(text), box.w, o), box.x + box.w / 2, box.y + box.h / 2 + size * 0.36, o);
+}
+function drawSessions(g, ctx, o) {
+  const { box } = ctx;
+  const sessions = filterSessions(sessionsOf(ctx.sources), o);
+  if (!sessions.length) {
+    drawQuiet(g, ctx, TEXT.noSessions);
+    return;
+  }
+  const s2 = clamp(box.h / REF_H, 0.5, 1.6);
+  const gap = Math.max(2, Math.round(o.gap * s2));
+  const designW = o.tileMin * s2;
+  const max = o.tileMax > 0 ? Math.max(o.tileMin, o.tileMax) * s2 : Infinity;
+  const p = plan(sessions, box.w, { min: designW, max, gap, summaryWidth: Math.round(o.summaryWidth * s2), maxTiles: o.maxTiles });
+  const free = box.w - usedWidth(p, gap);
+  let x = Math.round(box.x + (o.align === "center" ? free / 2 : o.align === "right" ? free : 0));
+  const st = { s: s2, designW, spineWidth: o.spineWidth, detailLines: o.detailLines, showGit: o.showGit, showId: o.showId };
+  for (const tile of p.tiles) {
+    drawTile(g, ctx, tile, x, box.y, p.tileWidth, box.h, st);
+    x += p.tileWidth + gap;
+  }
+  if (p.overflow.length) drawOverflow(g, ctx, p.overflow, x, box.y, p.summaryWidth, box.h, s2);
+}
+function drawSummaryStrip(g, ctx, o) {
+  const { box, kit, theme, now, t: t2, fmt, sources } = ctx;
+  const c = theme.colors;
+  const f = theme.fonts;
+  const sessions = filterSessions(sessionsOf(sources), o);
+  const s2 = clamp(Math.min(box.h / 56, box.w / 900), 0.4, 2);
+  const ruleH = o.showRule ? 1 : 0;
+  const mid = box.y + (box.h - ruleH) / 2;
+  let right = box.x + box.w;
+  if (o.showClock) {
+    const cs = Math.max(10, Math.round(30 * s2));
+    const cw = kit.drawTracked(g, fmt.time(now), right, mid + cs * 0.36, { size: cs, family: f.monoBold, color: c.ink, align: "right" });
+    right -= cw + Math.round(24 * s2);
+  }
+  const parts = [];
+  const mem = sources["system/vitals"]?.mem;
+  if (o.showRam && mem && mem.total > 0) {
+    parts.push({ text: `RAM: ${gigabytes(mem.used)}/${gigabytes(mem.total)}`, color: c.ink, keep: 0 });
+  }
+  const n = sessions.length;
+  if (o.showConsoles) parts.push({ text: n === 1 ? t2(TEXT.console) : fill(t2(TEXT.consoles), { n }), color: c.inkDim, keep: 1 });
+  const waiting = sessions.filter(claims);
+  const urgent = [...waiting].sort((a, b) => STATE_PRIORITY[b.state] - STATE_PRIORITY[a.state])[0];
+  const waitText = waiting.length === 0 ? t2(TEXT.nobody) : waiting.length === 1 ? t2(TEXT.waitingOne) : fill(t2(TEXT.waitingMany), { n: waiting.length });
+  parts.push({ text: waitText, color: urgent ? stateColor(urgent.state, c) : c.inkFaint, keep: 2 });
+  const dot = " \xB7 ";
+  let size = Math.max(10, Math.round(22 * s2));
+  const label = () => ({ size, family: f.sansBold, tracking: 3.4 * (size / 22), smallCaps: true });
+  const width = (ps) => ps.reduce((a, p, i) => a + kit.measureTracked(g, p.text, label()) + (i ? kit.measureTracked(g, dot, label()) : 0), 0);
+  const room = right - box.x;
+  while (parts.length > 1 && width(parts) > room) parts.splice(parts.findIndex((p) => p.keep === Math.min(...parts.map((q) => q.keep))), 1);
+  while (size > 10 && width(parts) > room) size--;
+  let x = box.x;
+  const base = mid + size * 0.36;
+  parts.forEach((p, i) => {
+    if (i) x += kit.drawTracked(g, dot, x, base, { ...label(), color: c.inkFaint });
+    x += kit.drawTracked(g, kit.truncate(g, p.text, Math.max(0, right - x), label()), x, base, { ...label(), color: p.color });
+  });
+  if (o.showRule) hairline(g, box.x, box.y + box.h - 1, box.w, c.surfaceEdge);
+}
+
+// src/platformer.ts
+var T = 66;
+var ROWS = 7;
+var WORLD_H = ROWS * T;
+var GROUND_ROW = 6;
+var MAP = [
+  //        1         2         3         4         5         6         7         8         9
+  //234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+  "                                                                                                    ",
+  "                                                                                              C     ",
+  "                       B?B?B                                                                        ",
+  "     B?B                                                                                            ",
+  "                                                                                         F          ",
+  "                   e             PP                  e    PP                  e          F          ",
+  "#######################################   ######################  #################  ###############"
+];
+var SPEED = 24.75;
+var GRAVITY = 16;
+var JUMP_V = 88;
+var STOMP_V = 46;
+function measureJumpReach() {
+  let y = GROUND_ROW * T;
+  let vy = -JUMP_V;
+  let frames = 0;
+  do {
+    vy += GRAVITY;
+    y += vy;
+    frames++;
+  } while (!(vy > 0 && y >= GROUND_ROW * T));
+  return frames * SPEED;
+}
+var JUMP_REACH = measureJumpReach();
+var BUG_SPEED = 4;
+var COLS = MAP[0].length;
+var LEVEL_WIDTH = COLS * T;
+var CASTLE_W = 5 * T;
+var CASTLE_TOP = 2.3 * T;
+var SKY = "#5C94FC";
+var SKY_DEEP = "#2A5FC8";
+function parseLevel() {
+  const blocks = [];
+  const pipes = [];
+  const bugs = [];
+  const gaps = /* @__PURE__ */ new Set();
+  let flagCol = -1;
+  let castleCol = -1;
+  for (let row = 0; row < ROWS; row++) {
+    const line = MAP[row].padEnd(COLS, " ");
+    for (let col = 0; col < COLS; col++) {
+      const ch = line[col];
+      if (ch === "#") blocks.push({ col, row, kind: "#" });
+      else if (ch === "B" || ch === "?") blocks.push({ col, row, kind: ch });
+      else if (ch === "P") {
+        if (line[col - 1] !== "P" && (MAP[row - 1]?.[col] ?? " ") !== "P") pipes.push({ col, top: row });
+      } else if (ch === "e") bugs.push({ col });
+      else if (ch === "F" && flagCol < 0) flagCol = col;
+      else if (ch === "C" && castleCol < 0) castleCol = col;
+    }
+  }
+  for (let col = 0; col < COLS; col++) {
+    if (MAP[GROUND_ROW].padEnd(COLS, " ")[col] !== "#") gaps.add(col);
+  }
+  return { blocks, pipes, bugs, gaps, flagCol, castleCol };
+}
+var LEVEL = parseLevel();
+function gapGroups() {
+  const cols = [...LEVEL.gaps].sort((a, b) => a - b);
+  const out = [];
+  for (const c of cols) {
+    const last = out[out.length - 1];
+    if (last && c === last[1] + 1) last[1] = c;
+    else out.push([c, c]);
+  }
+  return out;
+}
+function surfaceAt(x) {
+  const col = Math.floor(x / T);
+  if (col < 0 || col >= COLS) return GROUND_ROW * T;
+  for (const p of LEVEL.pipes) {
+    if (col >= p.col && col < p.col + 2) return p.top * T;
+  }
+  if (LEVEL.gaps.has(col)) return Number.POSITIVE_INFINITY;
+  return GROUND_ROW * T;
+}
+function jumpTriggers() {
+  const t2 = [];
+  for (const p of LEVEL.pipes) t2.push(p.col * T + 2.6 * T - JUMP_REACH);
+  for (const [from, to] of gapGroups()) {
+    t2.push(Math.max(from * T - 0.6 * T, (to + 1) * T + 0.4 * T - JUMP_REACH));
+  }
+  return t2.sort((a, b) => a - b);
+}
+var TRIGGERS = jumpTriggers();
+var GAP_TRIGGER = new Map(gapGroups().map(([from, to]) => [from, Math.max(from * T - 0.6 * T, (to + 1) * T + 0.4 * T - JUMP_REACH)]));
+function fateFor(seed) {
+  const stumbles = [
+    // The first obstacles are skipped: falling two seconds in leaves no time
+    // to even notice there is an animation.
+    ...gapGroups().map(([col]) => col).filter((c) => c > 20).map((col) => ({ kind: "gap", col })),
+    ...LEVEL.bugs.map((_b, index) => ({ kind: "bug", index })).filter((_, i) => LEVEL.bugs[i].col > 20)
+  ];
+  if (stumbles.length === 0) return { kind: "complete" };
+  const n = stumbles.length + 2;
+  const pick = (seed % n + n) % n;
+  return pick < 2 ? { kind: "complete" } : stumbles[pick - 2];
+}
+var SLIDE_FRAMES = 12;
+var WALK_FRAMES = 60;
+var HOLD_FRAMES = 14;
+var CARD_FRAMES = 16;
+var DEATH_V = 58;
+function simulate(width, seed = 0) {
+  const fate = fateFor(seed);
+  const frames = [];
+  const flagX = LEVEL.flagCol * T;
+  const doorX = LEVEL.castleCol * T + CASTLE_W / 2;
+  let x = 2 * T;
+  let y = GROUND_ROW * T;
+  let vy = 0;
+  let airborne = false;
+  let nextTrigger = 0;
+  let coins = 0;
+  const squashed = /* @__PURE__ */ new Map();
+  const bugX = LEVEL.bugs.map((b) => b.col * T);
+  const attempted = /* @__PURE__ */ new Set();
+  const maxCamera = Math.max(0, LEVEL_WIDTH - width);
+  const cameraFor = (hx) => Math.max(0, Math.min(maxCamera, hx - width * 0.34));
+  let phase = "run";
+  let index = 0;
+  let phaseFrame = 0;
+  let castleFlag = 0;
+  let camera = cameraFor(x);
+  for (let guard = 0; guard < 4e3; guard++) {
+    if (phase === "run") {
+      x += SPEED;
+      const closing = JUMP_REACH * ((SPEED + BUG_SPEED) / SPEED);
+      let bugAhead = false;
+      for (let i = 0; i < bugX.length; i++) {
+        if (squashed.has(i) || attempted.has(i)) continue;
+        if (bugX[i] - x > closing) continue;
+        attempted.add(i);
+        if (fate.kind === "bug" && fate.index === i) continue;
+        bugAhead = true;
+      }
+      let staticTrigger = false;
+      while (nextTrigger < TRIGGERS.length && x >= TRIGGERS[nextTrigger]) {
+        const skip = fate.kind === "gap" && TRIGGERS[nextTrigger] === GAP_TRIGGER.get(fate.col);
+        if (!skip) staticTrigger = true;
+        nextTrigger++;
+      }
+      if (!airborne && (staticTrigger || bugAhead)) {
+        vy = -JUMP_V;
+        airborne = true;
+      }
+      if (airborne) {
+        vy += GRAVITY;
+        y += vy;
+        if (vy > 0) {
+          for (let i = 0; i < bugX.length; i++) {
+            if (squashed.has(i)) continue;
+            if (Math.abs(bugX[i] - x) < T * 0.8 && y >= GROUND_ROW * T - T * 0.6) {
+              squashed.set(i, index);
+              vy = -STOMP_V;
+              coins += 100;
+            }
+          }
+        }
+        const floor = surfaceAt(x);
+        if (vy > 0 && y >= floor) {
+          y = floor;
+          vy = 0;
+          airborne = false;
+        }
+      }
+      if (!airborne) {
+        for (let i = 0; i < bugX.length; i++) {
+          if (squashed.has(i)) continue;
+          if (Math.abs(bugX[i] - x) < T * 0.55) {
+            phase = "dies";
+            vy = -DEATH_V;
+            phaseFrame = 0;
+          }
+        }
+      }
+      if (!airborne && y < surfaceAt(x)) {
+        airborne = true;
+        vy = 0;
+      }
+      if (y > ROWS * T) {
+        phase = "dies";
+        phaseFrame = 0;
+      }
+      for (let i = 0; i < bugX.length; i++) {
+        if (!squashed.has(i) && bugX[i] - x < width * 0.7) bugX[i] = bugX[i] - BUG_SPEED;
+      }
+      if (phase === "run" && x >= flagX) {
+        x = flagX;
+        y = 2.2 * T;
+        phase = "slide";
+        phaseFrame = 0;
+        coins += 500;
+      }
+      camera = cameraFor(x);
+    } else if (phase === "dies") {
+      vy += GRAVITY;
+      y += vy;
+      phaseFrame++;
+      if (y > ROWS * T + 260) {
+        phase = "retry";
+        phaseFrame = 0;
+      }
+    } else if (phase === "retry") {
+      if (++phaseFrame > CARD_FRAMES) break;
+    } else if (phase === "slide") {
+      y = 2.2 * T + (GROUND_ROW * T - 2.2 * T) * (phaseFrame / SLIDE_FRAMES);
+      camera = cameraFor(flagX + width * 0.2);
+      if (++phaseFrame > SLIDE_FRAMES) {
+        phase = "walk";
+        phaseFrame = 0;
+        y = GROUND_ROW * T;
+      }
+    } else if (phase === "walk") {
+      x += SPEED * 0.75;
+      camera = cameraFor(flagX + width * 0.2);
+      castleFlag = Math.min(1, (x - flagX) / (doorX - flagX));
+      if (x >= doorX || ++phaseFrame > WALK_FRAMES) {
+        phase = "hold";
+        phaseFrame = 0;
+      }
+    } else {
+      castleFlag = 1;
+      if (++phaseFrame > HOLD_FRAMES) break;
+    }
+    frames.push({ camera, heroX: x, heroY: y, airborne, phase, squashed: new Map(squashed), bugX: [...bugX], castleFlag, coins, index });
+    index++;
+  }
+  return frames;
+}
+var DEFAULT_TEXTS = { title: "KIOSKO", world: "RELEASE", time: "TIME", retry: "TRY AGAIN", level: "V1.0" };
+function levelFor(seed) {
+  const n = Math.abs(Math.floor(seed));
+  return `V${n % 9 + 1}.${Math.floor(n / 9) % 10}`;
+}
+var GLYPHS = {
+  A: "01110 10001 10001 11111 10001 10001 10001",
+  B: "11110 10001 10001 11110 10001 10001 11110",
+  C: "01110 10001 10000 10000 10000 10001 01110",
+  D: "11110 10001 10001 10001 10001 10001 11110",
+  E: "11111 10000 10000 11110 10000 10000 11111",
+  F: "11111 10000 10000 11110 10000 10000 10000",
+  G: "01110 10001 10000 10111 10001 10001 01111",
+  H: "10001 10001 10001 11111 10001 10001 10001",
+  I: "11111 00100 00100 00100 00100 00100 11111",
+  J: "00111 00010 00010 00010 00010 10010 01100",
+  K: "10001 10010 10100 11000 10100 10010 10001",
+  L: "10000 10000 10000 10000 10000 10000 11111",
+  M: "10001 11011 10101 10101 10001 10001 10001",
+  N: "10001 11001 10101 10011 10001 10001 10001",
+  O: "01110 10001 10001 10001 10001 10001 01110",
+  P: "11110 10001 10001 11110 10000 10000 10000",
+  Q: "01110 10001 10001 10001 10101 10010 01101",
+  R: "11110 10001 10001 11110 10100 10010 10001",
+  S: "01111 10000 10000 01110 00001 00001 11110",
+  T: "11111 00100 00100 00100 00100 00100 00100",
+  U: "10001 10001 10001 10001 10001 10001 01110",
+  V: "10001 10001 10001 10001 10001 01010 00100",
+  W: "10001 10001 10001 10101 10101 11011 10001",
+  X: "10001 10001 01010 00100 01010 10001 10001",
+  Y: "10001 10001 01010 00100 00100 00100 00100",
+  Z: "11111 00001 00010 00100 01000 10000 11111",
+  "0": "01110 10011 10101 10101 11001 10001 01110",
+  "1": "00100 01100 00100 00100 00100 00100 01110",
+  "2": "01110 10001 00001 00110 01000 10000 11111",
+  "3": "11111 00010 00100 00010 00001 10001 01110",
+  "4": "00010 00110 01010 10010 11111 00010 00010",
+  "5": "11111 10000 11110 00001 00001 10001 01110",
+  "6": "00110 01000 10000 11110 10001 10001 01110",
+  "7": "11111 00001 00010 00100 01000 01000 01000",
+  "8": "01110 10001 10001 01110 10001 10001 01110",
+  "9": "01110 10001 10001 01111 00001 00010 01100",
+  "?": "01110 10001 00001 00110 00100 00000 00100",
+  "<": "00010 00100 01000 10000 01000 00100 00010",
+  ">": "01000 00100 00010 00001 00010 00100 01000",
+  "/": "00001 00010 00010 00100 01000 01000 10000",
+  "!": "00100 00100 00100 00100 00100 00000 00100",
+  ".": "00000 00000 00000 00000 00000 00000 00100",
+  "-": "00000 00000 00000 11111 00000 00000 00000",
+  " ": "00000 00000 00000 00000 00000 00000 00000"
+};
+function pixelSafe(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toUpperCase();
+}
+var SEAM = 0.4;
+var pixelWidth = (text, px) => [...text].length * 6 * px - px;
+function drawPixelText(g, text, x, y, px, color) {
+  g.fillStyle = color;
+  let cx = x;
+  for (const ch of pixelSafe(text)) {
+    const rows = (GLYPHS[ch] ?? "11111 10001 10001 10001 10001 10001 11111").split(" ");
+    for (let r = 0; r < rows.length; r++) {
+      const row = rows[r];
+      for (let c = 0; c < row.length; c++) if (row[c] === "1") g.fillRect(cx + c * px, y + r * px, px + SEAM, px + SEAM);
+    }
+    cx += 6 * px;
+  }
+}
+var HERO_COLORS = {
+  A: "#FFB020",
+  // cap and shirt
+  S: "#F2C9A0",
+  // skin
+  K: "#2A1A12",
+  // eye
+  O: "#2E8A82",
+  // overalls
+  N: "#1F6259",
+  // overalls shade
+  B: "#4A2E1E",
+  // boots
+  H: "#8A5A2B"
+  // hair
+};
+var HERO_BODY = ["....AAAAA...", "...AAAAAAAA.", "...HHSSSKS..", "...HSSSSKSS.", "...HSSSSSSS.", "....SSSSSS..", ".....SSSS...", "..AAAAAAAA..", ".AAAOAAAOAA.", "AAAAOOOOAAAA", "AAAAOOOOAAAA"];
+var HERO_LEGS = [
+  [".AAAOOOOAAA.", "...OOOOOO...", "...OO..OO...", "..BBB..BBB..", "..BBB..BBB.."],
+  [".AAAOOOOAAA.", "...OOOOOO...", "..OO....OO..", ".BBB......BB", ".BBB......BB"],
+  [".AAAOOOOAAA.", "...OOOOOO...", "....OOOO....", "...BBBBBB...", "...BBBBBB..."]
+];
+var HERO_LEGS_AIR = [".AAAOOOOAAA.", "..NOOOOOON..", ".OO......OO.", "BBB.......BB", "BBB........."];
+var HERO_DEAD = ["A..........A", "AA.......AA.", ".AA.AAAAA.A.", "..AAAAAAAA..", "..SKSSSSKS..", "..SSKSSKSS..", "..SKSSSSKS..", "...SSSSSS...", "..AAAAAAAA..", ".AAAOOOOAAA.", ".AAAOOOOAAA.", "..OOOOOOOO..", "..OO....OO..", "..BB....BB..", ".BBB....BBB.", "............"];
+var HERO_PX = 7;
+var HERO_W = 12 * HERO_PX;
+var HERO_H = 16 * HERO_PX;
+function drawSprite(g, rows, x, y, px, colors) {
+  for (let r = 0; r < rows.length; r++) {
+    const row = rows[r];
+    for (let c = 0; c < row.length; c++) {
+      const color = colors[row[c]];
+      if (!color) continue;
+      g.fillStyle = color;
+      g.fillRect(x + c * px, y + r * px, px + SEAM, px + SEAM);
+    }
+  }
+}
+function drawHero(g, f) {
+  if (f.phase === "hold") return;
+  const x = Math.round(f.heroX - f.camera - HERO_W / 2);
+  const y = Math.round(f.heroY - HERO_H);
+  if (f.phase === "dies") {
+    drawSprite(g, HERO_DEAD, x, y, HERO_PX, HERO_COLORS);
+    return;
+  }
+  const legs = f.airborne || f.phase === "slide" ? HERO_LEGS_AIR : HERO_LEGS[Math.floor(f.index / 2) % HERO_LEGS.length];
+  drawSprite(g, HERO_BODY, x, y, HERO_PX, HERO_COLORS);
+  drawSprite(g, legs, x, y + HERO_BODY.length * HERO_PX, HERO_PX, HERO_COLORS);
+}
+function drawRetryCard(g, width, height, texts) {
+  g.fillStyle = "#000000";
+  g.fillRect(0, 0, width, height);
+  const cx = width / 2;
+  const fit = (text, px2) => {
+    while (px2 > 1 && pixelWidth(pixelSafe(text), px2) > width * 0.9) px2--;
+    return px2;
+  };
+  const head = `${texts.world} ${texts.level ?? DEFAULT_TEXTS.level}`;
+  const px = fit(head, 6);
+  drawPixelText(g, head, cx - pixelWidth(pixelSafe(head), px) / 2, height * 0.26, px, "#FFFFFF");
+  const headPx = 7;
+  const lives = "X  2";
+  const groupW = 12 * headPx + 30 + pixelWidth(lives, px);
+  const left = cx - groupW / 2;
+  drawSprite(g, HERO_BODY.slice(0, 7), left, height * 0.48, headPx, HERO_COLORS);
+  drawPixelText(g, lives, left + 12 * headPx + 30, height * 0.52, px, "#FFFFFF");
+  const rpx = fit(texts.retry, 3);
+  drawPixelText(g, texts.retry, cx - pixelWidth(pixelSafe(texts.retry), rpx) / 2, height * 0.82, rpx, "#627180");
+}
+var BUG_COLORS = { X: "#B84A3A", D: "#2A1A12", W: "#EFEFEF", F: "#7A2E22" };
+var BUG = ["..XXXXXX..", ".XXXXXXXX.", "XXWDXXDWXX", "XXWDXXDWXX", "XXXXXXXXXX", ".XXXXXXXX.", "..FF..FF..", ".FFF..FFF."];
+var BUG_FLAT = ["..........", "..........", "..........", "..........", "..XXXXXX..", ".XXXXXXXX.", "XXXXXXXXXX", ".FF....FF."];
+var BUG_PX = 6;
+function drawBugs(g, f, width) {
+  for (let i = 0; i < f.bugX.length; i++) {
+    const squashedAt = f.squashed.get(i);
+    if (squashedAt !== void 0 && f.index - squashedAt > 8) continue;
+    const rows = squashedAt !== void 0 ? BUG_FLAT : BUG;
+    const x = Math.round(f.bugX[i] - f.camera - BUG[0].length * BUG_PX / 2);
+    if (x < -100 || x > width + 100) continue;
+    drawSprite(g, rows, x, GROUND_ROW * T - rows.length * BUG_PX, BUG_PX, BUG_COLORS);
+  }
+}
+function drawBlock(g, b, sx, y, frameIndex) {
+  if (b.kind === "#") {
+    g.fillStyle = "#C84C0C";
+    g.fillRect(sx, y, T + 1, T + 1);
+    g.fillStyle = "#8A3308";
+    for (let r = 0; r < 2; r++) {
+      g.fillRect(sx, y + r * (T / 2) + T / 2 - 3, T, 3);
+      g.fillRect(sx + (r % 2 ? T / 4 : T * 3 / 4) - 1.5, y + r * (T / 2), 3, T / 2);
+    }
+    return;
+  }
+  if (b.kind === "B") {
+    g.fillStyle = "#B5651D";
+    g.fillRect(sx, y, T + 1, T);
+    g.fillStyle = "#7A3E10";
+    g.fillRect(sx, y, T, 4);
+    g.fillRect(sx, y + T / 2 - 2, T, 4);
+    g.fillRect(sx + T / 2 - 2, y + 4, 4, T / 2 - 6);
+    g.fillRect(sx + T / 4 - 2, y + T / 2 + 2, 4, T / 2 - 2);
+    g.fillRect(sx + T * 3 / 4 - 2, y + T / 2 + 2, 4, T / 2 - 2);
+    return;
+  }
+  const lit = Math.floor(frameIndex / 3) % 4;
+  g.fillStyle = ["#7C5CFF", "#8F74FF", "#7C5CFF", "#6346E0"][lit];
+  g.fillRect(sx, y, T + 1, T);
+  g.fillStyle = "#2E1A7A";
+  g.fillRect(sx, y, T, 4);
+  g.fillRect(sx, y + T - 4, T, 4);
+  g.fillRect(sx, y, 4, T);
+  g.fillRect(sx + T - 4, y, 4, T);
+  const tag = "</>";
+  drawPixelText(g, tag, sx + (T - pixelWidth(tag, 3)) / 2, y + T / 2 - 10, 3, "#EDE9FF");
+}
+function drawPipe(g, p, sx) {
+  const top = p.top * T;
+  const h = (GROUND_ROW - p.top) * T;
+  g.fillStyle = "#1E293B";
+  g.fillRect(sx - 4, top - 4, 2 * T + 8, h + 4);
+  g.fillStyle = "#64748B";
+  g.fillRect(sx + 6, top + T * 0.42, 2 * T - 12, h - T * 0.42);
+  g.fillRect(sx, top, 2 * T, T * 0.42);
+  g.fillStyle = "#94A3B8";
+  g.fillRect(sx + 12, top + 6, 14, T * 0.42 - 12);
+  g.fillRect(sx + 18, top + T * 0.42, 12, h - T * 0.42);
+  g.fillStyle = "#334155";
+  g.fillRect(sx + 2 * T - 16, top, 10, T * 0.42);
+  g.fillRect(sx + 2 * T - 22, top + T * 0.42, 10, h - T * 0.42);
+  g.fillStyle = "#1E293B";
+  for (let i = 0; i < 4; i++) g.fillRect(sx + 34 + i * 18, top + 10, 10, 4);
+  g.fillStyle = "#34D399";
+  g.fillRect(sx + 2 * T - 34, top + 9, 6, 6);
+}
+function drawBackdrop(g, camera, width) {
+  const grad = g.createLinearGradient(0, 0, 0, ROWS * T);
+  grad.addColorStop(0, SKY_DEEP);
+  grad.addColorStop(0.55, SKY);
+  g.fillStyle = grad;
+  g.fillRect(0, 0, width, ROWS * T);
+  const par = camera * 0.35;
+  g.fillStyle = "#1E7C34";
+  for (let i = 0; i < 14; i++) {
+    const x = ((i * 640 - par) % (LEVEL_WIDTH * 0.6) + LEVEL_WIDTH * 0.6) % (LEVEL_WIDTH * 0.6) - 200;
+    const r = i % 2 ? 150 : 96;
+    g.beginPath();
+    g.arc(x, GROUND_ROW * T, r, Math.PI, 0);
+    g.arc(x + r * 0.75, GROUND_ROW * T, r * 0.7, Math.PI, 0);
+    g.fill();
+  }
+  const cpar = camera * 0.18;
+  g.fillStyle = "#FFFFFF";
+  for (let i = 0; i < 12; i++) {
+    const x = ((i * 730 + 120 - cpar) % (LEVEL_WIDTH * 0.5) + LEVEL_WIDTH * 0.5) % (LEVEL_WIDTH * 0.5) - 150;
+    const y = 40 + i % 3 * 46;
+    const s2 = i % 2 ? 1 : 0.75;
+    for (const [dx, dy, r] of [
+      [0, 0, 26],
+      [30, -12, 34],
+      [64, 0, 26],
+      [32, 10, 30]
+    ]) {
+      g.beginPath();
+      g.arc(x + dx * s2, y + dy * s2, r * s2, 0, Math.PI * 2);
+      g.fill();
+    }
+  }
+}
+function drawFlagAndCastle(g, f, width) {
+  const poleX = LEVEL.flagCol * T - f.camera + T * 0.4;
+  if (poleX > -80 && poleX < width + 80) {
+    const top = 1.6 * T;
+    const bottom = GROUND_ROW * T;
+    g.fillStyle = "#94A3B8";
+    g.fillRect(poleX - 6, top, 4, bottom - top);
+    g.fillRect(poleX + 10, top, 4, bottom - top);
+    g.fillStyle = "#64748B";
+    for (let y = top + 10; y < bottom; y += 26) {
+      g.fillRect(poleX - 6, y, 20, 3);
+      g.save();
+      g.translate(poleX - 4, y + 3);
+      g.rotate(Math.atan2(23, 16));
+      g.fillRect(0, 0, 28, 2);
+      g.restore();
+    }
+    g.fillStyle = f.index % 8 < 4 ? "#F5453D" : "#7A1F1B";
+    g.fillRect(poleX - 4, top - 14, 16, 14);
+    const drop = f.phase === "run" ? 0 : Math.min(1, (f.heroY - 2.2 * T) / (GROUND_ROW * T - 2.2 * T));
+    const fy = 1.9 * T + drop * (GROUND_ROW * T - 2.9 * T);
+    g.fillStyle = "#22D3EE";
+    g.beginPath();
+    g.moveTo(poleX - 6, fy);
+    g.lineTo(poleX - 66, fy + 22);
+    g.lineTo(poleX - 6, fy + 44);
+    g.closePath();
+    g.fill();
+  }
+  const cx = LEVEL.castleCol * T - f.camera;
+  if (cx > -400 && cx < width + 400) {
+    const cw = CASTLE_W;
+    const top = CASTLE_TOP;
+    const ground = GROUND_ROW * T;
+    g.fillStyle = "#1E293B";
+    g.fillRect(cx, top, cw, ground - top);
+    g.fillStyle = "#334155";
+    g.fillRect(cx - 8, top - 16, cw + 16, 16);
+    for (let row = 0; row < 3; row++) {
+      for (let col = 0; col < 6; col++) {
+        const x = cx + 18 + col * ((cw - 36) / 6);
+        const y = top + 24 + row * 34;
+        g.fillStyle = "#0F172A";
+        g.fillRect(x, y, (cw - 36) / 6 - 8, 22);
+        const on = (col * 7 + row * 3 + Math.floor(f.index / 3)) % 5;
+        g.fillStyle = on === 0 ? "#FFB020" : on < 3 ? "#34D399" : "#14532D";
+        g.fillRect(x + 6, y + 8, 8, 6);
+      }
+    }
+    g.fillStyle = "#0F172A";
+    g.fillRect(cx + cw / 2 - T * 0.35, ground - T * 1.15, T * 0.7, T * 1.15);
+    g.fillStyle = "#38BDF8";
+    g.fillRect(cx + cw / 2 + T * 0.2, ground - T * 0.6, 5, 5);
+    const px = cx + cw / 2;
+    g.fillStyle = "#94A3B8";
+    g.fillRect(px - 3, top - 112, 6, 96);
+    if (f.castleFlag > 0) {
+      const fy = top - 34 - f.castleFlag * 58;
+      g.fillStyle = "#8B5CF6";
+      g.fillRect(px + 3, fy, 54, 34);
+      g.fillStyle = "#EDE9FF";
+      g.fillRect(px + 14, fy + 15, 32, 4);
+    }
+  }
+}
+function hud(g, text, x, y, px) {
+  drawPixelText(g, text, x + px, y + px, px, "rgba(0,0,0,0.45)");
+  drawPixelText(g, text, x, y, px, "#FFFFFF");
+}
+function drawHud(g, f, total, width, texts) {
+  const y = 22;
+  const coins = String(f.coins).padStart(6, "0");
+  const left = Math.max(0, Math.ceil((total - f.index) / total * 400));
+  const time = String(left).padStart(3, "0");
+  const title = pixelSafe(texts.title);
+  const world = pixelSafe(texts.world);
+  const timeLabel = pixelSafe(texts.time);
+  for (const px of [4, 3, 2]) {
+    const leftW = Math.max(pixelWidth(title, px), pixelWidth(coins, px));
+    const rightW = Math.max(pixelWidth(timeLabel, px), pixelWidth(time, px));
+    const level = pixelSafe(texts.level ?? DEFAULT_TEXTS.level);
+    const worldW = Math.max(pixelWidth(world, px), pixelWidth(level, px));
+    const margin = 10 * px;
+    const rightC = width - margin - rightW / 2;
+    const withWorld = margin + leftW + 2 * margin + worldW + 2 * margin + rightW + margin <= width;
+    if (!withWorld && margin + leftW + 2 * margin + rightW + margin > width && px > 2) continue;
+    const line2 = y + 9 * px;
+    const centre = (t2, cx) => cx - pixelWidth(t2, px) / 2;
+    hud(g, title, margin, y, px);
+    hud(g, coins, margin, line2, px);
+    if (withWorld) {
+      hud(g, world, centre(world, width / 2), y, px);
+      hud(g, level, centre(level, width / 2), line2, px);
+    }
+    hud(g, timeLabel, centre(timeLabel, rightC), y, px);
+    hud(g, time, centre(time, rightC), line2, px);
+    return;
+  }
+}
+function drawFrame(g, f, total, width, texts = DEFAULT_TEXTS) {
+  if (f.phase === "retry") {
+    drawRetryCard(g, width, WORLD_H, texts);
+    return;
+  }
+  drawBackdrop(g, f.camera, width);
+  for (const b of LEVEL.blocks) {
+    const sx = b.col * T - f.camera;
+    if (sx < -T || sx > width) continue;
+    drawBlock(g, b, sx, b.row * T, f.index);
+  }
+  for (const p of LEVEL.pipes) {
+    const sx = p.col * T - f.camera;
+    if (sx < -2 * T || sx > width) continue;
+    drawPipe(g, p, sx);
+  }
+  drawFlagAndCastle(g, f, width);
+  drawBugs(g, f, width);
+  drawHero(g, f);
+  drawHud(g, f, total, width, texts);
+}
+function runnerPlayer(width, height, seed, texts = DEFAULT_TEXTS) {
+  const k = height / WORLD_H;
+  const view = Math.max(1, Math.ceil(width / k));
+  const frames = simulate(view, seed);
+  return {
+    frames: frames.length,
+    fate: fateFor(seed),
+    draw(g, i) {
+      const f = frames[Math.max(0, Math.min(frames.length - 1, i))];
+      g.fillStyle = "#000000";
+      g.fillRect(0, 0, width, height);
+      g.save();
+      g.scale(k, k);
+      drawFrame(g, f, frames.length, view, texts);
+      g.restore();
+    }
+  };
+}
+
+// src/source.ts
+import { existsSync as existsSync3, watch } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+
+// ../../kiosko/packages/agent-sessions/src/git.ts
+import { execFile } from "node:child_process";
+import { readFileSync as readFileSync2, statSync, existsSync as existsSync2 } from "node:fs";
+import { basename } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var NEGATIVE_TTL_MS = 10 * 6e4;
+function repoRootCache(run, now = Date.now) {
+  const known = /* @__PURE__ */ new Map();
+  return async (cwd) => {
+    const hit = known.get(cwd);
+    if (hit && (hit.root !== null || now() - hit.at < NEGATIVE_TTL_MS)) return hit.root;
+    const out = (await run(cwd))?.trim() || null;
+    known.set(cwd, { root: out, at: now() });
+    return out;
+  };
+}
+function parseHead(out) {
+  const [ct, refs = ""] = out.trim().split("\n");
+  const secs = Number(ct);
+  if (!ct || !Number.isFinite(secs)) return null;
+  return { detached: !/\bHEAD -> /.test(refs), lastCommit: secs * 1e3 };
+}
+function headCache(run, ttlMs = 6e4, now = Date.now) {
+  const known = /* @__PURE__ */ new Map();
+  return async (root) => {
+    const hit = known.get(root);
+    if (hit && now() - hit.at < ttlMs) return hit.info;
+    const out = await run(root);
+    const info = out ? parseHead(out) : null;
+    known.set(root, { info, at: now() });
+    return info;
+  };
+}
+var git = (args, timeout = 2e3) => async (cwd) => {
+  try {
+    return (await execFileAsync("git", args, { cwd, timeout })).stdout;
+  } catch {
+    return null;
+  }
+};
+function parseStatus(out) {
+  const lines = out.split("\n").filter((l) => l.trim().length > 0);
+  const files = lines.map((l) => l.slice(3).split(" -> ").pop().replace(/^"|"$/g, ""));
+  return { count: lines.length, files };
+}
+function createGitEnricher(run = (args) => git(args)) {
+  const repoRoot = repoRootCache(run(["rev-parse", "--show-toplevel"]));
+  const headOf = headCache(run(["log", "-1", "--format=%ct%n%D"]));
+  const born = /* @__PURE__ */ new Map();
+  const long = /* @__PURE__ */ new Map();
+  async function bornOf(root) {
+    const hit = born.get(root);
+    if (hit && Date.now() - hit.at < 6 * 36e5) return hit.born;
+    let value = null;
+    if ((await run(["rev-parse", "--is-shallow-repository"])(root))?.trim() === "false") {
+      const out = await run(["log", "--max-parents=0", "--format=%at", "HEAD"])(root);
+      const times = (out ?? "").split("\n").map(Number).filter((n) => n > 0);
+      if (times.length) value = Math.min(...times) * 1e3;
+    }
+    born.set(root, { born: value, at: Date.now() });
+    return value;
+  }
+  function isSpaghetti(path) {
+    if (!/\.(ts|tsx|js|jsx|mjs|py|go|rs|java|kt|cs|php|rb|c|cc|cpp|h|swift)$/.test(path)) return false;
+    try {
+      const st = statSync(path);
+      const hit = long.get(path);
+      if (hit && hit.mtime === st.mtimeMs) return hit.long;
+      const value = st.size < 2e6 && longestDefinition(readFileSync2(path, "utf8")) > SPAGHETTI_LINES;
+      if (long.size > 500) long.clear();
+      long.set(path, { mtime: st.mtimeMs, long: value });
+      return value;
+    } catch {
+      return false;
+    }
+  }
+  return async function enrich(rec2) {
+    const out = { ...rec2 };
+    if (!rec2.cwd || !existsSync2(rec2.cwd)) return out;
+    const root = await repoRoot(rec2.cwd);
+    if (root) {
+      out.repo = root;
+      out.project = basename(root);
+      const head = await headOf(root);
+      if (head?.detached) out.detached = true;
+      if (head?.lastCommit) out.lastCommit = head.lastCommit;
+      const b = await bornOf(root);
+      if (b) out.repoBorn = b;
+    }
+    if (rec2.files?.some(isSpaghetti)) out.spaghetti = true;
+    const status = await run(["status", "--porcelain"])(rec2.cwd);
+    if (status !== null) {
+      const s2 = parseStatus(status);
+      out.dirty = s2.count;
+      out.dirtyFiles = s2.files;
+    }
+    return out;
+  };
+}
+
+// src/source.ts
+function resolveDir(dir, home = homedir2()) {
+  const d = dir.trim();
+  if (!d) return defaultSessionsDir();
+  if (d === "~") return home;
+  if (d.startsWith("~/")) return join3(home, d.slice(2));
+  return d;
+}
+async function loadSessions(o, enrich, now = Date.now(), onReap) {
+  const records = readSessions(o.dir);
+  const alive = o.reap ? reap(records, now, o, o.dir, onReap) : pruneZombies(records, now, o.zombieMs, o.staleMs);
+  if (!enrich) return alive;
+  return Promise.all(alive.map((r) => enrich(r).catch(() => r)));
+}
+function watchSessions(o, h) {
+  const enrich = o.git ? createGitEnricher() : void 0;
+  const now = h.now ?? Date.now;
+  let stopped = false;
+  let running = false;
+  let again = false;
+  let debounce;
+  let watcher;
+  const reload = async () => {
+    if (stopped) return;
+    if (running) {
+      again = true;
+      return;
+    }
+    running = true;
+    try {
+      const t2 = now();
+      const sessions = await loadSessions(o, enrich, t2, (r) => h.log(`dropped dead session ${r.project} (${r.state}, silent for ${Math.round((t2 - r.updated) / 6e4)} min)`));
+      if (!stopped) h.emit({ sessions, zombieMs: o.zombieMs });
+    } catch (err) {
+      h.log(`reading ${o.dir} failed: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      running = false;
+      if (again && !stopped) {
+        again = false;
+        void reload();
+      }
+    }
+  };
+  const schedule = () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => void reload(), o.debounceMs);
+  };
+  const arm = () => {
+    if (watcher || stopped || !existsSync3(o.dir)) return;
+    try {
+      const w = watch(o.dir, (_event, name) => {
+        if (!name || String(name).endsWith(".json")) schedule();
+      });
+      w.on("error", () => {
+        w.close();
+        if (watcher === w) watcher = void 0;
+      });
+      watcher = w;
+    } catch (err) {
+      h.log(`cannot watch ${o.dir}: ${err instanceof Error ? err.message : String(err)}; polling only`);
+    }
+  };
+  arm();
+  void reload();
+  const poll = setInterval(() => {
+    arm();
+    void reload();
+  }, Math.max(1e3, o.pollMs));
+  poll.unref?.();
+  const stop = () => {
+    stopped = true;
+    if (debounce) clearTimeout(debounce);
+    clearInterval(poll);
+    watcher?.close();
+    watcher = void 0;
+  };
+  h.signal?.addEventListener("abort", stop, { once: true });
+  return stop;
+}
+
+// src/index.ts
+var sessionsSource = defineSource({
+  id: "sessions",
+  name: { en: "AI agent sessions", es: "Sesiones de agentes IA" },
+  description: {
+    en: "Claude Code, Gemini CLI\u2026 sessions as written by the agent-sessions hook, with git status.",
+    es: "Las sesiones de Claude Code, Gemini CLI\u2026 que escribe el hook de agent-sessions, con el estado de git."
+  },
+  options: t.object({
+    dir: t.string({
+      default: "~/.aimonitor/sessions",
+      format: "path",
+      risk: "path",
+      label: { en: "Sessions folder", es: "Carpeta de sesiones" },
+      help: { en: "Where the hook writes one JSON file per session. Empty: $AGENT_SESSIONS_DIR or ~/.aimonitor/sessions.", es: "Donde el hook escribe un JSON por sesi\xF3n. Vac\xEDo: $AGENT_SESSIONS_DIR o ~/.aimonitor/sessions." }
+    }),
+    git: t.boolean({
+      default: true,
+      label: { en: "Read git status", es: "Leer el estado de git" },
+      help: { en: "Repository name and uncommitted files of each session (runs git).", es: "Nombre del repositorio y ficheros sin commit de cada sesi\xF3n (ejecuta git)." }
+    }),
+    zombieMs: t.duration({
+      default: 15 * 6e4,
+      min: 6e4,
+      label: { en: "Drop silent working sessions after", es: "Descartar sesiones activas calladas tras" },
+      help: {
+        en: "A session that says it is working and writes nothing for this long is dead. The cats room turns it into Schr\xF6dinger's box at half of this.",
+        es: "Una sesi\xF3n que dice estar trabajando y no escribe nada en este tiempo est\xE1 muerta. La habitaci\xF3n de gatos la convierte en la caja de Schr\xF6dinger a la mitad."
+      }
+    }),
+    staleMs: t.duration({
+      default: 2 * 36e5,
+      min: 6e4,
+      label: { en: "Drop any silent session after", es: "Descartar cualquier sesi\xF3n callada tras" },
+      help: { en: "The net under SessionEnd, which never arrives if the terminal is killed. Raise it if you leave permission prompts waiting for hours.", es: "La red bajo SessionEnd, que no llega si se mata el terminal. S\xFAbelo si dejas permisos esperando horas." }
+    }),
+    reap: t.boolean({
+      default: true,
+      advanced: true,
+      label: { en: "Delete files of dead sessions", es: "Borrar los ficheros de sesiones muertas" },
+      help: { en: "Safe: a live session writes its file again on its next event.", es: "Es seguro: una sesi\xF3n viva vuelve a escribir su fichero en el siguiente evento." }
+    }),
+    debounceMs: t.integer({ default: 200, min: 0, max: 5e3, unit: "ms", advanced: true, label: { en: "Wait for a burst of events", es: "Esperar a que acabe una r\xE1faga de eventos" } }),
+    pollMs: t.duration({ default: 3e4, min: 5e3, advanced: true, label: { en: "Re-read every", es: "Releer cada" }, help: { en: "Fallback to file watching; also refreshes the git counts.", es: "Respaldo de la vigilancia de ficheros; tambi\xE9n refresca los contadores de git." } })
+  }),
+  watch(ctx, emit) {
+    const o = ctx.options;
+    return watchSessions({ ...o, dir: resolveDir(o.dir) }, { emit, log: ctx.log, signal: ctx.signal });
+  },
+  demo: ({ now }) => ({ sessions: scenario("threeClaim", now), zombieMs: 15 * 6e4 })
+});
+var STATES = ["active", "idle", "ready", "waiting", "permission"];
+var projectsField = () => t.filter({
+  label: { en: "Projects", es: "Proyectos" },
+  help: {
+    en: "Empty: all. Project, repository or folder names or patterns, comma-separated: * matches anything, a leading ! leaves out (web-app, acme-*, !scratch).",
+    es: "Vac\xEDo: todos. Nombres o patrones de proyecto, repositorio o carpeta, separados por comas: * vale por cualquier cosa y un ! delante excluye (web-app, acme-*, !pruebas)."
+  }
+});
+var sessionsOptions = t.object({
+  projects: projectsField(),
+  hideStates: t.list(t.enum(STATES, { labels: STATE_LABEL }), {
+    label: { en: "Hide sessions that are", es: "Ocultar las sesiones en estado" },
+    help: { en: "E.g. Active and Idle, to see only the ones that claim you.", es: "Por ejemplo, Activa e Inactiva, para ver s\xF3lo las que te reclaman." }
+  }),
+  maxTiles: t.integer({
+    default: 0,
+    min: 0,
+    max: 12,
+    label: { en: "Most tiles", es: "Casillas como mucho" },
+    help: { en: "0 = as many as fit. The rest go to the summary column, so the tiles get wider.", es: "0 = las que quepan. El resto va a la columna de resumen, as\xED que las casillas se ensanchan." }
+  }),
+  tileMin: t.integer({ default: 320, min: 120, max: 1e3, unit: "px", label: { en: "Narrowest tile", es: "Casilla m\xE1s estrecha" }, help: { en: "At a 374 px tall widget; scales with the height. Sessions that would need narrower tiles go to the summary column.", es: "Para un widget de 374 px de alto; escala con la altura. Las sesiones que no quepan van a la columna de resumen." } }),
+  tileMax: t.integer({ default: 430, min: 0, max: 2e3, unit: "px", label: { en: "Widest tile", es: "Casilla m\xE1s ancha" }, help: { en: "So a single session doesn\u2019t stretch across the panel. 0 = no limit: the tiles fill the width.", es: "Para que una sola sesi\xF3n no se estire a todo el panel. 0 = sin l\xEDmite: las casillas llenan el ancho." } }),
+  gap: t.integer({ default: 12, min: 0, max: 60, unit: "px", label: { en: "Gap between tiles", es: "Separaci\xF3n entre casillas" } }),
+  detailLines: t.integer({ default: 3, min: 0, max: 6, slider: true, label: { en: "Detail lines", es: "L\xEDneas de detalle" }, help: { en: "Lines of the last tool call or message before cutting with an ellipsis. 0 hides it.", es: "L\xEDneas de la \xFAltima herramienta o mensaje antes de cortar con puntos suspensivos. 0 lo oculta." } }),
+  spineWidth: t.integer({ default: 7, min: 2, max: 30, unit: "px", advanced: true, label: { en: "Colour spine width", es: "Ancho de la espina de color" } }),
+  summaryWidth: t.integer({ default: 150, min: 80, max: 400, unit: "px", advanced: true, label: { en: "Summary column width", es: "Ancho de la columna de resumen" } }),
+  align: t.enum(["left", "center", "right"], { label: { en: "Alignment", es: "Alineaci\xF3n" }, labels: { left: { en: "Left", es: "Izquierda" }, center: { en: "Centre", es: "Centro" }, right: { en: "Right", es: "Derecha" } } }),
+  showGit: t.boolean({ default: true, label: { en: "Show uncommitted files", es: "Mostrar ficheros sin commit" } }),
+  showId: t.boolean({ default: true, label: { en: "Show the console id", es: "Mostrar el id de la consola" }, help: { en: "PROVIDER \xB7 ABC123 in the corner, to tell two consoles of one project apart.", es: "PROVEEDOR \xB7 ABC123 en la esquina, para distinguir dos consolas del mismo proyecto." } })
+});
+var sessionsWidget = defineWidget({
+  id: "sessions",
+  name: { en: "Agent sessions", es: "Sesiones de agentes" },
+  description: {
+    en: "One tile per AI coding session. The one that needs you most turns solid, the others that wait get a colour spine, and working ones stay dark.",
+    es: "Una casilla por sesi\xF3n de IA. La que m\xE1s te necesita se enciende entera, las dem\xE1s que esperan llevan una espina de color y las que trabajan quedan a oscuras."
+  },
+  icon: "bot",
+  category: "agents",
+  tags: ["claude", "gemini", "ai", "sessions", "git"],
+  chrome: "bare",
+  size: { min: { w: 400, h: 200 }, preferred: { w: 1500, h: 390 } },
+  options: sessionsOptions,
+  sources: [SESSIONS_SOURCE],
+  redraw: "minute",
+  render(g, ctx) {
+    drawSessions(g, ctx, ctx.options);
+  },
+  urgent: ({ sources, options }) => needsPermission(filterSessions(sessionsOf(sources), options)),
+  idle: ({ sources, options }) => filterSessions(sessionsOf(sources), options).length === 0,
+  empty: ({ sources, options }) => filterSessions(sessionsOf(sources), options).length === 0,
+  demo: ({ now }) => ({ sources: { [SESSIONS_SOURCE]: { sessions: scenario("threeClaim", now) } } })
+});
+var summaryWidget = defineWidget({
+  id: "summary",
+  name: { en: "Agents summary strip", es: "Franja de resumen de agentes" },
+  description: {
+    en: "A thin header line: RAM, how many consoles are open, how many wait for you (tinted by the most urgent) and the clock.",
+    es: "Una l\xEDnea fina de cabecera: RAM, cu\xE1ntas consolas hay abiertas, cu\xE1ntas te esperan (te\xF1ido por la m\xE1s urgente) y la hora."
+  },
+  icon: "activity",
+  category: "agents",
+  tags: ["claude", "gemini", "header"],
+  chrome: "bare",
+  size: { min: { w: 400, h: 32 }, preferred: { w: 1900, h: 60 } },
+  options: t.object({
+    projects: projectsField(),
+    showRam: t.boolean({ default: true, label: { en: "Show RAM", es: "Mostrar la RAM" }, help: { en: "Needs the system vitals source.", es: "Necesita la fuente de vitales del sistema." } }),
+    showConsoles: t.boolean({ default: true, label: { en: "Show how many consoles", es: "Mostrar cu\xE1ntas consolas" }, help: { en: "Off: only how many wait for you, for short strips.", es: "Apagado: s\xF3lo cu\xE1ntas te esperan, para franjas cortas." } }),
+    showClock: t.boolean({ default: true, label: { en: "Show the clock", es: "Mostrar la hora" } }),
+    showRule: t.boolean({ default: true, label: { en: "Rule underneath", es: "Raya debajo" } })
+  }),
+  sources: [SESSIONS_SOURCE, "system/vitals"],
+  redraw: "minute",
+  render(g, ctx) {
+    drawSummaryStrip(g, ctx, ctx.options);
+  },
+  idle: ({ sources, options }) => filterSessions(sessionsOf(sources), options).length === 0,
+  demo: ({ now }) => ({ sources: { [SESSIONS_SOURCE]: { sessions: scenario("threeClaim", now) }, "system/vitals": DEMO_VITALS } })
+});
+var runner = defineInterlude({
+  id: "runner",
+  name: { en: "8-bit runner", es: "Corredor de 8 bits" },
+  description: {
+    en: "A side-scrolling platformer run through a server room, in flat colours. Every slot plays a different ending; now and then the runner ships the release.",
+    es: "Una carrera de plataformas de scroll lateral por una sala de servidores, en colores planos. Cada franja acaba distinto; de vez en cuando el corredor saca la versi\xF3n."
+  },
+  icon: "gamepad",
+  options: t.object({
+    title: t.string({ default: DEFAULT_TEXTS.title, maxLength: 12, label: { en: "Name in the score", es: "Nombre en el marcador" }, help: { en: "Letters, digits and - . ! ?", es: "Letras, cifras y - . ! ?" } })
+  }),
+  sources: [SESSIONS_SOURCE],
+  fps: 12,
+  async prepare(ctx) {
+    if (ctx.width < 8 || ctx.height < 8) return null;
+    const texts = {
+      title: ctx.options.title.trim() || DEFAULT_TEXTS.title,
+      world: ctx.t({ en: "RELEASE", es: "VERSION" }),
+      level: levelFor(ctx.seed),
+      time: ctx.t({ en: "TIME", es: "TIEMPO" }),
+      retry: ctx.t({ en: "TRY AGAIN", es: "OTRA VEZ SERA" })
+    };
+    const p = runnerPlayer(ctx.width, ctx.height, ctx.seed, texts);
+    return { frames: p.frames, draw: p.draw };
+  },
+  // A session blocked on a permission prompt is no time to play.
+  skip: ({ sources }) => needsPermission(sessionsOf(sources))
+});
+var index_default = definePlugin({
+  id: "agents",
+  name: { en: "AI agents", es: "Agentes IA" },
+  version: "0.2.0",
+  description: {
+    en: "Claude Code and Gemini CLI sessions at a glance: who waits for you, for how long, and git status. Ported from aimonitor.",
+    es: "Las sesiones de Claude Code y Gemini CLI de un vistazo: qui\xE9n te espera, desde cu\xE1ndo y el estado de git. Portado de aimonitor."
+  },
+  author: "Kiosko",
+  license: "MIT",
+  icon: "bot",
+  widgets: [sessionsWidget, summaryWidget],
+  sources: [sessionsSource],
+  interludes: [runner]
+});
+export {
+  assignWeights,
+  index_default as default,
+  plan,
+  runner,
+  sessionsSource,
+  sessionsWidget,
+  spareWidth,
+  summaryWidget
+};