shraga 0.1.110 → 0.1.112

package/src/server/engine/claude-resume.ts

@@ -0,0 +1,205 @@
+/**
+ * Opt-in SDK session resume for the claude-code engine — the pure half (decision + prompt building),
+ * kept free of SDK/IO wiring so every fallback reason is unit-testable.
+ *
+ * Fresh turn (today's path): ONE user message = contextBlock + <conversation_history> + new message, so
+ * the whole history is re-written to prompt cache every turn. Resume turn: `resume: <claudeSessionId>`
+ * and send only the new message; the stable context went in once on the session's fresh query, and
+ * whatever CHANGED since (context sections, messages other channels appended) plus the current speaker's
+ * `user` section rides AFTER the user text so the cached transcript prefix stays byte-identical. Only one
+ * speaker's turns ever share a CC session (speaker-change).
+ *
+ * Flag: `directives.resume` (per conversation: `[resume:on]` or PUT /api/sessions/:id/directives) over
+ * `agent-config.json` `sdkResume` (global, re-read every turn). Default OFF.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import type { ConvMessage } from '../sessions.ts';
+import type { Directives } from '../directives.ts';
+import type { AgentSettings } from '../shraga-config.ts';
+
+/** Persisted on SessionMeta.claudeResume — the facts needed to decide whether the stored CC session
+ *  may be resumed. Hashes, not content: this lives in the 9 MB sessions index. */
+export interface ClaudeResumeState {
+  /** Claude Code session id (SDK init/result `session_id`); resume keeps it stable across turns. */
+  claudeSessionId: string;
+  /** Hash of the CLAUDE_CONFIG_DIR the transcript was written under (per-user login or box default). */
+  configDirHash: string;
+  /** speakerKey() of the person whose turns this CC session holds. Another speaker never resumes it: the
+   *  transcript carries this speaker's private user context (learnings/corrections). */
+  speaker?: string;
+  /** Model the last turn resolved (informational — CC resumes across models; only the cache is per-model). */
+  model?: string;
+  /** When this CC session was started (first fresh query). */
+  startedAt: number;
+  /** Id of the last conversation message at the start of the last turn; messages after it are what CC hasn't seen. */
+  markId?: string;
+  /** Identity of the newest shraga summary / compact marker when the state was saved. */
+  summaryKey: string;
+  /** Section name → hash of the context CC has already been given. */
+  sections: Record<string, string>;
+  /** Set by the core when another engine ran a turn on this session (its turns aren't in the CC transcript). */
+  interruptedBy?: string;
+}
+
+export type TurnPath = 'resume' | 'fresh' | `fallback:${string}`;
+
+/** Unseen out-of-band text above this size means resume would re-send a history anyway — go fresh. */
+export const MAX_UNSEEN_CHARS = 30_000;
+
+export function isResumeEnabled(directives: Directives, config: AgentSettings): boolean {
+  // The per-session directives endpoint stores passthrough values opaquely, so accept string forms too.
+  const v = (directives.resume ?? config.sdkResume) as unknown;
+  return v === true || v === 'on' || v === 'true';
+}
+
+export function shortHash(text: string): string {
+  return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+
+/** Who is speaking, as a hash (the sessions index must not gain raw emails). */
+export function speakerKey(uid: string, email?: string): string {
+  return shortHash(`${uid}\n${email?.trim().toLowerCase() ?? ''}`);
+}
+
+/** Errors that mean THIS resume can't run (the stored transcript is gone/unreadable) — worth one fresh retry.
+ *  Anything else (quota, auth, API, process crash) would fail a fresh query the same way: surface it as-is. */
+export function isResumeFailure(text: string): boolean {
+  return /No conversation found|\b(session|transcript)\b.{0,60}\b(not found|missing|corrupt|invalid)\b/i.test(text);
+}
+
+/** Where the CLI keeps transcripts for a run: the routed per-user login, else the process's config dir. */
+export function claudeConfigDir(accountDir: string | null | undefined): string {
+  return accountDir || process.env.CLAUDE_CONFIG_DIR?.trim() || path.join(homedir(), '.claude');
+}
+
+/** `<configDir>/projects/<cwd-slug>/<id>.jsonl`, found by scan rather than by re-deriving the CLI's slug
+ *  rule (a wrong guess would silently turn every resume into a fallback). */
+export function findClaudeTranscript(sessionId: string, configDir: string): string | null {
+  const projects = path.join(configDir, 'projects');
+  if (!existsSync(projects)) return null;
+  for (const dir of readdirSync(projects, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const file = path.join(projects, dir.name, `${sessionId}.jsonl`);
+    if (existsSync(file)) return file;
+  }
+  return null;
+}
+
+/** One conversation message as history text — shared by the fresh history prompt and the resume tail. */
+export function renderConvMessage(m: ConvMessage): string | null {
+  const texts = m.blocks
+    .filter((b) => b.type === 'text' || b.type === 'context')
+    .map((b) => (b.type === 'context' ? `[${b.label}]: ${b.text}` : (b as { text: string }).text))
+    .filter(Boolean);
+  return texts.length ? `${m.role === 'user' ? 'User' : 'Assistant'}: ${texts.join('\n')}` : null;
+}
+
+/** Changes whenever maybeCompact writes a summary or /compact adds a marker (applyCompactMarkers
+ *  turns the latter into a synthetic leading message). */
+export function conversationSummaryKey(conv: ConvMessage[]): string {
+  for (let i = conv.length - 1; i >= 0; i--) {
+    const s = conv[i].blocks.find((b) => b.type === 'summary') as { compactedCount: number } | undefined;
+    if (s) return `summary:${s.compactedCount}`;
+  }
+  const first = conv[0];
+  if (first?.id === 'compact-summary') return `marker:${shortHash(renderConvMessage(first) ?? '')}`;
+  return '';
+}
+
+/**
+ * Messages CC has not seen: everything after the mark, minus the previous turn's own reply (the first
+ * message, when it is the assistant's) and this turn's prompt (the last, when it is a user message —
+ * every channel appends it before streaming). null = the mark is gone (history was rewritten).
+ */
+export function unseenMessages(conv: ConvMessage[], markId: string | undefined): ConvMessage[] | null {
+  if (!markId) return null;
+  const idx = conv.findLastIndex((m) => m.id === markId);
+  if (idx < 0) return null;
+  const after = conv.slice(idx + 1);
+  if (after[0]?.role === 'assistant') after.shift();
+  if (after.at(-1)?.role === 'user') after.pop();
+  return after;
+}
+
+export interface TurnDecisionInput {
+  enabled: boolean;
+  state?: ClaudeResumeState;
+  conversation: ConvMessage[];
+  configDirHash: string;
+  speaker: string;
+  /** A CLI process from an earlier run on this session is still alive (e.g. the run a steer took over). */
+  cliAlive?: boolean;
+  conversationReset?: boolean;
+  hasTranscript: (claudeSessionId: string) => boolean;
+}
+
+export function decideClaudeTurn(i: TurnDecisionInput): { path: TurnPath; unseen: ConvMessage[] } {
+  const fallback = (reason: string) => ({ path: `fallback:${reason}` as TurnPath, unseen: [] });
+  if (!i.enabled) return { path: 'fresh', unseen: [] };
+  const s = i.state;
+  if (!s?.claudeSessionId) return fallback('no-session');
+  // Two CLI processes appending to one transcript can interleave it; the takeover turn starts its own.
+  if (i.cliAlive) return fallback('concurrent-run');
+  if (s.speaker !== i.speaker) return fallback('speaker-change');
+  if (s.interruptedBy) return fallback('engine-switch');
+  if (s.configDirHash !== i.configDirHash) return fallback('account-change');
+  if (i.conversationReset) return fallback('reset');
+  if (s.summaryKey !== conversationSummaryKey(i.conversation)) return fallback('summary');
+  const unseen = unseenMessages(i.conversation, s.markId);
+  if (!unseen) return fallback('history-diverged');
+  if (unseen.reduce((n, m) => n + (renderConvMessage(m)?.length ?? 0), 0) > MAX_UNSEEN_CHARS) return fallback('drift');
+  // Checked last (filesystem): the CLI's periodic cleanup (cleanupPeriodDays) or a moved config dir
+  // deletes transcripts under sessions we still hold — catch it before spawning a doomed resume.
+  if (!i.hasTranscript(s.claudeSessionId)) return fallback('transcript-missing');
+  return { path: 'resume', unseen };
+}
+
+export function sectionHashes(sections: Record<string, string>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(sections)) if (v) out[k] = shortHash(v);
+  return out;
+}
+
+/** Re-sent on every resume turn regardless of hashes: who is speaking (identity + role) must never depend on
+ *  bookkeeping about what an earlier, possibly cancelled, turn managed to deliver. Small. */
+export const ALWAYS_SENT_SECTIONS = ['user'];
+
+/** Hash marking a section whose delivery is unknown — never equals a real hash, so the next turn re-sends it. */
+const UNKNOWN = '?';
+
+/**
+ * Section hashes to store the moment a resume prompt is SUBMITTED. The CLI writes the prompt to the
+ * transcript before any output, so a turn cancelled early may or may not have delivered its delta. Unchanged
+ * sections are known either way; changed, new and removed ones are marked unknown and re-sent next turn.
+ */
+export function sectionsAfterSubmit(prev: Record<string, string>, next: Record<string, string>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const k of new Set([...Object.keys(prev), ...Object.keys(next)])) out[k] = prev[k] === next[k] ? prev[k] : UNKNOWN;
+  return out;
+}
+
+/** The context sections that changed since CC last saw them (new or edited) plus ALWAYS_SENT_SECTIONS, and a
+ *  note for sections that no longer apply. '' when there is nothing to send. */
+export function buildContextDelta(prev: Record<string, string>, sections: Record<string, string>): string {
+  const changed = Object.entries(sections).filter(([k, v]) => v && (ALWAYS_SENT_SECTIONS.includes(k) || prev[k] !== shortHash(v)));
+  const removed = Object.keys(prev).filter((k) => !sections[k]);
+  if (!changed.length && !removed.length) return '';
+  return [
+    '<context_update>',
+    'Current context for this turn. Each section below replaces its earlier version.',
+    ...changed.map(([k, v]) => `<section name="${k}">\n${v}\n</section>`),
+    ...(removed.length ? [`No longer applicable: ${removed.join(', ')}`] : []),
+    '</context_update>',
+  ].join('\n');
+}
+
+export function buildResumePrompt(prompt: string, unseen: ConvMessage[], delta: string): string {
+  const lines = unseen.map(renderConvMessage).filter(Boolean);
+  const unseenBlock = lines.length
+    ? `<messages_since_last_turn>\nAdded to this conversation since your last reply (other participants, channel context, notices):\n${lines.join('\n\n')}\n</messages_since_last_turn>`
+    : '';
+  return [prompt, unseenBlock, delta].filter(Boolean).join('\n\n');
+}

