shraga 0.0.3 → 0.1.1

package/src/server/slack/questions.ts

@@ -0,0 +1,112 @@
+// Slack-medium implementation of the AskUserQuestion flow: render the agent's
+// questions as a Block Kit form (radio_buttons / checkboxes + Submit button) and
+// resolve the pending turn when the user clicks Submit via Slack interactivity.
+import { slackPost } from './api.ts';
+import { handlePollVote, handlePollClose } from '../polls.ts';
+import type { QuestionHandler, AskQuestion, QuestionAnswers } from '../claude.ts';
+
+const PREFIX = '[slack-q]';
+const TTL_MS = 15 * 60_000; // questions expire after 15min → agent self-decides
+const SLACK_MAX = 75; // Slack option label/value max length
+
+type Ctx = { channel: string; threadTs?: string; useUserToken?: boolean };
+type Pending = Ctx & {
+  resolve: (answers: QuestionAnswers | null) => void;
+  questions: AskQuestion[];
+  messageTs?: string;
+  timer: ReturnType<typeof setTimeout>;
+};
+
+const pending = new Map<string, Pending>();
+
+const trunc = (s: string, n = SLACK_MAX) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+
+function buildBlocks(id: string, questions: AskQuestion[]): unknown[] {
+  const blocks: unknown[] = [];
+  questions.forEach((q, i) => {
+    blocks.push({ type: 'section', text: { type: 'mrkdwn', text: `*${q.question}*` } });
+    const options = q.options.map((o) => ({
+      text: { type: 'plain_text', text: trunc(o.label) },
+      value: trunc(o.label),
+      ...(o.description ? { description: { type: 'plain_text', text: trunc(o.description) } } : {}),
+    }));
+    blocks.push({
+      type: 'actions',
+      block_id: `q${i}`,
+      elements: [{ type: q.multiSelect ? 'checkboxes' : 'radio_buttons', action_id: `q${i}`, options }],
+    });
+  });
+  blocks.push({
+    type: 'actions',
+    elements: [{ type: 'button', action_id: `submit:${id}`, style: 'primary', value: id, text: { type: 'plain_text', text: 'Submit' } }],
+  });
+  return blocks;
+}
+
+/** Build a QuestionHandler bound to a Slack channel/thread for the current turn. */
+export function makeSlackQuestionHandler(ctx: Ctx): QuestionHandler {
+  return async (id, questions) => {
+    const res = await slackPost(
+      'chat.postMessage',
+      { channel: ctx.channel, thread_ts: ctx.threadTs, text: 'I have a few questions for you:', blocks: buildBlocks(id, questions) },
+      ctx.useUserToken,
+    ).catch((err) => { console.error(`${PREFIX} post failed:`, (err as Error)?.message); return null; });
+    if (!res?.ok) return null;
+    console.log(`${PREFIX} posted question ${id} (${questions.length}q) to ${ctx.channel}`);
+    return new Promise<QuestionAnswers | null>((resolve) => {
+      const timer = setTimeout(() => {
+        if (pending.delete(id)) { console.log(`${PREFIX} ${id} timed out`); resolve(null); }
+      }, TTL_MS);
+      pending.set(id, { ...ctx, resolve, questions, messageTs: res.ts, timer });
+    });
+  };
+}
+
+function parseAnswers(state: any, questions: AskQuestion[]): QuestionAnswers {
+  const answers: QuestionAnswers = {};
+  questions.forEach((q, i) => {
+    const block = state?.[`q${i}`]?.[`q${i}`];
+    if (!block) return;
+    if (q.multiSelect) {
+      const labels = (block.selected_options ?? []).map((o: any) => o.value);
+      if (labels.length) answers[q.question] = labels;
+    } else if (block.selected_option) {
+      answers[q.question] = block.selected_option.value;
+    }
+  });
+  return answers;
+}
+
+/**
+ * Handle a Slack interactivity payload (block_actions). Returns true if it
+ * resolved a pending question. Selection changes (non-submit actions) are ignored.
+ */
+export async function handleSlackInteraction(payload: any): Promise<boolean> {
+  if (payload?.type !== 'block_actions') return false;
+  const userId = payload.user?.id as string | undefined;
+
+  // Poll / directed-question votes — action_id `poll:vote:<id>:<optIdx>` or `poll:close:<id>`.
+  const pollAction = (payload.actions ?? []).find((a: any) => typeof a.action_id === 'string' && a.action_id.startsWith('poll:'));
+  if (pollAction) {
+    const [, verb, pollId, optIdx] = (pollAction.action_id as string).split(':');
+    if (verb === 'close') await handlePollClose(pollId);
+    else if (verb === 'vote' && userId) await handlePollVote(pollId, userId, Number(optIdx));
+    return true;
+  }
+
+  const submit = (payload.actions ?? []).find((a: any) => typeof a.action_id === 'string' && a.action_id.startsWith('submit:'));
+  if (!submit) return false;
+  const id = submit.value as string;
+  const p = pending.get(id);
+  if (!p) return false;
+  pending.delete(id);
+  clearTimeout(p.timer);
+  const answers = parseAnswers(payload.state?.values, p.questions);
+  if (p.messageTs) {
+    const summary = Object.entries(answers).map(([q, a]) => `• *${q}* — ${Array.isArray(a) ? a.join(', ') : a}`).join('\n') || '_(no selection)_';
+    await slackPost('chat.update', { channel: p.channel, ts: p.messageTs, text: '✅ Got your answers.', blocks: [{ type: 'section', text: { type: 'mrkdwn', text: `✅ Got your answers:\n${summary}` } }] }, p.useUserToken).catch(() => {});
+  }
+  console.log(`${PREFIX} resolved question ${id} (${Object.keys(answers).length} answered)`);
+  p.resolve(Object.keys(answers).length ? answers : null);
+  return true;
+}

