shraga 0.0.3 → 0.1.2

package/src/server/mcp.ts

@@ -0,0 +1,291 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { dataPath } from './paths.ts';
+import { dataSync } from './data-sync.ts';
+import { getGlobalMcpsFromConfig } from './shraga-config.ts';
+
+const MCP_DIR = dataPath('mcps');
+
+export interface McpStdioServerConfig {
+  /** When false, server stays in config for UI / sync but is omitted from the Claude SDK. Default: true. */
+  enabled?: boolean;
+  /** Claude Code CLI expects stdio transports to declare type (see --mcp-config validation). */
+  type?: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface McpHttpServerConfig {
+  enabled?: boolean;
+  type: 'http';
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export type McpServerConfig = McpStdioServerConfig | McpHttpServerConfig;
+
+export type McpConfig = Record<string, McpServerConfig>;
+
+function loadJson(file: string): McpConfig {
+  if (!existsSync(file)) return {};
+  try {
+    return JSON.parse(readFileSync(file, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function mcpPath(uid: string) {
+  return path.join(MCP_DIR, `${uid}.json`);
+}
+
+export function getGlobalMcpConfig(): McpConfig {
+  return getGlobalMcpsFromConfig();
+}
+
+export function getUserMcpConfig(uid: string): McpConfig {
+  return loadJson(mcpPath(uid));
+}
+
+function isHttpConfig(s: McpServerConfig): s is McpHttpServerConfig {
+  return s.type === 'http';
+}
+
+/** Resolve env values: empty → process.env[same key], "$VAR" → process.env[VAR] */
+function resolveEnv(config: McpConfig): McpConfig {
+  const resolved: McpConfig = {};
+  for (const [name, server] of Object.entries(config)) {
+    if (isHttpConfig(server)) { resolved[name] = server; continue; }
+    if (!server.env) { resolved[name] = server; continue; }
+    const env: Record<string, string> = {};
+    for (const [k, v] of Object.entries(server.env)) {
+      // env values can be null/undefined/non-string if a config was edited by hand
+      // or synced from another instance — coerce defensively so resolution never throws.
+      if (v == null || v === '') {
+        env[k] = process.env[k] || '';
+      } else if (typeof v !== 'string') {
+        env[k] = String(v);
+      } else if (v.startsWith('$')) {
+        env[k] = process.env[v.slice(1)] || '';
+      } else {
+        env[k] = v;
+      }
+    }
+    // Env-gate: a server that DECLARES env keys but resolves them all empty isn't configured for
+    // this deployment (e.g. an MCP that needs STRIPE_SECRET_KEY when none is set) — skip it instead
+    // of mounting → failing every turn. Servers with no declared env, or any value present, pass.
+    if (Object.keys(env).length > 0 && Object.values(env).every((v) => !v)) {
+      console.log(`[mcp] ${name}: skipped — required env (${Object.keys(env).join(', ')}) not set in this deployment`);
+      continue;
+    }
+    resolved[name] = { ...server, env };
+  }
+  return resolved;
+}
+
+const MASK_CHAR = '••••';
+
+function maskValue(v: string): string {
+  if (!v || v.length <= 8) return MASK_CHAR;
+  return `${v.slice(0, 4)}${MASK_CHAR}${v.slice(-4)}`;
+}
+
+function isMasked(v: string): boolean {
+  return v.includes(MASK_CHAR);
+}
+
+/** Mask env values for client display */
+export function maskEnvValues(config: McpConfig): McpConfig {
+  const masked: McpConfig = {};
+  for (const [name, server] of Object.entries(config)) {
+    if (isHttpConfig(server)) { masked[name] = server; continue; }
+    if (!server.env) { masked[name] = server; continue; }
+    const env: Record<string, string> = {};
+    for (const [k, v] of Object.entries(server.env)) {
+      env[k] = v ? maskValue(v) : '';
+    }
+    masked[name] = { ...server, env };
+  }
+  return masked;
+}
+
+/** Merge incoming config, preserving original values for masked fields */
+export function mergeWithOriginal(incoming: McpConfig, original: McpConfig): McpConfig {
+  const merged: McpConfig = {};
+  for (const [name, server] of Object.entries(incoming)) {
+    if (isHttpConfig(server)) { merged[name] = server; continue; }
+    if (!server.env) { merged[name] = server; continue; }
+    const orig = original[name];
+    const origEnv = (orig && !isHttpConfig(orig) ? orig.env : undefined) || {};
+    const env: Record<string, string> = {};
+    for (const [k, v] of Object.entries(server.env)) {
+      if (!isMasked(v)) {
+        env[k] = v;
+        continue;
+      }
+      const saved = origEnv[k];
+      env[k] =
+        saved != null && saved !== ''
+          ? saved
+          : (process.env[k] || '');
+    }
+    merged[name] = { ...server, env };
+  }
+  return merged;
+}
+
+/** Global MCPs merged with per-user overrides (raw, no env resolution) */
+export function getRawMcpConfig(uid: string): McpConfig {
+  return { ...getGlobalMcpConfig(), ...getUserMcpConfig(uid) };
+}
+
+/** Ensure stdio MCP entries match CLI schema (avoids silent drops / validation issues). */
+function withStdioType(config: McpConfig): McpConfig {
+  const out: McpConfig = {};
+  for (const [name, server] of Object.entries(config)) {
+    if (isHttpConfig(server)) { out[name] = server; continue; }
+    if (server.command && !server.type) out[name] = { type: 'stdio', ...server };
+    else out[name] = server;
+  }
+  return out;
+}
+
+const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..');
+
+/** Canonical path baked into MCP env when prod has the file deployed (cwd = app dir). */
+const GOOGLE_SA_DEPLOY_REL = './secrets/google-service-account.json';
+
+/**
+ * Resolve GOOGLE_SERVICE_ACCOUNT for any MCP that declares it in env.
+ * - Inline JSON when env starts with `{`.
+ * - Fall back to `secrets/google-service-account.json` when the path is bogus.
+ */
+function finalizeGoogleServiceAccountCredentials(config: McpConfig): McpConfig {
+  const jsonFromEnv = process.env.GOOGLE_SERVICE_ACCOUNT_JSON?.trim();
+  const defaultAbs = path.join(PROJECT_ROOT, 'secrets/google-service-account.json');
+  const defaultExists = existsSync(defaultAbs);
+
+  let result = { ...config };
+  for (const [name, entry] of Object.entries(result)) {
+    if (isHttpConfig(entry)) continue;
+    if (!entry.env || !('GOOGLE_SERVICE_ACCOUNT' in entry.env)) continue;
+
+    const accountFromResolve = entry.env.GOOGLE_SERVICE_ACCOUNT?.trim() ?? '';
+
+    if (jsonFromEnv?.startsWith('{')) {
+      result = { ...result, [name]: { ...entry, env: { ...entry.env, GOOGLE_SERVICE_ACCOUNT: jsonFromEnv } } };
+      continue;
+    }
+
+    if (accountFromResolve.startsWith('{')) continue;
+
+    const raw = accountFromResolve;
+    const pathOk =
+      raw &&
+      !raw.includes('${') &&
+      existsSync(path.isAbsolute(raw) ? raw : path.resolve(PROJECT_ROOT, raw.replace(/^\.\//, '')));
+
+    if (pathOk) continue;
+    if (!defaultExists) continue;
+
+    result = { ...result, [name]: { ...entry, env: { ...entry.env, GOOGLE_SERVICE_ACCOUNT: GOOGLE_SA_DEPLOY_REL } } };
+  }
+
+  return result;
+}
+
+/**
+ * For MCP entries that declare FIREBASE_DATABASE_URL + FIREBASE_SERVICE_ACCOUNT_JSON in env:
+ * resolve from FIREBASE_CONFIG_* JSON blobs when the dedicated env vars are empty.
+ */
+function finalizeFirebaseCredentials(config: McpConfig): McpConfig {
+  let result = { ...config };
+  for (const [name, entry] of Object.entries(result)) {
+    if (isHttpConfig(entry)) continue;
+    if (!entry.env || !('FIREBASE_DATABASE_URL' in entry.env)) continue;
+
+    const patches: Record<string, string> = {};
+    const isEmpty = (v?: string) => !v || v.startsWith('${');
+
+    if (isEmpty(entry.env.FIREBASE_DATABASE_URL)) {
+      const suffix = name.includes('lab') ? 'LAB' : name.includes('prod') ? 'PROD' : '';
+      const configKeys = suffix
+        ? [`FIREBASE_CONFIG_${suffix}`, `VITE_FIREBASE_CONFIG_${suffix}`, 'FIREBASE_CONFIG']
+        : ['FIREBASE_CONFIG'];
+      const configJson = configKeys.map(k => process.env[k]).find(v => v?.trim());
+      if (configJson) try {
+        const parsed = JSON.parse(configJson);
+        if (parsed.databaseURL) patches.FIREBASE_DATABASE_URL = parsed.databaseURL;
+      } catch { /* not valid JSON */ }
+    }
+
+    if (isEmpty(entry.env.FIREBASE_SERVICE_ACCOUNT_JSON)) {
+      const suffix = name.includes('lab') ? 'LAB' : name.includes('prod') ? 'PROD' : '';
+      const saKeys = suffix
+        ? [`FIREBASE_SERVICE_ACCOUNT_JSON_${suffix}`, 'FIREBASE_SERVICE_ACCOUNT_JSON']
+        : ['FIREBASE_SERVICE_ACCOUNT_JSON'];
+      const sa = saKeys.map(k => process.env[k]).find(v => v?.trim());
+      if (sa) patches.FIREBASE_SERVICE_ACCOUNT_JSON = sa;
+    }
+
+    if (Object.keys(patches).length) {
+      result = { ...result, [name]: { ...entry, env: { ...entry.env, ...patches } } };
+    }
+  }
+  return result;
+}
+
+/** Full merged MCP config (includes `enabled: false` entries) for API/UI. */
+export function getResolvedMcpConfig(uid: string): McpConfig {
+  return finalizeFirebaseCredentials(
+    finalizeGoogleServiceAccountCredentials(
+      resolveEnv(
+        withStdioType(
+          getRawMcpConfig(uid),
+        ),
+      ),
+    ),
+  );
+}
+
+/** Strip disabled servers and drop `enabled` before passing to Claude Code (unknown keys can break validation). */
+function activeMcpConfigForSdk(config: McpConfig): McpConfig {
+  const out: McpConfig = {};
+  for (const [name, server] of Object.entries(config)) {
+    if (server.enabled === false) continue;
+    const sdkServer = { ...server };
+    delete (sdkServer as { enabled?: boolean }).enabled;
+    out[name] = sdkServer;
+  }
+  return out;
+}
+
+/** Active MCPs only — used by agent, schedulers, webhooks, CLI sync. */
+export function getMcpConfig(uid: string): McpConfig {
+  return activeMcpConfigForSdk(getResolvedMcpConfig(uid));
+}
+
+/** Resolved, SDK-ready GLOBAL mcp config (no per-user overlay) — for boot/background catalog warm-up.
+ *  The slow/shared servers are global, so warming this
+ *  populates their catalog entries off the turn path. Per-user-only servers warm on first use. */
+export function getGlobalMcpConfigForSdk(): McpConfig {
+  return activeMcpConfigForSdk(
+    finalizeFirebaseCredentials(
+      finalizeGoogleServiceAccountCredentials(
+        resolveEnv(
+          withStdioType(
+            getGlobalMcpConfig(),
+          ),
+        ),
+      ),
+    ),
+  );
+}
+
+export function saveMcpConfig(uid: string, config: McpConfig): void {
+  mkdirSync(MCP_DIR, { recursive: true });
+  writeFileSync(mcpPath(uid), JSON.stringify(config, null, 2));
+  dataSync.trackWrite(`mcps/${uid}.json`);
+}
+

package/src/server/model-aliases.ts

@@ -0,0 +1,76 @@
+/**
+ * Model aliasing + mid-conversation switch resolution — pure, dependency-free.
+ *
+ * The shared mechanism every model consumer in Shraga uses to resolve `[opus]`-style aliases,
+ * gate by an allow-list, and announce a switch identically. Policy (which models a caller may
+ * use) and session state (the prior model) stay with the consumer; this module is the mechanism.
+ */
+
+/** Canonical short aliases → concrete Anthropic model ids. */
+export const MODEL_ALIASES: Record<string, string> = {
+  fable: 'claude-fable-5',
+  'fable-5': 'claude-fable-5',
+  opus: 'claude-opus-4-8',
+  'opus-4-8': 'claude-opus-4-8',
+  'opus-4-7': 'claude-opus-4-7',
+  'opus-4-6': 'claude-opus-4-6',
+  sonnet: 'claude-sonnet-4-6',
+  haiku: 'claude-haiku-4-5-20251001',
+};
+
+/** Resolve an alias to a concrete id. A provider prefix ("anthropic/") is preserved; unknown ids pass through. */
+export function resolveModelAlias(input: string): string {
+  const slash = input.indexOf('/');
+  const prefix = slash === -1 ? '' : input.slice(0, slash + 1);
+  const rest = slash === -1 ? input : input.slice(slash + 1);
+  return prefix + (MODEL_ALIASES[rest.toLowerCase()] ?? rest);
+}
+
+/** Short, human-friendly name for a resolved model id (e.g. "anthropic/claude-opus-4-8" → "opus"). */
+export function modelShortLabel(model?: string): string {
+  if (!model) return 'default';
+  const id = model.split('/').pop()!;
+  return id.replace(/^claude-/, '').replace(/-\d.*$/, '');
+}
+
+export interface ResolveModelSwitchOpts {
+  /** Model requested for this turn (e.g. from an inline directive). Undefined = keep `current`. */
+  requested?: string;
+  /** The turn's default/current model when nothing is requested. */
+  current: string;
+  /** The session's prior resolved model — drives change detection + the notice. */
+  prior?: string;
+  /** If set, `requested` must match one of these (by short label) or it's denied and `current` is kept. */
+  allowed?: string[];
+  /** Announcement formatter. Default: `_[switching from x to y]_\n\n`. */
+  format?: (from: string, to: string) => string;
+}
+
+export interface ModelSwitch {
+  /** The model to run this turn. */
+  model: string;
+  /** True when `requested` was rejected by `allowed` and `model` fell back to `current`. */
+  denied: boolean;
+  /** Inline notice to surface when the model actually changed vs `prior`, else undefined. */
+  notice?: string;
+}
+
+/**
+ * Resolve which model a turn runs, given an optional request, an allow-list, and the prior model.
+ * Comparisons are by short label so provider-prefixed and dated ids unify
+ * ("anthropic/claude-opus-4-8" ≡ "claude-opus-4-8" ≡ "opus").
+ */
+export function resolveModelSwitch(opts: ResolveModelSwitchOpts): ModelSwitch {
+  const { requested, current, prior, allowed } = opts;
+  if (!requested) return { model: current, denied: false };
+  if (allowed && !allowed.some((a) => modelShortLabel(a) === modelShortLabel(requested))) {
+    return { model: current, denied: true };
+  }
+  const fmt = opts.format ?? ((from: string, to: string) => `_[switching from ${from} to ${to}]_\n\n`);
+  const changed = prior !== undefined && modelShortLabel(prior) !== modelShortLabel(requested);
+  return {
+    model: requested,
+    denied: false,
+    notice: changed ? fmt(modelShortLabel(prior!), modelShortLabel(requested)) : undefined,
+  };
+}

package/src/server/paths.ts

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { readdirSync } from 'node:fs';
+
+function resolveDataDir(): string {
+  if (process.env.DATA_DIR) return process.env.DATA_DIR;
+  const root = process.cwd();
+  const hasNamed = readdirSync(root).some(f => f.startsWith('data-'));
+  if (hasNamed) {
+    throw new Error(
+      `DATA_DIR not set but named data dirs exist (data-*). ` +
+      `Run via 'bun run dev <env>' or set DATA_DIR explicitly.`
+    );
+  }
+  return path.resolve(root, 'data');
+}
+
+export const DATA_DIR = resolveDataDir();
+export const dataPath = (...segments: string[]) => path.join(DATA_DIR, ...segments);
+
+// The Shraga app root (where `defaults/` lives and the agent's project filesystem is rooted).
+// Derived from THIS module's stable location — `src/server/paths.ts` → repo root is two dirs up — so
+// it's correct even for code loaded from an overlay checkout in a different directory (where
+// `import.meta.dirname`-relative math would resolve to the overlay, not the app).
+export const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..');

package/src/server/polls.ts

@@ -0,0 +1,175 @@
+// Proactive Slack poll / directed-question state. The mcp-slack-use `post_slack_poll`
+// tool posts the interactive message; shraga owns everything after: vote state, live
+// tally updates (chat.update), closing on deadline/quorum/first-answer, and waking the
+// originating agent session once with the result ("close then report").
+//
+// Decoupled from claude.ts via injected runners (see initPolls) to avoid an import cycle.
+import { mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { dataPath } from './paths.ts';
+import { appendMessage, getSession, type ConvBlock } from './sessions.ts';
+import { addUnread } from './unread.ts';
+import { postMessage, slackPost, getUserName, buildPollBlocks, type PollSpec } from './slack/api.ts';
+import { findSlackSessionBySessionId } from './slack/sessions.ts';
+
+const PREFIX = '[polls]';
+
+export interface PollRecord extends PollSpec {
+  channel: string;
+  ts: string;
+  useUserToken?: boolean;
+  votes: Record<string, number[]>; // userId -> chosen option indices
+  status: 'open' | 'closed';
+  deadlineAt?: number;
+  quorum?: number;
+  sessionId: string; // originating session to report back to
+  uid: string;
+  userEmail?: string;
+  createdAt: number;
+}
+
+// ── IoC: injected by index.ts at startup to avoid a claude.ts <-> polls.ts cycle ──
+type TurnRunner = (args: { prompt: string; sessionId: string; uid: string; userEmail?: string }) => Promise<ConvBlock[]>;
+let runTurn: TurnRunner | null = null;
+let broadcastFn: ((ev: object) => void) | null = null;
+
+export function initPolls(deps: { runTurn: TurnRunner; broadcast: (ev: object) => void }): void {
+  runTurn = deps.runTurn;
+  broadcastFn = deps.broadcast;
+  setInterval(sweep, 60_000);
+  console.log(`${PREFIX} sweeper started`);
+}
+
+const PRUNE_AFTER_MS = 7 * 24 * 60 * 60_000; // delete closed poll files after 7 days
+
+/** Close polls past their deadline; prune long-closed poll files. */
+function sweep(): void {
+  const now = Date.now();
+  let files: string[];
+  try { files = readdirSync(dir()).filter((f) => f.endsWith('.json')); } catch { return; }
+  for (const f of files) {
+    let p: PollRecord | null = null;
+    try { p = JSON.parse(readFileSync(path.join(dir(), f), 'utf-8')) as PollRecord; } catch { continue; }
+    if (!p) continue;
+    if (p.status === 'open' && p.deadlineAt && now >= p.deadlineAt) {
+      closePoll(p.pollId, 'deadline').catch((e) => console.error(`${PREFIX} sweep close failed:`, (e as Error)?.message));
+    } else if (p.status === 'closed' && now - p.createdAt > PRUNE_AFTER_MS) {
+      try { rmSync(path.join(dir(), f)); } catch { /* ignore */ }
+    }
+  }
+}
+
+// ── Storage ───────────────────────────────────────────────────────────────────
+const dir = (): string => { const d = dataPath('polls'); mkdirSync(d, { recursive: true }); return d; };
+const file = (id: string): string => path.join(dir(), `${id}.json`);
+
+export function loadPoll(id: string): PollRecord | null {
+  try { return JSON.parse(readFileSync(file(id), 'utf-8')) as PollRecord; } catch { return null; }
+}
+function save(p: PollRecord): void { writeFileSync(file(p.pollId), JSON.stringify(p, null, 2)); }
+
+const toSpec = (p: PollRecord): PollSpec => ({ pollId: p.pollId, title: p.title, options: p.options, kind: p.kind, multi: p.multi, targetUser: p.targetUser });
+function tallies(p: PollRecord): number[] {
+  const t = p.options.map(() => 0);
+  for (const idxs of Object.values(p.votes)) for (const i of idxs) if (t[i] !== undefined) t[i]++;
+  return t;
+}
+const voterCount = (p: PollRecord): number => Object.keys(p.votes).length;
+
+async function rerender(p: PollRecord, closed = false): Promise<void> {
+  await slackPost('chat.update', { channel: p.channel, ts: p.ts, text: p.title, blocks: buildPollBlocks(toSpec(p), tallies(p), voterCount(p), closed) }, p.useUserToken)
+    .catch((e) => console.error(`${PREFIX} rerender failed:`, (e as Error)?.message));
+}
+
+// ── Registration (called from claude.ts on a post_slack_poll tool result) ───────
+export interface RegisterPollInput {
+  pollId: string; channel: string; ts: string; title: string;
+  options: { label: string; description?: string }[];
+  kind: 'poll' | 'question'; multi?: boolean; targetUser?: string;
+  deadlineMinutes?: number; quorum?: number; useUserToken?: boolean;
+  sessionId: string; uid: string; userEmail?: string;
+}
+
+export function registerPoll(i: RegisterPollInput): void {
+  const p: PollRecord = {
+    pollId: i.pollId, title: i.title, options: i.options, kind: i.kind, multi: i.multi, targetUser: i.targetUser,
+    channel: i.channel, ts: i.ts, useUserToken: i.useUserToken,
+    votes: {}, status: 'open', createdAt: Date.now(),
+    deadlineAt: i.deadlineMinutes ? Date.now() + i.deadlineMinutes * 60_000 : undefined,
+    quorum: i.quorum, sessionId: i.sessionId, uid: i.uid, userEmail: i.userEmail,
+  };
+  save(p);
+  console.log(`${PREFIX} registered ${p.pollId} kind=${p.kind} ch=${p.channel} deadline=${i.deadlineMinutes ?? '-'}m quorum=${i.quorum ?? '-'}`);
+}
+
+// ── Interactivity (called from slack/questions.ts) ──────────────────────────────
+export async function handlePollVote(pollId: string, userId: string, optIdx: number): Promise<void> {
+  const p = loadPoll(pollId);
+  if (!p || p.status === 'closed') return;
+  // Directed question: only the addressed user may answer.
+  if (p.kind === 'question' && p.targetUser && userId !== p.targetUser) return;
+
+  const cur = new Set(p.votes[userId] ?? []);
+  if (p.kind === 'question' || !p.multi) {
+    if (cur.has(optIdx)) cur.delete(optIdx); else { cur.clear(); cur.add(optIdx); }
+  } else {
+    cur.has(optIdx) ? cur.delete(optIdx) : cur.add(optIdx);
+  }
+  if (cur.size) p.votes[userId] = [...cur]; else delete p.votes[userId];
+  save(p);
+
+  const complete = p.kind === 'question'
+    ? (p.targetUser ? (p.votes[p.targetUser]?.length ?? 0) > 0 : voterCount(p) > 0)
+    : (p.quorum ? voterCount(p) >= p.quorum : false);
+  if (complete) await closePoll(pollId, 'quorum'); else await rerender(p, false);
+}
+
+export async function handlePollClose(pollId: string): Promise<void> {
+  await closePoll(pollId, 'manual');
+}
+
+async function closePoll(pollId: string, reason: 'deadline' | 'quorum' | 'manual'): Promise<void> {
+  const p = loadPoll(pollId);
+  if (!p || p.status === 'closed') return;
+  p.status = 'closed';
+  save(p);
+  await rerender(p, true);
+  console.log(`${PREFIX} closed ${pollId} reason=${reason} voters=${voterCount(p)}`);
+  await wakeAgent(p, reason).catch((e) => console.error(`${PREFIX} wake failed:`, (e as Error)?.message));
+}
+
+// ── Close then report: wake the originating session once with the tally ─────────
+async function wakeAgent(p: PollRecord, reason: string): Promise<void> {
+  if (!runTurn) { console.warn(`${PREFIX} no turn runner; skipping wake for ${p.pollId}`); return; }
+  if (!getSession(p.sessionId)) { console.warn(`${PREFIX} session ${p.sessionId} gone; skipping wake`); return; }
+
+  // Per-option voters, with Slack user ids resolved to display names (cached).
+  const votersByOption: string[][] = p.options.map(() => []);
+  for (const [userId, idxs] of Object.entries(p.votes)) for (const i of idxs) if (votersByOption[i]) votersByOption[i].push(userId);
+  const nameCache = new Map<string, string>();
+  const resolveName = async (uid: string): Promise<string> => {
+    if (nameCache.has(uid)) return nameCache.get(uid)!;
+    const n = (await getUserName(uid).catch(() => null)) || uid;
+    nameCache.set(uid, n);
+    return n;
+  };
+  const lines = (await Promise.all(p.options.map(async (o, i) => {
+    const names = await Promise.all(votersByOption[i].map(resolveName));
+    const c = votersByOption[i].length;
+    return `- ${o.label}: ${c} vote${c === 1 ? '' : 's'}${names.length ? ` (${names.join(', ')})` : ''}`;
+  }))).join('\n');
+  const headline = p.kind === 'question' ? 'Your question was answered' : `Your poll closed (${reason})`;
+  const prompt = `[Poll result] ${headline}. Title: "${p.title}". ${voterCount(p)} participant(s).\n${lines}\n\nFollow up appropriately (summarize, take the next action, or notify the relevant people). Do not re-post the poll.`;
+
+  appendMessage(p.sessionId, { id: crypto.randomUUID(), role: 'user', blocks: [{ type: 'text', text: prompt }], channel: 'poll' });
+  broadcastFn?.({ type: 'session_messages_changed', sessionId: p.sessionId });
+
+  const blocks = await runTurn({ prompt, sessionId: p.sessionId, uid: p.uid, userEmail: p.userEmail });
+  if (!blocks.length) return;
+  appendMessage(p.sessionId, { id: crypto.randomUUID(), role: 'assistant', blocks });
+  broadcastFn?.({ type: 'session_messages_changed', sessionId: p.sessionId });
+  const text = blocks.filter((b): b is { type: 'text'; text: string } => b.type === 'text').map((b) => b.text).join('\n\n').trim();
+  addUnread(p.uid, p.sessionId, text.slice(0, 120) || 'Poll closed', 'proactive', p.title);
+  const slack = findSlackSessionBySessionId(p.sessionId);
+  if (slack && text) await postMessage(slack.channel, text, slack.threadTs, slack.useUserToken).catch((e) => console.error(`${PREFIX} slack deliver failed:`, (e as Error)?.message));
+}

package/src/server/push/apns.ts

@@ -0,0 +1,113 @@
+// APNs (iOS) sender — token-based (.p8) auth over HTTP/2.
+//
+// CRITICAL: this MUST use node:http2, NOT fetch. Bun's fetch returns
+// `Malformed_HTTP_Response` against api.push.apple.com and never reaches Apple
+// (mocked unit tests still pass — so this path is only trustworthy when verified
+// with a LIVE dummy-token probe → expect HTTP 400 BadDeviceToken).
+//
+// Ported from appwrap/examples/push-relay/src/server.ts; adds a pooled
+// ClientHttp2Session and dead-token classification.
+import { connect, type ClientHttp2Session } from 'node:http2';
+import { createSign } from 'node:crypto';
+
+const env = (k: string) => process.env[k] || '';
+
+export interface PushMessage {
+  title: string;
+  body: string;
+  data?: Record<string, unknown>;
+}
+
+export interface ApnsResult {
+  status: number;
+  id?: string;
+  reason?: string;
+}
+
+/** True when APNs credentials are present (independent of PUSH_ENABLED). */
+export function apnsConfigured(): boolean {
+  return !!(env('APNS_KEY_P8_B64') && env('APNS_KEY_ID') && env('APNS_TEAM_ID'));
+}
+
+export function apnsTopic(): string {
+  return env('APNS_TOPIC');
+}
+
+function apnsHost(): string {
+  return env('APNS_ENV') === 'production' ? 'https://api.push.apple.com' : 'https://api.sandbox.push.apple.com';
+}
+
+const b64url = (o: object) => Buffer.from(JSON.stringify(o)).toString('base64url');
+
+// ── ES256 provider JWT (kid=APNS_KEY_ID, iss=APNS_TEAM_ID), cached < 50min ──
+let jwtCache: { jwt: string; at: number } | null = null;
+function apnsJwt(): string {
+  if (jwtCache && Date.now() - jwtCache.at < 50 * 60_000) return jwtCache.jwt;
+  const key = Buffer.from(env('APNS_KEY_P8_B64'), 'base64').toString('utf8');
+  const iat = Math.floor(Date.now() / 1000);
+  const head = b64url({ alg: 'ES256', kid: env('APNS_KEY_ID') });
+  const body = b64url({ iss: env('APNS_TEAM_ID'), iat });
+  const sig = createSign('SHA256').update(`${head}.${body}`).sign({ key, dsaEncoding: 'ieee-p1363' }).toString('base64url');
+  jwtCache = { jwt: `${head}.${body}.${sig}`, at: Date.now() };
+  return jwtCache.jwt;
+}
+
+// ── Pooled HTTP/2 session (one per host, reconnect on close/error) ──
+let session: ClientHttp2Session | null = null;
+function getSession(): ClientHttp2Session {
+  if (session && !session.closed && !session.destroyed) return session;
+  const s = connect(apnsHost());
+  s.on('error', (e: any) => {
+    console.error('[push] apns session error:', e?.message || e);
+    if (session === s) session = null;
+  });
+  s.on('close', () => { if (session === s) session = null; });
+  session = s;
+  return s;
+}
+
+function parseReason(data: string): string | undefined {
+  if (!data) return undefined;
+  try { return JSON.parse(data).reason; } catch { return data.slice(0, 120); }
+}
+
+/** A 410, or BadDeviceToken / Unregistered / DeviceTokenNotForTopic → the token is dead and should be pruned. */
+export function isApnsTokenDead(status: number, reason?: string): boolean {
+  if (status === 410) return true;
+  return reason === 'BadDeviceToken' || reason === 'Unregistered' || reason === 'DeviceTokenNotForTopic';
+}
+
+export function sendApns(token: string, topic: string, msg: PushMessage): Promise<ApnsResult> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (r: ApnsResult) => { if (settled) return; settled = true; resolve(r); };
+
+    let client: ClientHttp2Session;
+    try { client = getSession(); } catch (e: any) { return done({ status: 0, reason: String(e?.message || e) }); }
+
+    const payload = JSON.stringify({ aps: { alert: { title: msg.title, body: msg.body }, sound: 'default' }, ...(msg.data || {}) });
+    let req;
+    try {
+      req = client.request({
+        ':method': 'POST',
+        ':path': `/3/device/${token}`,
+        authorization: `bearer ${apnsJwt()}`,
+        'apns-topic': topic,
+        'apns-push-type': 'alert',
+        'apns-priority': '10',
+        'content-type': 'application/json',
+      });
+    } catch (e: any) {
+      session = null;
+      return done({ status: 0, reason: String(e?.message || e) });
+    }
+
+    let status = 0, id: string | undefined, data = '';
+    req.on('response', (h: any) => { status = h[':status']; id = h['apns-id']; });
+    req.on('data', (c: Buffer) => (data += c));
+    // Resolve at `end` so a non-200 surfaces APNs's `reason` (e.g. BadDeviceToken) instead of losing it.
+    req.on('end', () => done({ status, id, reason: parseReason(data) }));
+    req.on('error', (e: any) => { session = null; done({ status: 0, reason: String(e?.message || e) }); });
+    req.end(payload);
+  });
+}