sphica 0.6.0 → 0.6.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "sphica",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/dist/capture.js

@@ -11801,6 +11801,8 @@ function lock() {
   return null;
 }
 var BATCH = 500;
+var FLUSH_BUDGET_MS = 30000;
+var TOOL_FLUSH_BUDGET_MS = 2000;
 var ROWS = 1000;
 var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
 async function write(db, batch, projects) {
@@ -11876,98 +11878,135 @@ async function write(db, batch, projects) {
 }
 var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
-async function flush(file = dbFile()) {
-  const unlock = lock();
-  if (!unlock)
-    return { sent: 0, deferred: 0, rejected: 0, busy: true };
-  const dir = spoolDir();
-  let client = null;
+var queued = (from) => {
+  try {
+    return fs4.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+  } catch {
+    return [];
+  }
+};
+async function sendBatch(db, names) {
+  const held = unregisteredDir();
+  const records = [];
+  for (const { name, from } of names) {
+    let r;
+    try {
+      r = current(JSON.parse(fs4.readFileSync(path5.join(from, name), "utf8")));
+    } catch {
+      fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs4.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
+      continue;
+    }
+    if (r)
+      records.push({ name, from, r });
+    else
+      fs4.rmSync(path5.join(from, name), { force: true });
+  }
+  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
+  const known = records.filter((x) => projects.has(x.r.project));
+  const strayed = records.filter((x) => !projects.has(x.r.project));
+  let sent = 0;
+  const bad = [];
   try {
-    const held = unregisteredDir();
-    const list = (from) => {
+    sent = await write(db, known.map((x) => x.r), projects);
+  } catch (e) {
+    if (!rejected(e))
+      throw e;
+    for (const x of known) {
       try {
-        return fs4.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
-      } catch {
-        return [];
+        sent += await write(db, [x.r], projects);
+      } catch (e2) {
+        if (!rejected(e2))
+          throw e2;
+        bad.push(x);
       }
-    };
-    const names = [...list(dir), ...list(held)].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).slice(0, BATCH);
-    if (names.length === 0)
-      return { sent: 0, deferred: 0, rejected: 0 };
-    const records = [];
-    for (const { name, from } of names) {
-      let r;
+    }
+  }
+  if (bad.length) {
+    fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    for (const x of bad) {
       try {
-        r = current(JSON.parse(fs4.readFileSync(path5.join(from, name), "utf8")));
-      } catch {
-        fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-        fs4.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
-        continue;
-      }
-      if (r)
-        records.push({ name, from, r });
-      else
-        fs4.rmSync(path5.join(from, name), { force: true });
-    }
-    const db = openWriter("capture", file);
-    client = db;
-    const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-    const known = records.filter((x) => projects.has(x.r.project));
-    const strayed = records.filter((x) => !projects.has(x.r.project));
-    let sent = 0;
-    const bad = [];
-    try {
-      sent = await write(db, known.map((x) => x.r), projects);
-    } catch (e) {
-      if (!rejected(e))
-        throw e;
-      for (const x of known) {
-        try {
-          sent += await write(db, [x.r], projects);
-        } catch (e2) {
-          if (!rejected(e2))
-            throw e2;
-          bad.push(x);
-        }
+        fs4.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (bad.length) {
-      fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      for (const x of bad) {
-        try {
-          fs4.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
-        }
+  }
+  if (strayed.length) {
+    fs4.mkdirSync(held, { recursive: true, mode: 448 });
+    for (const x of strayed) {
+      if (x.from === held)
+        continue;
+      try {
+        fs4.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (strayed.length) {
-      fs4.mkdirSync(held, { recursive: true, mode: 448 });
-      for (const x of strayed) {
-        if (x.from === held)
-          continue;
-        try {
-          fs4.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
+  }
+  const moved = new Set([...bad, ...strayed].map((x) => x.name));
+  for (const x of records)
+    if (!moved.has(x.name))
+      fs4.rmSync(path5.join(x.from, x.name), { force: true });
+  return { sent, rejected: bad.length };
+}
+async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
+  const deadline = Date.now() + budgetMs;
+  const dir = spoolDir();
+  const held = unregisteredDir();
+  const total = { sent: 0, deferred: 0, rejected: 0 };
+  let batches = 0;
+  let queueBatches = 0;
+  for (let first = true;; first = false) {
+    let unlock = lock();
+    while (!unlock && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
+      if (Date.now() < deadline)
+        unlock = lock();
+    }
+    if (!unlock)
+      return first ? { ...total, busy: true } : total;
+    let client = null;
+    const send = async (names) => {
+      client ??= openWriter("capture", file);
+      const r = await sendBatch(client, names);
+      total.sent += r.sent;
+      total.rejected += r.rejected;
+      batches++;
+    };
+    const late = () => batches > 0 && Date.now() >= deadline;
+    const sentBefore = batches;
+    try {
+      if (first) {
+        prune(held);
+        for (const part of chunks(queued(held), BATCH)) {
+          if (late())
+            break;
+          await send(part);
         }
       }
+      while (queueBatches === 0 || !late()) {
+        const part = queued(dir).slice(0, BATCH);
+        if (part.length === 0)
+          break;
+        await send(part);
+        queueBatches++;
+      }
+      prune(held);
+      total.deferred = queued(held).length;
+      if (batches > sentBefore)
+        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+    } catch (e) {
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      throw e;
+    } finally {
+      await client?.destroy().catch(() => {});
+      unlock();
     }
-    const moved = new Set([...bad, ...strayed].map((x) => x.name));
-    for (const x of records)
-      if (!moved.has(x.name))
-        fs4.rmSync(path5.join(x.from, x.name), { force: true });
-    prune(held);
-    writeState({ flushedAt: new Date().toISOString(), error: null, deferred: strayed.length });
-    return { sent, deferred: strayed.length, rejected: bad.length };
-  } catch (e) {
-    writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
-    throw e;
-  } finally {
-    await client?.destroy().catch(() => {});
-    unlock();
+    if (Date.now() >= deadline || queued(dir).length === 0)
+      return total;
   }
 }
 async function readInput(stream) {
@@ -11997,6 +12036,7 @@ if (process.argv[1] && /capture\.(ts|js)$/.test(process.argv[1])) {
 }
 export {
   MAX_MESSAGE,
+  TOOL_FLUSH_BUDGET_MS,
   answersOf,
   branchOf,
   captureNotice,

package/dist/cli.js

@@ -15132,6 +15132,7 @@ function lock() {
   return null;
 }
 var BATCH = 500;
+var FLUSH_BUDGET_MS = 30000;
 var ROWS = 1000;
 var chunks = (xs, n2 = ROWS) => Array.from({ length: Math.ceil(xs.length / n2) }, (_, i2) => xs.slice(i2 * n2, (i2 + 1) * n2));
 async function write(db, batch, projects) {
@@ -15207,98 +15208,135 @@ async function write(db, batch, projects) {
 }
 var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
-async function flush(file = dbFile()) {
-  const unlock = lock();
-  if (!unlock)
-    return { sent: 0, deferred: 0, rejected: 0, busy: true };
-  const dir = spoolDir();
-  let client = null;
+var queued = (from) => {
+  try {
+    return fs6.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+  } catch {
+    return [];
+  }
+};
+async function sendBatch(db, names) {
+  const held = unregisteredDir();
+  const records = [];
+  for (const { name, from } of names) {
+    let r2;
+    try {
+      r2 = current(JSON.parse(fs6.readFileSync(path7.join(from, name), "utf8")));
+    } catch {
+      fs6.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs6.renameSync(path7.join(from, name), path7.join(rejectedDir(), name));
+      continue;
+    }
+    if (r2)
+      records.push({ name, from, r: r2 });
+    else
+      fs6.rmSync(path7.join(from, name), { force: true });
+  }
+  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
+  const known = records.filter((x) => projects.has(x.r.project));
+  const strayed = records.filter((x) => !projects.has(x.r.project));
+  let sent = 0;
+  const bad = [];
   try {
-    const held = unregisteredDir();
-    const list = (from) => {
+    sent = await write(db, known.map((x) => x.r), projects);
+  } catch (e) {
+    if (!rejected(e))
+      throw e;
+    for (const x of known) {
       try {
-        return fs6.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
-      } catch {
-        return [];
+        sent += await write(db, [x.r], projects);
+      } catch (e2) {
+        if (!rejected(e2))
+          throw e2;
+        bad.push(x);
       }
-    };
-    const names = [...list(dir), ...list(held)].sort((a2, b) => a2.name < b.name ? -1 : a2.name > b.name ? 1 : 0).slice(0, BATCH);
-    if (names.length === 0)
-      return { sent: 0, deferred: 0, rejected: 0 };
-    const records = [];
-    for (const { name, from } of names) {
-      let r2;
+    }
+  }
+  if (bad.length) {
+    fs6.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    for (const x of bad) {
       try {
-        r2 = current(JSON.parse(fs6.readFileSync(path7.join(from, name), "utf8")));
-      } catch {
-        fs6.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-        fs6.renameSync(path7.join(from, name), path7.join(rejectedDir(), name));
-        continue;
-      }
-      if (r2)
-        records.push({ name, from, r: r2 });
-      else
-        fs6.rmSync(path7.join(from, name), { force: true });
-    }
-    const db = openWriter("capture", file);
-    client = db;
-    const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-    const known = records.filter((x) => projects.has(x.r.project));
-    const strayed = records.filter((x) => !projects.has(x.r.project));
-    let sent = 0;
-    const bad = [];
-    try {
-      sent = await write(db, known.map((x) => x.r), projects);
-    } catch (e) {
-      if (!rejected(e))
-        throw e;
-      for (const x of known) {
-        try {
-          sent += await write(db, [x.r], projects);
-        } catch (e2) {
-          if (!rejected(e2))
-            throw e2;
-          bad.push(x);
-        }
+        fs6.renameSync(path7.join(x.from, x.name), path7.join(rejectedDir(), x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (bad.length) {
-      fs6.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      for (const x of bad) {
-        try {
-          fs6.renameSync(path7.join(x.from, x.name), path7.join(rejectedDir(), x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
-        }
+  }
+  if (strayed.length) {
+    fs6.mkdirSync(held, { recursive: true, mode: 448 });
+    for (const x of strayed) {
+      if (x.from === held)
+        continue;
+      try {
+        fs6.renameSync(path7.join(x.from, x.name), path7.join(held, x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (strayed.length) {
-      fs6.mkdirSync(held, { recursive: true, mode: 448 });
-      for (const x of strayed) {
-        if (x.from === held)
-          continue;
-        try {
-          fs6.renameSync(path7.join(x.from, x.name), path7.join(held, x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
+  }
+  const moved = new Set([...bad, ...strayed].map((x) => x.name));
+  for (const x of records)
+    if (!moved.has(x.name))
+      fs6.rmSync(path7.join(x.from, x.name), { force: true });
+  return { sent, rejected: bad.length };
+}
+async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
+  const deadline = Date.now() + budgetMs;
+  const dir = spoolDir();
+  const held = unregisteredDir();
+  const total = { sent: 0, deferred: 0, rejected: 0 };
+  let batches = 0;
+  let queueBatches = 0;
+  for (let first = true;; first = false) {
+    let unlock = lock();
+    while (!unlock && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
+      if (Date.now() < deadline)
+        unlock = lock();
+    }
+    if (!unlock)
+      return first ? { ...total, busy: true } : total;
+    let client = null;
+    const send = async (names) => {
+      client ??= openWriter("capture", file);
+      const r2 = await sendBatch(client, names);
+      total.sent += r2.sent;
+      total.rejected += r2.rejected;
+      batches++;
+    };
+    const late = () => batches > 0 && Date.now() >= deadline;
+    const sentBefore = batches;
+    try {
+      if (first) {
+        prune(held);
+        for (const part of chunks(queued(held), BATCH)) {
+          if (late())
+            break;
+          await send(part);
         }
       }
+      while (queueBatches === 0 || !late()) {
+        const part = queued(dir).slice(0, BATCH);
+        if (part.length === 0)
+          break;
+        await send(part);
+        queueBatches++;
+      }
+      prune(held);
+      total.deferred = queued(held).length;
+      if (batches > sentBefore)
+        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+    } catch (e) {
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      throw e;
+    } finally {
+      await client?.destroy().catch(() => {});
+      unlock();
     }
-    const moved = new Set([...bad, ...strayed].map((x) => x.name));
-    for (const x of records)
-      if (!moved.has(x.name))
-        fs6.rmSync(path7.join(x.from, x.name), { force: true });
-    prune(held);
-    writeState({ flushedAt: new Date().toISOString(), error: null, deferred: strayed.length });
-    return { sent, deferred: strayed.length, rejected: bad.length };
-  } catch (e) {
-    writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
-    throw e;
-  } finally {
-    await client?.destroy().catch(() => {});
-    unlock();
+    if (Date.now() >= deadline || queued(dir).length === 0)
+      return total;
   }
 }
 async function readInput(stream) {

package/dist/deliver.js

@@ -11847,6 +11847,7 @@ function lock() {
   return null;
 }
 var BATCH = 500;
+var FLUSH_BUDGET_MS = 30000;
 var ROWS = 1000;
 var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
 async function write(db, batch, projects) {
@@ -11922,98 +11923,135 @@ async function write(db, batch, projects) {
 }
 var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
-async function flush(file = dbFile()) {
-  const unlock = lock();
-  if (!unlock)
-    return { sent: 0, deferred: 0, rejected: 0, busy: true };
-  const dir = spoolDir();
-  let client = null;
+var queued = (from) => {
+  try {
+    return fs4.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+  } catch {
+    return [];
+  }
+};
+async function sendBatch(db, names) {
+  const held = unregisteredDir();
+  const records = [];
+  for (const { name, from } of names) {
+    let r;
+    try {
+      r = current(JSON.parse(fs4.readFileSync(path5.join(from, name), "utf8")));
+    } catch {
+      fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs4.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
+      continue;
+    }
+    if (r)
+      records.push({ name, from, r });
+    else
+      fs4.rmSync(path5.join(from, name), { force: true });
+  }
+  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
+  const known = records.filter((x) => projects.has(x.r.project));
+  const strayed = records.filter((x) => !projects.has(x.r.project));
+  let sent = 0;
+  const bad = [];
   try {
-    const held = unregisteredDir();
-    const list = (from) => {
+    sent = await write(db, known.map((x) => x.r), projects);
+  } catch (e) {
+    if (!rejected(e))
+      throw e;
+    for (const x of known) {
       try {
-        return fs4.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
-      } catch {
-        return [];
+        sent += await write(db, [x.r], projects);
+      } catch (e2) {
+        if (!rejected(e2))
+          throw e2;
+        bad.push(x);
       }
-    };
-    const names = [...list(dir), ...list(held)].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).slice(0, BATCH);
-    if (names.length === 0)
-      return { sent: 0, deferred: 0, rejected: 0 };
-    const records = [];
-    for (const { name, from } of names) {
-      let r;
+    }
+  }
+  if (bad.length) {
+    fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    for (const x of bad) {
       try {
-        r = current(JSON.parse(fs4.readFileSync(path5.join(from, name), "utf8")));
-      } catch {
-        fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-        fs4.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
-        continue;
-      }
-      if (r)
-        records.push({ name, from, r });
-      else
-        fs4.rmSync(path5.join(from, name), { force: true });
-    }
-    const db = openWriter("capture", file);
-    client = db;
-    const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-    const known = records.filter((x) => projects.has(x.r.project));
-    const strayed = records.filter((x) => !projects.has(x.r.project));
-    let sent = 0;
-    const bad = [];
-    try {
-      sent = await write(db, known.map((x) => x.r), projects);
-    } catch (e) {
-      if (!rejected(e))
-        throw e;
-      for (const x of known) {
-        try {
-          sent += await write(db, [x.r], projects);
-        } catch (e2) {
-          if (!rejected(e2))
-            throw e2;
-          bad.push(x);
-        }
+        fs4.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (bad.length) {
-      fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      for (const x of bad) {
-        try {
-          fs4.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
-        }
+  }
+  if (strayed.length) {
+    fs4.mkdirSync(held, { recursive: true, mode: 448 });
+    for (const x of strayed) {
+      if (x.from === held)
+        continue;
+      try {
+        fs4.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (strayed.length) {
-      fs4.mkdirSync(held, { recursive: true, mode: 448 });
-      for (const x of strayed) {
-        if (x.from === held)
-          continue;
-        try {
-          fs4.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
+  }
+  const moved = new Set([...bad, ...strayed].map((x) => x.name));
+  for (const x of records)
+    if (!moved.has(x.name))
+      fs4.rmSync(path5.join(x.from, x.name), { force: true });
+  return { sent, rejected: bad.length };
+}
+async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
+  const deadline = Date.now() + budgetMs;
+  const dir = spoolDir();
+  const held = unregisteredDir();
+  const total = { sent: 0, deferred: 0, rejected: 0 };
+  let batches = 0;
+  let queueBatches = 0;
+  for (let first = true;; first = false) {
+    let unlock = lock();
+    while (!unlock && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
+      if (Date.now() < deadline)
+        unlock = lock();
+    }
+    if (!unlock)
+      return first ? { ...total, busy: true } : total;
+    let client = null;
+    const send = async (names) => {
+      client ??= openWriter("capture", file);
+      const r = await sendBatch(client, names);
+      total.sent += r.sent;
+      total.rejected += r.rejected;
+      batches++;
+    };
+    const late = () => batches > 0 && Date.now() >= deadline;
+    const sentBefore = batches;
+    try {
+      if (first) {
+        prune(held);
+        for (const part of chunks(queued(held), BATCH)) {
+          if (late())
+            break;
+          await send(part);
         }
       }
+      while (queueBatches === 0 || !late()) {
+        const part = queued(dir).slice(0, BATCH);
+        if (part.length === 0)
+          break;
+        await send(part);
+        queueBatches++;
+      }
+      prune(held);
+      total.deferred = queued(held).length;
+      if (batches > sentBefore)
+        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+    } catch (e) {
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      throw e;
+    } finally {
+      await client?.destroy().catch(() => {});
+      unlock();
     }
-    const moved = new Set([...bad, ...strayed].map((x) => x.name));
-    for (const x of records)
-      if (!moved.has(x.name))
-        fs4.rmSync(path5.join(x.from, x.name), { force: true });
-    prune(held);
-    writeState({ flushedAt: new Date().toISOString(), error: null, deferred: strayed.length });
-    return { sent, deferred: strayed.length, rejected: bad.length };
-  } catch (e) {
-    writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
-    throw e;
-  } finally {
-    await client?.destroy().catch(() => {});
-    unlock();
+    if (Date.now() >= deadline || queued(dir).length === 0)
+      return total;
   }
 }
 async function readInput(stream) {

package/dist/mcp-record.js

@@ -46683,6 +46683,8 @@ function lock() {
   return null;
 }
 var BATCH = 500;
+var FLUSH_BUDGET_MS = 30000;
+var TOOL_FLUSH_BUDGET_MS = 2000;
 var ROWS = 1000;
 var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
 async function write(db, batch, projects) {
@@ -46758,98 +46760,135 @@ async function write(db, batch, projects) {
 }
 var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
-async function flush(file2 = dbFile()) {
-  const unlock = lock();
-  if (!unlock)
-    return { sent: 0, deferred: 0, rejected: 0, busy: true };
-  const dir = spoolDir();
-  let client = null;
+var queued = (from) => {
   try {
-    const held = unregisteredDir();
-    const list = (from) => {
+    return fs5.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+  } catch {
+    return [];
+  }
+};
+async function sendBatch(db, names) {
+  const held = unregisteredDir();
+  const records = [];
+  for (const { name, from } of names) {
+    let r;
+    try {
+      r = current(JSON.parse(fs5.readFileSync(path5.join(from, name), "utf8")));
+    } catch {
+      fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs5.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
+      continue;
+    }
+    if (r)
+      records.push({ name, from, r });
+    else
+      fs5.rmSync(path5.join(from, name), { force: true });
+  }
+  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
+  const known = records.filter((x) => projects.has(x.r.project));
+  const strayed = records.filter((x) => !projects.has(x.r.project));
+  let sent = 0;
+  const bad = [];
+  try {
+    sent = await write(db, known.map((x) => x.r), projects);
+  } catch (e) {
+    if (!rejected(e))
+      throw e;
+    for (const x of known) {
       try {
-        return fs5.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
-      } catch {
-        return [];
+        sent += await write(db, [x.r], projects);
+      } catch (e2) {
+        if (!rejected(e2))
+          throw e2;
+        bad.push(x);
       }
-    };
-    const names = [...list(dir), ...list(held)].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).slice(0, BATCH);
-    if (names.length === 0)
-      return { sent: 0, deferred: 0, rejected: 0 };
-    const records = [];
-    for (const { name, from } of names) {
-      let r;
+    }
+  }
+  if (bad.length) {
+    fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    for (const x of bad) {
       try {
-        r = current(JSON.parse(fs5.readFileSync(path5.join(from, name), "utf8")));
-      } catch {
-        fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-        fs5.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
-        continue;
-      }
-      if (r)
-        records.push({ name, from, r });
-      else
-        fs5.rmSync(path5.join(from, name), { force: true });
-    }
-    const db = openWriter("capture", file2);
-    client = db;
-    const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-    const known = records.filter((x) => projects.has(x.r.project));
-    const strayed = records.filter((x) => !projects.has(x.r.project));
-    let sent = 0;
-    const bad = [];
-    try {
-      sent = await write(db, known.map((x) => x.r), projects);
-    } catch (e) {
-      if (!rejected(e))
-        throw e;
-      for (const x of known) {
-        try {
-          sent += await write(db, [x.r], projects);
-        } catch (e2) {
-          if (!rejected(e2))
-            throw e2;
-          bad.push(x);
-        }
+        fs5.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (bad.length) {
-      fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      for (const x of bad) {
-        try {
-          fs5.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
-        }
+  }
+  if (strayed.length) {
+    fs5.mkdirSync(held, { recursive: true, mode: 448 });
+    for (const x of strayed) {
+      if (x.from === held)
+        continue;
+      try {
+        fs5.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (strayed.length) {
-      fs5.mkdirSync(held, { recursive: true, mode: 448 });
-      for (const x of strayed) {
-        if (x.from === held)
-          continue;
-        try {
-          fs5.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
+  }
+  const moved = new Set([...bad, ...strayed].map((x) => x.name));
+  for (const x of records)
+    if (!moved.has(x.name))
+      fs5.rmSync(path5.join(x.from, x.name), { force: true });
+  return { sent, rejected: bad.length };
+}
+async function flush(file2 = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
+  const deadline = Date.now() + budgetMs;
+  const dir = spoolDir();
+  const held = unregisteredDir();
+  const total = { sent: 0, deferred: 0, rejected: 0 };
+  let batches = 0;
+  let queueBatches = 0;
+  for (let first = true;; first = false) {
+    let unlock = lock();
+    while (!unlock && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
+      if (Date.now() < deadline)
+        unlock = lock();
+    }
+    if (!unlock)
+      return first ? { ...total, busy: true } : total;
+    let client = null;
+    const send = async (names) => {
+      client ??= openWriter("capture", file2);
+      const r = await sendBatch(client, names);
+      total.sent += r.sent;
+      total.rejected += r.rejected;
+      batches++;
+    };
+    const late2 = () => batches > 0 && Date.now() >= deadline;
+    const sentBefore = batches;
+    try {
+      if (first) {
+        prune(held);
+        for (const part of chunks(queued(held), BATCH)) {
+          if (late2())
+            break;
+          await send(part);
         }
       }
+      while (queueBatches === 0 || !late2()) {
+        const part = queued(dir).slice(0, BATCH);
+        if (part.length === 0)
+          break;
+        await send(part);
+        queueBatches++;
+      }
+      prune(held);
+      total.deferred = queued(held).length;
+      if (batches > sentBefore)
+        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+    } catch (e) {
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      throw e;
+    } finally {
+      await client?.destroy().catch(() => {});
+      unlock();
     }
-    const moved = new Set([...bad, ...strayed].map((x) => x.name));
-    for (const x of records)
-      if (!moved.has(x.name))
-        fs5.rmSync(path5.join(x.from, x.name), { force: true });
-    prune(held);
-    writeState({ flushedAt: new Date().toISOString(), error: null, deferred: strayed.length });
-    return { sent, deferred: strayed.length, rejected: bad.length };
-  } catch (e) {
-    writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
-    throw e;
-  } finally {
-    await client?.destroy().catch(() => {});
-    unlock();
+    if (Date.now() >= deadline || queued(dir).length === 0)
+      return total;
   }
 }
 async function readInput(stream) {
@@ -48137,7 +48176,7 @@ async function liveUnits(db, projectId2, limit = 40) {
 // server/src/extract.ts
 var newRunId = () => crypto2.randomBytes(9).toString("base64url");
 async function pendingText(db, projectId2) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const rows = await pendingSessions(db, projectId2);
   if (!rows.length)
     return "Every captured session has been traced.";
@@ -48159,14 +48198,14 @@ async function sessionOf(db, projectId2, given) {
   return s.id;
 }
 async function beginTrace(db, projectId2, session) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const s = await sessionOf(db, projectId2, session);
   const run = newRunId();
   await openRun(db, { projectId: projectId2, origin: "trace", target: `session:${s}`, sessionId: s, draftId: run });
   return run;
 }
 async function beginGlean(db, projectId2, session) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const s = await sessionOf(db, projectId2, session);
   const run = newRunId();
   await openRun(db, { projectId: projectId2, origin: "glean", target: "glean", sessionId: s, draftId: run });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "license": "MIT",
   "type": "module",