package/src/server/slack/sessions.ts

@@ -0,0 +1,139 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dataPath } from '../paths.ts';
+import { upsertSession } from '../sessions.ts';
+
+interface SlackSession {
+  sessionId: string;
+  channel: string;
+  lastActivity: number;
+  lastMessageTs?: string;
+  useUserToken?: boolean;
+  flat?: boolean;
+}
+
+const MAPPING_FILE = dataPath('slack-sessions.json');
+const PROACTIVE_FILE = dataPath('slack-proactive.json');
+const SLACK_BOT_EMAIL = 'slack-bot@shraga.local';
+/**
+ * Placeholder emails that mean "no real user" — NOT an address to attribute a turn to.
+ * `slack-bot@unclaw.local` is the legacy value and is still persisted in existing
+ * `slack-sessions.json` files, so it must keep being recognised.
+ */
+const SLACK_BOT_EMAILS: readonly string[] = [SLACK_BOT_EMAIL, 'slack-bot@unclaw.local'];
+
+export function isSlackBotPlaceholderEmail(email: string | undefined): boolean {
+  return !!email && SLACK_BOT_EMAILS.includes(email);
+}
+
+const SLACK_USER = { uid: 'slack-bot', email: SLACK_BOT_EMAIL, name: 'Slack Bot' };
+
+let mapping: Record<string, SlackSession> = {};
+
+function loadMapping() {
+  if (existsSync(MAPPING_FILE)) {
+    try { mapping = JSON.parse(readFileSync(MAPPING_FILE, 'utf-8')); } catch { mapping = {}; }
+  }
+}
+
+function saveMapping() {
+  writeFileSync(MAPPING_FILE, JSON.stringify(mapping, null, 2));
+}
+
+export function threadKey(channel: string, threadTs: string): string {
+  return `${channel}:${threadTs}`;
+}
+
+/** Register an additional thread key pointing to an existing session (e.g. bot reply ts). */
+export function registerThreadAlias(channel: string, threadTs: string, sessionId: string): void {
+  loadMapping();
+  const key = threadKey(channel, threadTs);
+  if (mapping[key]) return;
+  mapping[key] = { sessionId, channel, lastActivity: Date.now() };
+  saveMapping();
+}
+
+export function getOrCreateSession(channel: string, threadTs: string, firstPrompt: string, flat?: boolean, scope: 'system' | 'user' = 'system', user?: { uid: string; email: string; name?: string }): { sessionId: string; isNew: boolean } {
+  loadMapping();
+  const key = threadKey(channel, threadTs);
+  if (mapping[key]) {
+    mapping[key].lastActivity = Date.now();
+    saveMapping();
+    return { sessionId: mapping[key].sessionId, isNew: false };
+  }
+
+  const sessionId = crypto.randomUUID();
+  // Attribute the session to the resolved human (for nightly reconcile user-scope writes).
+  // Unknown Slack users fall through to the synthetic SLACK_USER — runs, but won't mis-attribute.
+  upsertSession(sessionId, firstPrompt, user ?? SLACK_USER, scope);
+  mapping[key] = { sessionId, channel, lastActivity: Date.now(), ...(flat ? { flat: true } : {}) };
+  saveMapping();
+  return { sessionId, isNew: true };
+}
+
+/** True if an agent session already exists for this thread (read-only; does not create). */
+export function hasSessionForThread(channel: string, threadTs: string): boolean {
+  loadMapping();
+  return !!mapping[threadKey(channel, threadTs)];
+}
+
+export function setLastMessageTs(channel: string, threadTs: string, ts: string): void {
+  loadMapping();
+  const key = threadKey(channel, threadTs);
+  if (mapping[key]) {
+    mapping[key].lastMessageTs = ts;
+    saveMapping();
+  }
+}
+
+export function setFlat(channel: string, threadTs: string, flat: boolean): void {
+  loadMapping();
+  const key = threadKey(channel, threadTs);
+  if (mapping[key]) {
+    mapping[key].flat = flat;
+    saveMapping();
+  }
+}
+
+export function setUseUserToken(channel: string, threadTs: string, useUserToken: boolean): void {
+  loadMapping();
+  const key = threadKey(channel, threadTs);
+  if (mapping[key]) {
+    mapping[key].useUserToken = useUserToken;
+    saveMapping();
+  }
+}
+
+// --- Proactive message registry ---
+interface ProactiveMessage { sessionId: string; sessionTitle: string; sentAt: number; }
+let proactiveMap: Record<string, ProactiveMessage> = {};
+
+function loadProactive() {
+  if (existsSync(PROACTIVE_FILE)) {
+    try { proactiveMap = JSON.parse(readFileSync(PROACTIVE_FILE, 'utf-8')); } catch { proactiveMap = {}; }
+  }
+}
+function saveProactive() { writeFileSync(PROACTIVE_FILE, JSON.stringify(proactiveMap, null, 2)); }
+
+export function registerProactiveMessage(channel: string, ts: string, sessionId: string, sessionTitle: string): void {
+  loadProactive();
+  const key = threadKey(channel, ts);
+  proactiveMap[key] = { sessionId, sessionTitle, sentAt: Date.now() };
+  saveProactive();
+  console.log(`[slack] Registered proactive message: ${key} → session ${sessionId}`);
+}
+
+export function getProactiveOrigin(channel: string, ts: string): ProactiveMessage | null {
+  loadProactive();
+  return proactiveMap[threadKey(channel, ts)] || null;
+}
+
+export function findSlackSessionBySessionId(sessionId: string): { channel: string; threadTs: string; lastMessageTs?: string; useUserToken?: boolean; flat?: boolean } | null {
+  loadMapping();
+  for (const [key, entry] of Object.entries(mapping)) {
+    if (entry.sessionId === sessionId) {
+      const sepIdx = key.indexOf(':');
+      return { channel: key.slice(0, sepIdx), threadTs: key.slice(sepIdx + 1), lastMessageTs: entry.lastMessageTs, useUserToken: entry.useUserToken, flat: entry.flat };
+    }
+  }
+  return null;
+}

