@chatpanel/gateway 0.6.83 → 0.6.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.83",
+  "version": "0.6.85",
   "description": "Local privacy gateway \u2014 redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/server.js

@@ -58,7 +58,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.83';
+export const VERSION = '0.6.85';
 
 // WARM search tier — SQLite + FTS5 record store (falls back to an encrypted-JSON
 // store if SQLite can't load), fed by the extension's ingest sync + backup-ingest.
@@ -829,6 +829,9 @@ export function createGateway(cfg = loadConfig()) {
     //   POST /v1/teams/runs/:id/answer { threadId, text, by }  → { ok, run }  a person answers an ask (0.6.81)
     //   POST /v1/teams/runs/:id/decide { postId, status, by }  → { ok, run }  approve / reject a post
     //   POST /v1/teams/runs/:id/post { threadId, text, kind?, replyTo?, by } → { ok, run }
+    //   POST /v1/teams/runs/:id/handoff { taskId, model, by, reason } → { ok, run }  continue a task on another model (0.6.85)
+    //   GET  /v1/teams/runs/:id/checkpoint → { ok, checkpoint }  what resumeTeam needs, from the record
+    //   POST /v1/teams/runs/:id/claim { client } → { ok, run }  a client takes a stopped/stale run over
     //   POST /v1/teams/runs/:id/stop         → { ok, run }             a stop request any client may make
     //   DELETE /v1/teams/runs/:id            → { ok, removed }
     if (pathname === '/v1/teams/runs' && req.method === 'GET') {
@@ -843,7 +846,7 @@ export function createGateway(cfg = loadConfig()) {
       }
     }
     {
-      const m = /^\/v1\/teams\/runs\/([a-zA-Z0-9_-]{4,64})(\/events|\/stop|\/answer|\/decide|\/post)?$/.exec(pathname);
+      const m = /^\/v1\/teams\/runs\/([a-zA-Z0-9_-]{4,64})(\/events|\/stop|\/answer|\/decide|\/post|\/handoff|\/checkpoint|\/claim)?$/.exec(pathname);
       if (m) {
         const id = m[1];
         const sub = m[2] || '';
@@ -858,6 +861,20 @@ export function createGateway(cfg = loadConfig()) {
         }
         // The board, from a person on ANY client (0.6.81): answer an ask, decide on a post,
         // post a note. Each is appended as events, so the running client's tail sees it.
+        // A task's continuation from another client (0.6.85): hand a task to another model; read
+        // the checkpoint to resume a run whose client went away; claim it when resuming.
+        if (sub === '/checkpoint' && req.method === 'GET') {
+          try { return sendJson(res, 200, { ok: true, checkpoint: teamStore.checkpoint(id) }); } catch (e) { return sendJson(res, 404, { error: { message: `team run: ${e.message}`, type: 'team_error' } }); }
+        }
+        if ((sub === '/handoff' || sub === '/claim') && req.method === 'POST') {
+          try {
+            const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};
+            const run = sub === '/handoff' ? teamStore.handoff(id, { taskId: body.taskId, model: body.model, by: body.by, reason: body.reason }) : teamStore.claim(id, { client: body.client });
+            return sendJson(res, 200, { ok: true, run });
+          } catch (e) {
+            return sendJson(res, e.message.startsWith('no ') ? 404 : 400, { error: { message: `team run: ${e.message}`, type: 'team_error' } });
+          }
+        }
         if ((sub === '/answer' || sub === '/decide' || sub === '/post') && req.method === 'POST') {
           try {
             const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};

package/src/team-record.js

@@ -0,0 +1,103 @@
+// VENDORED from @chatpanel/events/team-record.js — edit there, then copy over.
+// The run record — a team run folded from its events, the same way on the gateway's store
+// and in either client. One fold, so what the desktop shows, what the extension shows and
+// what the store holds never disagree; and enough on the record to RESUME the run from
+// anywhere: the plan, every task's status and transcript, the board, the spend.
+//
+// The gateway vendors this file (its store used to carry a mirror of it, which is the copy
+// that drifts). `checkpointFrom(run)` is what a client hands `resumeTeam` after reading a
+// run the process that started it no longer runs.
+
+import { foldBoard, emptyBoardState } from './team-board.js';
+
+export const LIVE_RUN_STATUSES = Object.freeze(['planning', 'running', 'merging', 'waiting']);
+export const RESUMABLE_RUN_STATUSES = Object.freeze(['waiting', 'stopped', 'failed', 'partial', 'over-budget', 'answered']);
+const TASK_TEXT_MAX = 20_000;
+
+export function emptyRun({ id, client = '', now = Date.now() } = {}) {
+  return { id, client: String(client || '').slice(0, 40), createdAt: now, lastEventAt: now, status: 'planning', team: '', request: '', roles: [], plan: null, tasks: [], board: [], threads: emptyBoardState(), checkpoint: null, proposal: null, usage: null, stopRequested: null, startedAt: null, endedAt: null };
+}
+
+const taskOf = (run, id) => run.tasks.find((x) => x.id === id);
+
+/** Fold one event (`{ type, at, payload }`, or a flat `{ type, at, ...payload }`) into the record. */
+export function foldRun(run, ev) {
+  const type = String(ev?.type || '');
+  const p = ev?.payload && typeof ev.payload === 'object' ? ev.payload : (ev || {});
+  const at = Number(ev?.at) || Date.now();
+  run.lastEventAt = at;
+  switch (type) {
+    case 'run.started':
+    case 'run.resumed':
+      run.team = p.team || run.team; run.request = p.request ?? run.request; run.budget = p.budget || run.budget;
+      run.roles = Array.isArray(p.roles) ? p.roles : run.roles; run.status = 'planning'; run.startedAt = run.startedAt || at;
+      if (type === 'run.resumed') { run.endedAt = null; run.checkpoint = null; run.resumedAt = at; }
+      break;
+    case 'plan.ready':
+      run.plan = { by: p.by || 'fixed', tasks: Array.isArray(p.tasks) ? p.tasks : [] };
+      // A resume replays the plan: keep what the tasks already hold (transcripts, attempts).
+      run.tasks = run.plan.tasks.map((t) => ({ ...(taskOf(run, t.id) || {}), id: t.id, role: t.role, title: t.title, status: taskOf(run, t.id)?.status === 'ok' ? 'ok' : 'pending', findings: taskOf(run, t.id)?.findings || 0 }));
+      run.status = 'running';
+      break;
+    case 'task.started': { const t = taskOf(run, p.taskId); if (t) { t.status = 'running'; t.startedAt = at; t.error = null; } run.status = 'running'; break; }
+    case 'task.model': { const t = taskOf(run, p.taskId); if (t) { t.model = p.model; t.attempts = [...(t.attempts || []), { model: p.model, at, attempt: p.attempt }]; } break; }
+    case 'task.step': { const t = taskOf(run, p.taskId); if (t && Array.isArray(p.steps)) t.transcript = [...(t.transcript || []), ...p.steps]; break; }
+    case 'task.handoff': { const t = taskOf(run, p.taskId); if (t) { t.model = p.to; t.handoffs = [...(t.handoffs || []), { from: p.from, to: p.to, by: p.by, reason: p.reason, at }]; } break; }
+    case 'task.tool': { const t = taskOf(run, p.taskId); if (t) t.tools = (t.tools || 0) + 1; break; }
+    case 'task.delta': { const t = taskOf(run, p.taskId); if (t) t.text = String(p.text || '').slice(0, TASK_TEXT_MAX); break; }
+    case 'task.finding':
+      if (p.finding && p.finding.text) { run.board.push({ ...p.finding, at }); const t = taskOf(run, p.taskId); if (t) t.findings += 1; }
+      break;
+    case 'task.waiting': { const t = taskOf(run, p.taskId); if (t) { t.status = 'waiting'; t.waitingOn = p.threadId; } break; }
+    case 'task.done':
+    case 'task.failed': { const t = taskOf(run, p.taskId); if (t) { t.status = p.status || (type === 'task.done' ? 'ok' : 'failed'); t.error = p.error || null; t.ms = p.ms; t.endedAt = at; } break; }
+    case 'run.merging': run.status = 'merging'; break;
+    case 'run.waiting': run.status = 'running'; break;
+    case 'run.usage': run.usage = p.usage || run.usage; break;
+    case 'run.done':
+      run.status = p.status || 'completed'; run.usage = p.usage || run.usage; run.proposal = p.proposal ?? run.proposal; run.endedAt = at;
+      if (p.checkpoint) run.checkpoint = p.checkpoint;
+      break;
+    case 'run.stop-requested': run.stopRequested = at; break;
+    case 'board.thread': case 'board.post': case 'board.decision': case 'board.thread-status':
+      run.threads = foldBoard(run.threads || emptyBoardState(), ev);
+      if (type === 'board.thread-status' && p.status !== 'waiting' && run.status === 'waiting' && !(run.threads.threads || []).some((t) => t.kind === 'ask' && t.status === 'waiting')) run.status = 'answered';
+      break;
+    default: break;
+  }
+  return run;
+}
+
+/** Fold a whole event list into a fresh record. */
+export function runFromEvents(id, events, opts = {}) {
+  const run = emptyRun({ id, ...opts });
+  for (const ev of events || []) foldRun(run, ev);
+  return run;
+}
+
+/**
+ * What `resumeTeam` needs, from the record alone — the runner's own checkpoint when the run
+ * ended with one, else one built from the folded tasks: whatever the process that ran it
+ * managed to write before it went. A task recorded `running` (its process died) resumes
+ * from its transcript like a waiting one.
+ */
+export function checkpointFrom(run) {
+  if (!run?.plan?.tasks?.length) return null;
+  if (run.checkpoint?.plan?.tasks?.length) return { ...run.checkpoint, board: run.threads && run.threads.threads?.length >= (run.checkpoint.board?.threads?.length || 0) ? run.threads : run.checkpoint.board };
+  return {
+    runId: run.id,
+    startedAt: run.startedAt || run.createdAt,
+    plan: run.plan,
+    tasks: run.tasks.map((t) => ({ id: t.id, role: t.role, title: t.title, status: t.status === 'running' || t.status === 'pending' ? 'stopped' : t.status, text: t.text || '', error: t.error || null, transcript: t.transcript || [], attempts: t.attempts || [], usage: null })),
+    board: run.threads || emptyBoardState(),
+    budget: { cap: run.usage?.cap || run.budget || {}, spent: run.usage?.spent || {} },
+    budgetAsked: false,
+  };
+}
+
+/** Can this record be picked up again? Not one that completed, not one still being run by a live client. */
+export function isResumable(run) {
+  if (!run?.plan?.tasks?.length) return false;
+  if (RESUMABLE_RUN_STATUSES.includes(run.status)) return true;
+  return !!run.stale && LIVE_RUN_STATUSES.includes(run.status); // its client went away mid-run
+}

package/src/team-store.js

@@ -20,7 +20,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from '
 import { join, dirname } from 'node:path';
 import os from 'node:os';
 import { randomBytes, createCipheriv, createDecipheriv } from 'node:crypto';
-import { foldBoard, emptyBoardState } from './team-board.js';
+import { emptyBoardState } from './team-board.js';
+import { foldRun, emptyRun, checkpointFrom, isResumable, LIVE_RUN_STATUSES } from './team-record.js';
 
 const DIR = join(os.homedir(), '.chatpanel');
 const STORE_PATH = process.env.CHATPANEL_TEAMS_STORE || join(DIR, 'team-runs.enc');
@@ -31,7 +32,7 @@ export const MAX_EVENTS_PER_RUN = 2000;
 export const MAX_EVENT_BYTES = 64 * 1024;
 export const STALE_AFTER_MS = 5 * 60_000;
 const RUN_ID_RE = /^[a-zA-Z0-9_-]{4,64}$/;
-const LIVE = new Set(['planning', 'running', 'merging']);
+const LIVE = new Set(LIVE_RUN_STATUSES);
 
 function loadOrCreateKey() {
   try { if (existsSync(KEY_PATH)) return Buffer.from(readFileSync(KEY_PATH, 'utf8').trim(), 'base64'); } catch { /* regenerate */ }
@@ -53,50 +54,8 @@ function decrypt(key, env) {
 }
 const clone = (v) => (v === undefined ? undefined : JSON.parse(JSON.stringify(v)));
 
-/** Apply one event to a run record. The record is the fold of its events. */
-export function applyEvent(run, ev) {
-  const type = String(ev?.type || '');
-  const p = ev?.payload && typeof ev.payload === 'object' ? ev.payload : {};
-  run.lastEventAt = ev.at;
-  switch (type) {
-    case 'run.started':
-      run.team = p.team || run.team; run.request = p.request ?? run.request; run.budget = p.budget || run.budget;
-      run.roles = Array.isArray(p.roles) ? p.roles : run.roles; run.status = 'planning'; run.startedAt = run.startedAt || ev.at;
-      break;
-    case 'plan.ready':
-      run.plan = { by: p.by || 'fixed', tasks: Array.isArray(p.tasks) ? p.tasks : [] };
-      run.tasks = run.plan.tasks.map((t) => ({ id: t.id, role: t.role, title: t.title, status: 'pending', findings: 0 }));
-      run.status = 'running';
-      break;
-    case 'task.started': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) { t.status = 'running'; t.startedAt = ev.at; } run.status = 'running'; break; }
-    case 'task.delta': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.text = String(p.text || '').slice(0, 20_000); break; }
-    case 'task.finding':
-      if (p.finding && p.finding.text) { run.board.push({ ...p.finding, at: ev.at }); const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.findings += 1; }
-      break;
-    case 'task.done':
-    case 'task.failed': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) { t.status = p.status || (type === 'task.done' ? 'ok' : 'failed'); t.error = p.error || null; t.ms = p.ms; } break; }
-    case 'run.merging': run.status = 'merging'; break;
-    case 'run.done':
-      run.status = p.status || 'completed'; run.usage = p.usage || run.usage; run.proposal = p.proposal ?? run.proposal; run.endedAt = ev.at;
-      break;
-    case 'run.stop-requested': run.stopRequested = ev.at; break;
-    // The board as a message board (events 0.81): threads, posts, replies, decisions, asks.
-    // Folded by the shared fold, so this record and both clients agree on it.
-    case 'board.thread': case 'board.post': case 'board.decision': case 'board.thread-status':
-      run.threads = foldBoard(run.threads || emptyBoardState(), ev);
-      if (type === 'board.thread-status' && p.status !== 'waiting' && run.status === 'waiting' && !(run.threads.threads || []).some((t) => t.kind === 'ask' && t.status === 'waiting')) run.status = 'answered';
-      break;
-    case 'task.waiting': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) { t.status = 'waiting'; t.waitingOn = p.threadId; } break; }
-    case 'task.model': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.model = p.model; break; }
-    case 'task.tool': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.tools = (t.tools || 0) + 1; break; }
-    case 'run.usage': run.usage = p.usage || run.usage; break;
-    case 'run.waiting': run.status = 'running'; break;
-    case 'run.resumed': run.status = 'running'; run.endedAt = null; run.checkpoint = null; break;
-    default: break;
-  }
-  if (type === 'run.done' && p.checkpoint) run.checkpoint = p.checkpoint;
-  return run;
-}
+/** Apply one event to a run record — the shared fold (team-record.js, vendored from @chatpanel/events). */
+export function applyEvent(run, ev) { return foldRun(run, ev); }
 
 export class TeamStore {
   constructor({ storePath = STORE_PATH, now = () => Date.now(), staleAfterMs = STALE_AFTER_MS } = {}) {
@@ -126,7 +85,7 @@ export class TeamStore {
     renameSync(tmp, this.path);
   }
   _fresh(id, { client = '' } = {}) {
-    return { id, client: String(client || '').slice(0, 40), createdAt: this.now(), lastEventAt: this.now(), status: 'planning', team: '', request: '', roles: [], plan: null, tasks: [], board: [], threads: emptyBoardState(), checkpoint: null, proposal: null, usage: null, stopRequested: null, events: [] };
+    return { ...emptyRun({ id, client, now: this.now() }), events: [] };
   }
   _evict() {
     if (this.runs.size <= MAX_RUNS) return;
@@ -138,6 +97,8 @@ export class TeamStore {
     const v = clone({ ...run, events: undefined });
     delete v.events;
     v.stale = LIVE.has(run.status) && this.now() - run.lastEventAt > this.staleAfterMs;
+    // Can a client pick this run up again? Not while its own client is live on it.
+    v.resumable = isResumable(v);
     if (events) v.events = clone(run.events);
     return v;
   }
@@ -179,7 +140,7 @@ export class TeamStore {
       .filter((r) => !team || r.team === team)
       .sort((a, b) => b.createdAt - a.createdAt)
       .slice(0, Math.max(1, Math.min(200, Number(limit) || 50)))
-      .map((r) => { const v = this._view(r); return { ...v, board: undefined, threads: undefined, checkpoint: undefined, tasks: v.tasks.map((t) => ({ ...t, text: undefined })), findings: r.board.length, waiting: (r.threads?.threads || []).filter((t) => t.kind === 'ask' && t.status === 'waiting').length }; });
+      .map((r) => { const v = this._view(r); return { ...v, board: undefined, threads: undefined, checkpoint: undefined, tasks: v.tasks.map((t) => ({ ...t, text: undefined, transcript: undefined })), findings: r.board.length, waiting: (r.threads?.threads || []).filter((t) => t.kind === 'ask' && t.status === 'waiting').length }; });
   }
   /** Ask the running client to stop. Recorded as an event, so watchers (the runner) see it. */
   /**
@@ -216,6 +177,29 @@ export class TeamStore {
     const post = { id: `pp_${randomBytes(4).toString('hex')}`, threadId, by: String(by || 'person').slice(0, 40), kind: ['note', 'question', 'decision'].includes(kind) ? kind : 'note', text: String(text || '').slice(0, 4000), refs: [], replyTo: replyTo || null, status: 'open', at };
     return this.append(id, [{ type: 'board.post', at, post }]);
   }
+  /** The checkpoint a client resumes from — the runner's own when the run ended with one, else built from the record. */
+  checkpoint(id) {
+    const run = this.runs.get(String(id || ''));
+    if (!run) throw new Error(`no run ${id}`);
+    return checkpointFrom(this._view(run));
+  }
+  /** A person hands a task to another model, from any client: the running client's tail acts on it. */
+  handoff(id, { taskId, model, by = 'person', reason = '' } = {}) {
+    const run = this.runs.get(String(id || ''));
+    if (!run) throw new Error(`no run ${id}`);
+    if (!run.tasks.some((t) => t.id === taskId)) throw new Error(`no task ${taskId}`);
+    if (!model) throw new Error('a model is required');
+    return this.append(id, [{ type: 'task.handoff-requested', at: this.now(), taskId, model: String(model).slice(0, 120), by: String(by || 'person').slice(0, 40), reason: String(reason || '').slice(0, 400) }]);
+  }
+  /** A client is taking a run over (resume): the record says so, and the old client's stop no longer applies. */
+  claim(id, { client = '' } = {}) {
+    const run = this.runs.get(String(id || ''));
+    if (!run) throw new Error(`no run ${id}`);
+    run.client = String(client || run.client || '').slice(0, 40);
+    run.stopRequested = null;
+    this.save();
+    return this._view(run);
+  }
   stop(id) {
     const run = this.runs.get(String(id || ''));
     if (!run) return null;

package/src/toolrelay.js

@@ -40,7 +40,7 @@ export function toolsToSpecs(tools) {
 // not time since the turn began: a flat 135 s from the start killed every relayed turn
 // with more than a handful of tool rounds, at 135.1 s exactly, and the client read the
 // empty resume as "the model returned no answer". A team member's turn is many rounds.
-export const RELAY_IDLE_MS = 135_000; // the bridge's own tool-call timeout is 120 s
+export const RELAY_IDLE_MS = 200_000; // longer than the bridge's own idle (180 s), which is the authority
 
 export function createRelaySession({ vault, redactOpts, bridgeUrl, token, harness = null, idleMs = RELAY_IDLE_MS }) {
   const id = randomUUID().slice(0, 8);
@@ -81,6 +81,10 @@ export async function pumpBridgeStream(s, handlers) {
         const payload = t.slice(5).trim();
         if (!payload || payload === '[DONE]') continue;
         let evt; try { evt = JSON.parse(payload); } catch { continue; }
+        // Anything the bridge sends is life: an agent running its own tools for two minutes
+        // sends only status events, and a session that counts only text and tool requests
+        // as activity ended those turns mid-work.
+        touchRelaySession(s.id);
         if (evt.type === 'delta' && typeof evt.text === 'string') {
           handlers.onText(evt.text);
         } else if (evt.type === 'tool_request') {