package/src/server/engine/types.ts

@@ -11,6 +11,9 @@ export interface EngineStreamOpts {
   conversation: ConvMessage[];
   /** Contextual blocks to prepend (user block, skills, workspace tree, etc.) */
   contextBlock: string;
+  /** The same context split into named sections (in contextBlock order), so an engine that keeps
+   *  state across turns can send only what changed. Joined with '\n' they equal contextBlock. */
+  contextSections?: Record<string, string>;
 
   attachments?: AttachmentMeta[];
   images?: string[];

package/src/server/integrity-audit.ts

@@ -3,14 +3,21 @@
  * Detects: missing files, truncated content, degraded JSON arrays/objects, invalid JSON.
  *
  * CLI:    bun run src/server/integrity-audit.ts [git-ref] [data-dir]
- * API:    import { audit } from './integrity-audit.ts'
+ * API:    import { audit } from './integrity-audit.ts'   (async — never blocks the event loop)
  * Remote: run `bun run src/server/integrity-audit.ts` from $APP_DIR on the target host.
  *
  * When no ref is given, picks the most recent "auto: sync" commit as baseline.
  * Exit code 1 if issues found.
+ *
+ * Proportional by design: only files that DIFFER between ref and HEAD are examined (an unchanged
+ * file can't be missing, truncated or degraded, and its JSON validity was judged when it changed).
+ * Work is ≤3 git processes total — `diff --raw`, one `cat-file --batch-check` (byte sizes for the
+ * truncation check) and one `cat-file --batch` for changed .json only (≤16MB each) — regardless of
+ * repo size. Non-JSON blobs (media/binaries) are never loaded into memory.
+ * The old version ran `git show` via execSync for every tracked file (x2, plus every .json): on a
+ * 4.4k-file prod data repo that froze the server's event loop for ~5 min after every restart.
  */
 
-import { execSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { readdirSync } from 'node:fs';
 
@@ -18,26 +25,66 @@ import { readdirSync } from 'node:fs';
 // Guard (mirrors paths.ts): never silently fall back to bare ./data when named env dirs (data-*)
 // exist — that targets a stale, env-less data/ folder. An explicit [data-dir]/DATA_DIR overrides.
 function resolveDataDir(): string {
-  if (process.argv[3]) return process.argv[3];
   if (process.env.DATA_DIR) return process.env.DATA_DIR;
   const root = process.cwd();
   if (readdirSync(root).some((f) => f.startsWith('data-')))
     throw new Error('DATA_DIR not set but named data dirs exist (data-*). Pass [data-dir] or set DATA_DIR.');
   return resolve(root, 'data');
 }
-const DATA_DIR = resolveDataDir();
 
 const SIZE_RATIO = 0.5;
 const COUNT_SLACK = 2;
 const STRUCTURAL_JSON = ['schedules.json', 'contacts.json', 'skills-defaults.json', 'api-keys.json'];
+const MAX_JSON_BYTES = 16 * 1024 * 1024; // larger .json isn't read/parsed (bounds memory)
+const GITLINK = '160000';   // submodule entry — not a blob
+const ABSENT = '000000';    // side of an add/delete
+
+async function git(dir: string, args: string[], input?: string): Promise<Uint8Array> {
+  const proc = Bun.spawn(['git', '-C', dir, ...args], {
+    stdin: input === undefined ? 'ignore' : new Blob([input]),
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+  const [out, err] = await Promise.all([
+    new Response(proc.stdout).arrayBuffer(),
+    new Response(proc.stderr).text(),
+  ]);
+  const code = await proc.exited;
+  if (code !== 0) throw new Error(`git ${args[0]} failed (${code}): ${err.trim()}`);
+  return new Uint8Array(out);
+}
+
+// ignoreBOM keeps a leading BOM in the text, matching the old execSync decode (a BOM'd .json is invalid).
+const decoder = new TextDecoder('utf-8', { ignoreBOM: true });
 
-function git(cmd: string): string {
-  return execSync(`git -C "${DATA_DIR}" ${cmd}`, { encoding: 'utf-8' }).trim();
+/** Byte sizes of many objects through ONE `git cat-file --batch-check` (no content read). Missing omitted. */
+async function blobSizes(dir: string, shas: string[]): Promise<Map<string, number>> {
+  const sizes = new Map<string, number>();
+  if (!shas.length) return sizes;
+  for (const line of decoder.decode(await git(dir, ['cat-file', '--batch-check'], shas.join('\n') + '\n')).split('\n')) {
+    const [sha, type, size] = line.split(' ');
+    if (type && type !== 'missing' && size !== undefined) sizes.set(sha, Number(size));
+  }
+  return sizes;
 }
 
-function gitShow(ref: string, file: string): string | null {
-  try { return execSync(`git -C "${DATA_DIR}" show ${ref}:${file}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }); }
-  catch { return null; }
+/** Read many blobs through ONE `git cat-file --batch` process. Missing objects are omitted. */
+async function readBlobs(dir: string, shas: string[]): Promise<Map<string, string>> {
+  const blobs = new Map<string, string>();
+  if (!shas.length) return blobs;
+  const buf = await git(dir, ['cat-file', '--batch'], shas.join('\n') + '\n');
+  let pos = 0;
+  while (pos < buf.length) {
+    const nl = buf.indexOf(10, pos);
+    if (nl < 0) break;
+    const [sha, type, size] = decoder.decode(buf.subarray(pos, nl)).split(' ');
+    pos = nl + 1;
+    if (type === 'missing' || size === undefined) continue;
+    const n = Number(size);
+    blobs.set(sha, decoder.decode(buf.subarray(pos, pos + n)));
+    pos += n + 1; // content + trailing LF
+  }
+  return blobs;
 }
 
 function jsonEntryCount(text: string): number | null {
@@ -55,54 +102,77 @@ export interface Issue {
   detail: string;
 }
 
-export function audit(ref: string): Issue[] {
+export async function audit(ref: string, dataDir = resolveDataDir()): Promise<Issue[]> {
+  // `:oldmode newmode oldsha newsha status\0path\0` per changed path (renames split into D + A).
+  // --relative: scope to dataDir and report paths relative to it (dataDir may be a subfolder of the repo).
+  const tokens = decoder.decode(await git(dataDir, ['diff', '--raw', '-z', '--no-renames', '--no-abbrev', '--relative', ref, 'HEAD'])).split('\0');
+  const changes: { file: string; oldMode: string; newMode: string; oldSha: string; newSha: string }[] = [];
+  for (let i = 0; i + 1 < tokens.length; i += 2) {
+    const [oldMode, newMode, oldSha, newSha] = tokens[i].slice(1).split(' ');
+    changes.push({ file: tokens[i + 1], oldMode, newMode, oldSha, newSha });
+  }
+  const isBlob = (mode: string) => mode !== GITLINK && mode !== ABSENT;
+
+  // Sizes for every changed blob (cheap: headers only); content ONLY for small .json that needs parsing.
+  // Loading every changed blob (media/binaries) into memory spiked RSS by GBs on large syncs.
+  const sizes = await blobSizes(dataDir, [...new Set(changes.flatMap(c => [
+    ...(isBlob(c.oldMode) ? [c.oldSha] : []), ...(isBlob(c.newMode) ? [c.newSha] : []),
+  ]))]);
+  const wanted = new Set<string>();
+  const small = (sha: string) => (sizes.get(sha) ?? Infinity) <= MAX_JSON_BYTES;
+  const skipped = (file: string, sha: string) =>
+    console.warn(`[integrity-audit] skipped ${file}: ${sizes.get(sha)}B exceeds the ${MAX_JSON_BYTES}B JSON cap — not validated`);
+  for (const c of changes) {
+    if (!c.file.endsWith('.json') || !isBlob(c.newMode)) continue;
+    if (!small(c.newSha)) { skipped(c.file, c.newSha); continue; }
+    wanted.add(c.newSha);
+    if (!isBlob(c.oldMode) || !STRUCTURAL_JSON.includes(c.file)) continue;
+    if (small(c.oldSha)) wanted.add(c.oldSha);
+    else skipped(c.file, c.oldSha);
+  }
+  const blobs = await readBlobs(dataDir, [...wanted]);
+
   const issues: Issue[] = [];
-  const lsBlobs = (r: string) => git(`ls-tree -r ${r}`)
-    .split('\n').filter(Boolean)
-    .filter(l => !l.startsWith('160000 '))     // skip submodule gitlinks
-    .map(l => l.split('\t')[1]);
-  const refFiles = lsBlobs(ref);
-  const curSet = new Set(lsBlobs('HEAD'));
-
-  for (const f of refFiles) {
-    if (!curSet.has(f)) {
+  const jsonIssues: Issue[] = [];
+  for (const { file: f, oldMode, newMode, oldSha, newSha } of changes) {
+    if (isBlob(oldMode) && !isBlob(newMode)) {
       issues.push({ file: f, kind: 'missing', detail: 'in reference but not HEAD' });
       continue;
     }
-    const refContent = gitShow(ref, f);
-    const curContent = gitShow('HEAD', f);
-    if (!refContent || !curContent) continue;
-
-    // Size check
-    if (refContent.length > 200 && curContent.length < refContent.length * SIZE_RATIO) {
-      issues.push({ file: f, kind: 'truncated', detail: `${refContent.length}B → ${curContent.length}B (${Math.round(curContent.length / refContent.length * 100)}%)` });
+    const refSize = isBlob(oldMode) ? sizes.get(oldSha) : undefined;
+    const curSize = isBlob(newMode) ? sizes.get(newSha) : undefined;
+    const curContent = isBlob(newMode) ? blobs.get(newSha) : undefined;
+    const refContent = isBlob(oldMode) ? blobs.get(oldSha) : undefined;
+
+    // Size check (empty blobs are skipped, as before)
+    if (refSize && curSize && refSize > 200 && curSize < refSize * SIZE_RATIO) {
+      issues.push({ file: f, kind: 'truncated', detail: `${refSize}B → ${curSize}B (${Math.round(curSize / refSize * 100)}%)` });
     }
 
-    // Structural JSON check
-    if (STRUCTURAL_JSON.includes(f)) {
-      const refCount = jsonEntryCount(refContent);
-      const curCount = jsonEntryCount(curContent);
-      if (refCount !== null && curCount !== null && curCount < refCount - COUNT_SLACK) {
-        issues.push({ file: f, kind: 'degraded', detail: `${refCount} → ${curCount} entries` });
+    if (refContent && curContent) {
+      // Structural JSON check
+      if (STRUCTURAL_JSON.includes(f)) {
+        const refCount = jsonEntryCount(refContent);
+        const curCount = jsonEntryCount(curContent);
+        if (refCount !== null && curCount !== null && curCount < refCount - COUNT_SLACK) {
+          issues.push({ file: f, kind: 'degraded', detail: `${refCount} → ${curCount} entries` });
+        }
       }
     }
-  }
 
-  // Invalid JSON check on all current .json files
-  for (const f of curSet) {
-    if (!f.endsWith('.json')) continue;
-    const content = gitShow('HEAD', f);
-    if (!content) continue;
-    try { JSON.parse(content); }
-    catch { issues.push({ file: f, kind: 'invalid-json', detail: 'parse error' }); }
+    // Invalid JSON check on added/modified .json files
+    if (curContent && f.endsWith('.json')) {
+      try { JSON.parse(curContent); }
+      catch { jsonIssues.push({ file: f, kind: 'invalid-json', detail: 'parse error' }); }
+    }
   }
 
-  return issues;
+  return [...issues, ...jsonIssues];
 }
 
-export function findBaselineRef(): string {
+export async function findBaselineRef(dataDir = resolveDataDir()): Promise<string> {
   try {
-    const log = git('log --oneline -50 --format=%H\\ %s');
+    const log = decoder.decode(await git(dataDir, ['log', '-50', '--format=%H %s']));
     for (const line of log.split('\n')) {
       const [hash, ...rest] = line.split(' ');
       const msg = rest.join(' ');
@@ -115,10 +185,11 @@ export function findBaselineRef(): string {
 // ── CLI ────────────────────────────────────────────────────────────────────
 
 if (import.meta.main) {
-  const ref = process.argv[2] || findBaselineRef();
-  console.log(`data-audit: HEAD vs ${ref.slice(0, 8)} (${DATA_DIR})\n`);
+  const dataDir = process.argv[3] || resolveDataDir();
+  const ref = process.argv[2] || await findBaselineRef(dataDir);
+  console.log(`data-audit: HEAD vs ${ref.slice(0, 8)} (${dataDir})\n`);
 
-  const issues = audit(ref);
+  const issues = await audit(ref, dataDir);
   if (!issues.length) {
     console.log('✓ No issues found');
     process.exit(0);

package/src/server/sessions.ts

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { DATA_DIR, dataPath } from './paths.ts';
 import type { Directives } from './directives.ts';
 import type { ClaudeAccountRef } from './claude-account.ts';
+import { findClaudeTranscript, type ClaudeResumeState } from './engine/claude-resume.ts';
 
 const SESSIONS_PATH = dataPath('sessions.json');
 
@@ -45,6 +46,8 @@ export interface SessionMeta {
   /** Claude login the last turn ran on (claude-code engine, subscription auth only). `personal` = the
    *  requester's own routed login (claude-account.ts), false = the box's shared login. Never a token. */
   lastAccount?: ClaudeAccountRef;
+  /** claude-code engine SDK-resume mapping (opt-in flag) — see engine/claude-resume.ts. */
+  claudeResume?: ClaudeResumeState;
   forkedFrom?: string;
 }
 
@@ -383,6 +386,18 @@ export function setSessionModel(sessionId: string, model: string, engine?: strin
   }
 }
 
+/** Store (or clear, with undefined) the claude-code resume mapping. `patch` merges into the existing one. */
+export function setClaudeResume(sessionId: string, state: ClaudeResumeState | undefined, patch?: Partial<ClaudeResumeState>): void {
+  const sessions = loadIndex();
+  const s = sessions.find((x) => x.sessionId === sessionId);
+  if (!s) return;
+  if (patch) { if (!s.claudeResume) return; s.claudeResume = { ...s.claudeResume, ...patch }; }
+  else if (state) s.claudeResume = state;
+  else if (s.claudeResume) delete s.claudeResume;
+  else return;
+  saveIndex(sessions);
+}
+
 export function getSessionsByScheduleId(scheduleId: string): SessionMeta[] {
   return loadIndex()
     .filter((s) => s.scheduleId === scheduleId)
@@ -528,16 +543,8 @@ export function getSessionAbortController(sessionId: string): AbortController |
   return globalSessionLocks.get(sessionId)?.abortController;
 }
 
-const CLAUDE_PROJECTS_DIR = path.join(homedir(), '.claude', 'projects');
-
 function findSessionFile(sessionId: string): string | null {
-  if (!existsSync(CLAUDE_PROJECTS_DIR)) return null;
-  for (const dir of readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true })) {
-    if (!dir.isDirectory()) continue;
-    const file = path.join(CLAUDE_PROJECTS_DIR, dir.name, `${sessionId}.jsonl`);
-    if (existsSync(file)) return file;
-  }
-  return null;
+  return findClaudeTranscript(sessionId, path.join(homedir(), '.claude'));
 }
 
 // ── Our own conversation store ───────────────────────────────────────────────

package/src/server/shraga-config.ts

@@ -52,6 +52,9 @@ export interface AgentSettings {
   skillDiscovery?: boolean;
   thinking?: 'adaptive' | 'enabled' | 'disabled';
   effort?: 'low' | 'medium' | 'high' | 'max';
+  /** claude-code engine: resume the SDK session across turns instead of re-sending the history
+   *  (prompt-cache savings). Default off; a session's `[resume:on|off]` directive wins. */
+  sdkResume?: boolean;
 }
 
 export interface ShragaConfig {