package/src/server/stats.ts

@@ -0,0 +1,106 @@
+// Shared machine-stats sampler: ONE interval samples the host (CPU/mem/load) for the
+// whole server and broadcasts each point to all clients. Clients never poll the box —
+// they seed from getStats() and then receive live points over WS. N users = 1 sampler.
+import os from 'node:os';
+import { readFileSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export interface StatSample {
+  t: number;   // epoch ms
+  cpu: number; // 0-100, host CPU utilization since last sample
+  mem: number; // 0-100, used / total memory
+  load: number; // 1-min load average
+}
+
+export class StatsSamplerOptions {
+  intervalMs = 5000;
+  window = 120; // ring-buffer length (120 × 5s = 10 min trend)
+}
+
+export class StatsSampler {
+  public options: StatsSamplerOptions;
+  private buffer: StatSample[] = [];
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private prevCpu = cpuTotals();
+  // Cached memory %, refreshed asynchronously each tick. NEVER read the OS memory synchronously in the
+  // sample path: on macOS that meant `execSync('memory_pressure')`, which blocks the event loop for
+  // ~1-2s (longer under load) every 5s — stalling /api/version long enough to trip the health watchdog
+  // into false-restarting a live server. Seed from the cheap os.freemem fallback until the first refresh.
+  private memPct = 100 * (1 - os.freemem() / os.totalmem());
+
+  public constructor(options?: Partial<StatsSamplerOptions>) {
+    this.options = { ...new StatsSamplerOptions(), ...options };
+  }
+
+  start(broadcast: (data: object) => void) {
+    if (this.timer) return; // singleton — already running
+    void this.refreshMem(); // prime the cache; each tick refreshes it async for the NEXT sample
+    this.timer = setInterval(() => {
+      void this.refreshMem(); // async, non-blocking — updates this.memPct without stalling the loop
+      const sample = this.sample();
+      this.buffer.push(sample);
+      if (this.buffer.length > this.options.window) this.buffer.shift();
+      broadcast({ type: 'stats', sample });
+    }, this.options.intervalMs);
+    if (typeof this.timer.unref === 'function') this.timer.unref();
+    console.log(`[stats] sampling host every ${this.options.intervalMs}ms (window ${this.options.window})`);
+  }
+
+  stop() {
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+  }
+
+  getStats(): StatSample[] {
+    return this.buffer;
+  }
+
+  private sample(): StatSample {
+    const now = cpuTotals();
+    const idleDelta = now.idle - this.prevCpu.idle;
+    const totalDelta = now.total - this.prevCpu.total;
+    this.prevCpu = now;
+    const cpu = totalDelta > 0 ? Math.max(0, Math.min(100, 100 * (1 - idleDelta / totalDelta))) : 0;
+    return {
+      t: Date.now(),
+      cpu: Math.round(cpu),
+      mem: Math.round(this.memPct), // cached; refreshed async each tick (never blocks the loop)
+      load: Math.round(os.loadavg()[0] * 100) / 100,
+    };
+  }
+
+  // Refresh the cached memory %. os.freemem() counts reclaimable memory (page cache on Linux,
+  // inactive/purgeable pages on macOS) as "used", so it reads ~95-99% even when healthy — use each OS's
+  // notion of *available* (free + reclaimable) instead. Async + bounded so it can NEVER stall the loop.
+  private async refreshMem(): Promise<void> {
+    try {
+      if (process.platform === 'linux') {
+        const info = readFileSync('/proc/meminfo', 'utf8'); // tiny virtual file — negligible read
+        const total = +(info.match(/MemTotal:\s+(\d+)/)?.[1] ?? 0);
+        const avail = info.match(/MemAvailable:\s+(\d+)/)?.[1];
+        if (total > 0 && avail != null) { this.memPct = 100 * (1 - +avail / total); return; }
+      } else if (process.platform === 'darwin') {
+        // macOS pressure-aware "free percentage". Was execSync — which blocked the event loop for
+        // seconds every tick and tripped the health watchdog. Async with a hard timeout; killed and
+        // fell back if it stalls, so a slow/hung `memory_pressure` never touches the loop.
+        const { stdout } = await execFileAsync('memory_pressure', [], { encoding: 'utf8', timeout: 3000 });
+        const freePct = stdout.match(/free percentage:\s+(\d+)%/)?.[1];
+        if (freePct != null) { this.memPct = 100 - +freePct; return; }
+      }
+    } catch { /* fall through to os.freemem */ }
+    this.memPct = 100 * (1 - os.freemem() / os.totalmem());
+  }
+}
+
+function cpuTotals() {
+  let idle = 0, total = 0;
+  for (const c of os.cpus()) {
+    for (const v of Object.values(c.times)) total += v;
+    idle += c.times.idle;
+  }
+  return { idle, total };
+}
+
+export const statsSampler = new StatsSampler();

package/src/server/summarize.ts

@@ -0,0 +1,11 @@
+import { loadAgents } from './agents.ts';
+import { runTextQuery } from './sdk-utils.ts';
+
+export async function summarizeText(text: string, instruction: string): Promise<string> {
+  const agent = loadAgents()['summarizer'];
+  return runTextQuery({
+    prompt: `${instruction}\n\n${text}`,
+    model: agent?.model || 'haiku',
+    systemPrompt: agent?.prompt || 'You are a concise summarizer. Output only the summary, nothing else.',
+  });
+}

package/src/server/turn-context.ts

@@ -0,0 +1,61 @@
+// Turn-context seam — per-turn prompt contributions from optional add-ons.
+//
+// The core builds a turn's prompt and knows nothing about what an add-on might want to say about the
+// user's current situation. A contributor returns a short block that is prepended to THIS turn's
+// prompt only — never the cacheable contextBlock, never the persisted transcript.
+//
+// Sibling of the `features.ts` seam and shaped like it: typed, optional, registered before startup,
+// a no-op when nothing is registered (the core registers NOTHING here). The core concatenates
+// whatever comes back and interprets none of it.
+
+/** What the core knows about the turn. `hints` is the opaque client-supplied per-send bag (the
+ *  client's `setSendOptions` slot) — the core never interprets it; a contributor reads its own keys. */
+export interface TurnContextInput {
+  sessionId?: string;
+  uid?: string;
+  hints?: Record<string, unknown>;
+}
+
+/** Return a prompt block for this turn, or undefined/'' to contribute nothing. */
+export type TurnContextContributor = (input: TurnContextInput) => string | undefined;
+
+const contributors = new Map<string, TurnContextContributor>();
+
+/** Register a per-turn prompt contributor. Called by an add-on before startup. Idempotent by name. */
+export function registerTurnContext(name: string, contribute: TurnContextContributor): void {
+  if (contributors.has(name)) return;
+  contributors.set(name, contribute);
+}
+
+/**
+ * Collect every contributor's block for this turn, joined by a blank line. Empty when none is
+ * registered — which is the core's own state, so the core's prompt is byte-identical to before.
+ * A throwing contributor is contained (logged, others still contribute): a broken add-on must not
+ * take down a turn.
+ */
+export function collectTurnContext(input: TurnContextInput): string {
+  const blocks: string[] = [];
+  for (const [name, contribute] of contributors) {
+    try {
+      const block = contribute(input)?.trim();
+      if (block) blocks.push(block);
+    } catch (err) {
+      console.error(`[turn-context] ${name} failed:`, (err as Error)?.message ?? err);
+    }
+  }
+  return blocks.join('\n\n');
+}
+
+/**
+ * Sanitize a client-supplied hint value before a contributor interpolates it into the model prompt.
+ * Strips control chars/newlines and caps length, so a crafted value can't forge a second block or
+ * inject instructions. Generic (knows no add-on shape) and lives here because EVERY contributor
+ * interpolates untrusted `hints` — keeping it on the seam makes the requirement discoverable.
+ */
+export function sanitizeHintField(value: string, max: number): string {
+  return Array.from(value)
+    .filter((c) => { const n = c.charCodeAt(0); return n >= 32 && n !== 127; })
+    .join('')
+    .slice(0, max)
+    .trim();
+}

package/src/server/unclaw-config.ts

@@ -0,0 +1,19 @@
+/**
+ * Back-compat shim for the pre-de-brand module name. NOT a second source of truth —
+ * it re-exports `shraga-config.ts` and must never grow logic or its own types.
+ *
+ * Why it exists: a deployment's data config is written by the operator and value-imports
+ * this path (`import { defineConfig } from '../src/server/unclaw-config.ts'`), so the name
+ * is part of our public surface — renaming the module broke every deployment still carrying
+ * a legacy `data/unclaw.config.ts`, and the loader swallows that failure into an empty config.
+ *
+ * Same back-compat contract the loader already honours on the filename side
+ * (`CONFIG_FILENAMES = ['shraga.config.ts', 'unclaw.config.ts']`, new name preferred,
+ * old name still accepted) — this is that contract on the module side.
+ *
+ * Retire both together, once no deployment ships a legacy config.
+ */
+export * from './shraga-config.ts';
+
+/** Legacy name for {@link ShragaConfig} — the interface a legacy data config may annotate with. */
+export type { ShragaConfig as UnclawConfig } from './shraga-config.ts';

package/src/server/unread.ts

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dataPath } from './paths.ts';
+import { getSession } from './sessions.ts';
+
+export interface UnreadEntry {
+  count: number;
+  preview: string;
+  since: number;
+  lastAt: number;
+  source: 'response' | 'proactive' | 'schedule';
+  title?: string;
+}
+
+export interface UserUnreads {
+  sessions: Record<string, UnreadEntry>;
+}
+
+const UNREAD_DIR = dataPath('unread');
+
+function filePath(uid: string): string {
+  return `${UNREAD_DIR}/${uid}.json`;
+}
+
+function load(uid: string): UserUnreads {
+  const file = filePath(uid);
+  if (!existsSync(file)) return { sessions: {} };
+  try {
+    return JSON.parse(readFileSync(file, 'utf-8'));
+  } catch {
+    return { sessions: {} };
+  }
+}
+
+function save(uid: string, data: UserUnreads): void {
+  mkdirSync(UNREAD_DIR, { recursive: true });
+  writeFileSync(filePath(uid), JSON.stringify(data, null, 2));
+}
+
+export function addUnread(
+  uid: string,
+  sessionId: string,
+  preview: string,
+  source: UnreadEntry['source'],
+  title?: string,
+): UnreadEntry {
+  const data = load(uid);
+  const existing = data.sessions[sessionId];
+  const now = Date.now();
+  const entry: UnreadEntry = {
+    count: (existing?.count ?? 0) + 1,
+    preview,
+    since: existing?.since ?? now,
+    lastAt: now,
+    source,
+    ...(title ? { title } : existing?.title ? { title: existing.title } : {}),
+  };
+  data.sessions[sessionId] = entry;
+  save(uid, data);
+  return entry;
+}
+
+export function markRead(uid: string, sessionId: string): void {
+  const data = load(uid);
+  if (!data.sessions[sessionId]) return;
+  delete data.sessions[sessionId];
+  save(uid, data);
+}
+
+export function getUnreads(uid: string): UserUnreads {
+  const data = load(uid);
+  const sids = Object.keys(data.sessions);
+  const orphans = sids.filter(sid => !getSession(sid));
+  if (orphans.length > 0) {
+    for (const sid of orphans) delete data.sessions[sid];
+    save(uid, data);
+  }
+  return data;
+}
+

package/src/server/user-context.ts

@@ -0,0 +1,33 @@
+import { mkdirSync, existsSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { WORKSPACE_DIR } from './workspace.ts';
+import { injectFile } from './file-inject.ts';
+import type { Contact } from './contacts.ts';
+
+const STUB = (name: string) =>
+  `# ${name}\n\n## Summary\n\n_No learnings yet._\n\n## Corrections\n\n## How They Operate\n\n## Their Taste\n\n## Current Focus\n`;
+
+const SYSTEM_EMAIL_RE = /^(postmaster|mailer-daemon|noreply|no-reply|notifications?|drive-shares-dm-noreply)@/i;
+
+function isHumanContact(contact: Contact): boolean {
+  if (!contact.emails.length && !contact.slackIds.length) return false;
+  if (contact.emails.length && contact.emails.every(e => SYSTEM_EMAIL_RE.test(e))) return false;
+  return true;
+}
+
+export function ensureUserDir(contact: Contact): string | null {
+  if (!isHumanContact(contact)) return null;
+  const dir = path.join(WORKSPACE_DIR, 'users', contact.id);
+  mkdirSync(dir, { recursive: true });
+  const contextFile = path.join(dir, 'user-context.md');
+  if (!existsSync(contextFile)) writeFileSync(contextFile, STUB(contact.name), 'utf-8');
+  return dir;
+}
+
+export function getUserContextBlock(contact: Contact | null): string {
+  if (!contact) return '';
+  const dir = ensureUserDir(contact);
+  if (!dir) return '';
+  const filePath = path.join(dir, 'user-context.md');
+  return injectFile(filePath, { label: 'user-context', maxChars: 3000 });
+}

package/src/server/vendor-sync.ts

@@ -0,0 +1,52 @@
+import { readdirSync, lstatSync, readlinkSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { $ } from 'bun';
+
+const TAG = '[vendor-sync]';
+const VENDOR_DIR = resolve(import.meta.dir, '../../vendor');
+
+export async function syncVendorRepos(): Promise<void> {
+  let entries: string[];
+  try {
+    entries = readdirSync(VENDOR_DIR);
+  } catch {
+    return;
+  }
+
+  const dirs = entries.filter(e => {
+    const full = join(VENDOR_DIR, e);
+    try {
+      const stat = lstatSync(full);
+      if (!stat.isSymbolicLink()) return false;
+      const target = resolve(VENDOR_DIR, readlinkSync(full));
+      return lstatSync(target).isDirectory();
+    } catch { return false; }
+  });
+
+  if (!dirs.length) return;
+
+  const results = await Promise.allSettled(
+    dirs.map(async name => {
+      const target = resolve(VENDOR_DIR, readlinkSync(join(VENDOR_DIR, name)));
+      const gitDir = join(target, '.git');
+      try { lstatSync(gitDir); } catch { return; }
+      // skip branches with no upstream (e.g. local feature branches) — pull would always fail
+      const upstream = await $`git -C ${target} rev-parse --abbrev-ref @{u}`.nothrow().quiet();
+      if (upstream.exitCode !== 0) {
+        const branch = (await $`git -C ${target} branch --show-current`.nothrow().quiet()).stdout.toString().trim();
+        console.log(`${TAG} ${name}: skipped (branch '${branch}' has no upstream)`);
+        return;
+      }
+      const { stdout, exitCode } = await $`git -C ${target} pull --ff-only 2>&1`.nothrow().quiet();
+      const out = stdout.toString().trim();
+      if (exitCode !== 0) {
+        console.warn(`${TAG} ${name}: pull failed — ${out}`);
+      } else if (!out.includes('Already up to date')) {
+        console.log(`${TAG} ${name}: ${out.split('\n').pop()}`);
+      }
+    })
+  );
+
+  const failed = results.filter(r => r.status === 'rejected').length;
+  if (failed) console.warn(`${TAG} ${failed} repo(s) failed to sync`);
+}