@coreplane/switchboard 1.216.2 → 1.218.0

package/dist/assets/config/config.example.yaml

@@ -473,6 +473,12 @@ workspaceDir: ./workspaces
 #       auth: bearer
 #       tokenEnv: MCP_GITHUB_TOKEN          # static bearer from the bot env (startup fails if unset)
 #       agents: [general, research, coding] # default [general, research]
+#     lake:                                  # a server behind Cloudflare Access: the gate wants a service token,
+#       url: https://vega.example.com/mcp    # not an Authorization header — name the two headers and the bot
+#       auth: none                           # env vars holding them (manifest secrets on Cloudflare); an unset
+#       headersEnv:                          # one makes the server `unavailable` for that run, naming it
+#         CF-Access-Client-Id: MCP_ACCESS_CLIENT_ID
+#         CF-Access-Client-Secret: MCP_ACCESS_CLIENT_SECRET
 # channels:
 #   "slack:C0123":
 #     mcpServers:

package/dist/assets/deploy/cloudflare/package.json

@@ -24,6 +24,6 @@
     "@cloudflare/workers-types": "^5.20260904.1",
     "typescript": "^5.9.3",
     "vitest": "^5.0.0",
-    "wrangler": "^4.129.0"
+    "wrangler": "^4.129.1"
   }
 }

package/dist/assets/deploy/cloudflare/worker.ts

@@ -90,6 +90,8 @@ export interface Env {
   ANTHROPIC_ADMIN_KEY?: string; // costs dash (optional): Anthropic Admin API key for the LLM cost report
   MEMORY_TOKEN?: string; // durable memory + friction ledger + schedule firings + MCP registry: bearer for the state Worker
   MCP_CREDENTIAL_KEY?: string; // MCP registry: the bot-only key that seals server credentials before they reach the McpDO
+  MCP_ACCESS_CLIENT_ID?: string; // MCP servers behind Cloudflare Access: the service token's client id, named by a server's `headersEnv`
+  MCP_ACCESS_CLIENT_SECRET?: string; // MCP servers behind Cloudflare Access: the service token's client secret, named by a server's `headersEnv`
   STATE_WORKER_URL?: string; // var: the state Worker's base URL — where this shim records each scheduled firing
   ARTIFACTS_R2_ACCESS_KEY_ID?: string; // artifact store: the bucket-scoped S3 token the bot signs presigned URLs with
   ARTIFACTS_R2_SECRET_ACCESS_KEY?: string; // artifact store: the secret half of that token
@@ -124,6 +126,8 @@ const FORWARDED_OPTIONAL = [
   "BRAVE_SEARCH_API_KEY",
   "MEMORY_TOKEN",
   "MCP_CREDENTIAL_KEY",
+  "MCP_ACCESS_CLIENT_ID",
+  "MCP_ACCESS_CLIENT_SECRET",
   "STATE_WORKER_URL",
   "ARTIFACTS_R2_ACCESS_KEY_ID",
   "ARTIFACTS_R2_SECRET_ACCESS_KEY",

package/dist/assets/deploy/cloudflare-docs/package.json

@@ -13,6 +13,6 @@
     "tail": "wrangler tail"
   },
   "devDependencies": {
-    "wrangler": "^4.129.0"
+    "wrangler": "^4.129.1"
   }
 }

package/dist/assets/deploy/cloudflare-memory/package.json

@@ -20,6 +20,6 @@
     "@cloudflare/workers-types": "^5.20260904.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "wrangler": "^4.129.0"
+    "wrangler": "^4.129.1"
   }
 }

package/dist/assets/deploy/cloudflare-memory/worker.ts

@@ -46,7 +46,10 @@ import {
   attachmentRefsOf,
   DEFAULT_SESSION_LOG_MAX_BYTES,
   droppedToolResultRow,
+  GAP_MARKER,
+  NOTEPAD_MAX_BYTES,
   planSessionTrim,
+  roleOfStoredRow,
   rowKind,
   sessionsToDrop,
   tailCut,
@@ -80,6 +83,7 @@ import {
   type LiveRunRow,
   type ReclaimedRun,
   type RunState,
+  type SessionHit,
   type StepRecord,
   type StopMode,
   type TranscriptAttachment,
@@ -210,6 +214,10 @@ const FTS_CANDIDATES_FLOOR = 50;
  *  tokens and are untouched; the engine still ranks with the FULL query, so the
  *  cap only shapes which rows can become candidates. */
 const MAX_MATCH_TOKENS = 24;
+/** A `recall` query's size and the most hits one answers (session-log item 10):
+ *  a query is a few words, and the tool's default is five. */
+const MAX_SEARCH_QUERY_BYTES = 1_024;
+const MAX_SEARCH_HITS = 50;
 /** Request body ceiling, checked against Content-Length before parsing. A full
  *  batch (50 × 4000-char texts + keywords + envelope) fits comfortably. */
 const MAX_BODY_BYTES = 512 * 1024;
@@ -2892,18 +2900,65 @@ export class SessionLogDO extends DurableObject<Env> {
     return { ...(await this.read(from)), from };
   }
 
-  /** The rows whose text matches `query`, newest first. */
-  async search(query: string, limit: number): Promise<Array<{ idx: number; part: number; text: string }>> {
+  /** The rows whose text matches `query`, in relevance order (FTS5's bm25 rank,
+   *  the order the memory store's search uses; the newest first among equals),
+   *  each with its turn, part, role, kind and indexed text — what `recall`
+   *  answers (session-log item 10). */
+  async search(query: string, limit: number): Promise<SessionHit[]> {
     const match = ftsMatchExpr(query);
     if (match === null) return [];
     return this.sql
-      .exec<{ idx: number; part: number; text: string }>(
-        `SELECT t.idx, t.part, t.text FROM turns_fts f JOIN turns t ON t.id = f.rowid
-          WHERE turns_fts MATCH ? ORDER BY t.idx DESC, t.part DESC LIMIT ?`,
+      .exec<{ idx: number; part: number; kind: string; json: string; text: string }>(
+        `SELECT t.idx, t.part, t.kind, t.json, t.text FROM turns_fts f JOIN turns t ON t.id = f.rowid
+          WHERE turns_fts MATCH ? ORDER BY f.rank, t.idx DESC, t.part DESC LIMIT ?`,
         match,
         limit,
       )
-      .toArray();
+      .toArray()
+      .map(({ idx, part, kind, json, text }) => {
+        const role = roleOfStoredRow(json);
+        return { idx, part, ...(role !== undefined ? { role } : {}), kind, text };
+      });
+  }
+
+  /** The gap markers (session-log item 9) whose turn lies in `[from, to]`: the
+   *  rows a follow-up appended because the run before it detached, so a search
+   *  whose hits straddle one can say the log ends short between them. */
+  async gapsBetween(from: number, to: number): Promise<number[]> {
+    return this.sql
+      .exec<{ idx: number }>(
+        `SELECT DISTINCT idx FROM turns WHERE idx >= ? AND idx <= ? AND kind = 'text' AND text = ? ORDER BY idx`,
+        from,
+        to,
+        GAP_MARKER,
+      )
+      .toArray()
+      .map((r) => r.idx);
+  }
+
+  /** The notepad, replaced whole by the live run (session-log item 10): the
+   *  same fence as a row write — unknown-run before an owner, fenced for
+   *  another generation — and the write's time kept beside the text. */
+  async writeNotepad(gen: string, text: string, now: number): Promise<FenceResult> {
+    let out: FenceResult = { ok: true };
+    this.ctx.storage.transactionSync(() => {
+      const owner = this.owner();
+      if (owner === undefined) {
+        out = { ok: false, reason: "unknown-run" };
+        return;
+      }
+      if (owner.gen !== gen) {
+        out = { ok: false, reason: "fenced" };
+        return;
+      }
+      this.sql.exec(
+        `INSERT INTO notepad (k, text, updated_at) VALUES (1, ?, ?)
+         ON CONFLICT(k) DO UPDATE SET text = excluded.text, updated_at = excluded.updated_at`,
+        text,
+        now,
+      );
+    });
+    return out;
   }
 
   async bytes(): Promise<number> {
@@ -2968,6 +3023,9 @@ const LEDGER_ROUTES = new Set([
   "/runs/session/read",
   "/runs/session/read-tail",
   "/runs/session/clear-owner",
+  "/runs/session/search",
+  "/runs/session/notepad",
+  "/runs/session/notepad/write",
 ]);
 
 /** Routes whose bodies may carry a record, a transcript chunk, or an event batch. */
@@ -3187,6 +3245,38 @@ async function handleLedger(pathname: string, body: unknown, env: Env): Promise<
       if (!g.ok) return json({ error: g.error }, 400);
       return fenced(await stub.clearOwner(runId.value, g.value));
     }
+    // `recall` (session-log item 10): the hits in relevance order, and the gap
+    // markers that lie between the oldest and the newest of them.
+    if (pathname === "/runs/session/search") {
+      if (
+        typeof b.query !== "string" ||
+        b.query.trim().length === 0 ||
+        utf8ByteLength(b.query) > MAX_SEARCH_QUERY_BYTES
+      )
+        return json({ error: `query must be a non-empty string of at most ${MAX_SEARCH_QUERY_BYTES} bytes` }, 400);
+      const limit = b.limit;
+      if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > MAX_SEARCH_HITS)
+        return json({ error: `limit must be an integer in 1..${MAX_SEARCH_HITS}` }, 400);
+      const hits = await stub.search(b.query, limit);
+      const gaps =
+        hits.length > 1
+          ? await stub.gapsBetween(Math.min(...hits.map((h) => h.idx)), Math.max(...hits.map((h) => h.idx)))
+          : [];
+      console.log(`[runs/session/search] ${key.value} -> ${hits.length} hit(s), ${gaps.length} gap(s)`);
+      return json({ hits, gaps });
+    }
+    if (pathname === "/runs/session/notepad") return json({ notepad: await stub.notepad() });
+    if (pathname === "/runs/session/notepad/write") {
+      const g = gen(b.gen);
+      if (!g.ok) return json({ error: g.error }, 400);
+      if (typeof b.text !== "string") return json({ error: "text must be a string" }, 400);
+      const bytes = utf8ByteLength(b.text);
+      if (bytes > NOTEPAD_MAX_BYTES)
+        return json({ error: `text is ${bytes} bytes; the notepad holds at most ${NOTEPAD_MAX_BYTES}` }, 400);
+      const r = await stub.writeNotepad(g.value, b.text, systemClock());
+      console.log(`[runs/session/notepad/write] ${key.value} <- ${bytes} byte(s), ok=${r.ok}`);
+      return fenced(r);
+    }
     return json({ error: "not found" }, 404);
   }
 

package/dist/assets/deploy/cloudflare-resident/package.json

@@ -24,6 +24,6 @@
     "@cloudflare/workers-types": "^5.20260904.1",
     "typescript": "^5.9.3",
     "vitest": "^5.0.0",
-    "wrangler": "^4.129.0"
+    "wrangler": "^4.129.1"
   }
 }

package/dist/assets/deploy/cloudflare-sandbox/package.json

@@ -21,6 +21,6 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^5.20260904.1",
     "typescript": "^5.9.3",
-    "wrangler": "^4.129.0"
+    "wrangler": "^4.129.1"
   }
 }

package/dist/assets/deploy/secrets.manifest.json

@@ -99,6 +99,18 @@
       "optional": true,
       "note": "AES-256-GCM key (32 bytes, base64: `openssl rand -base64 32`) the bot seals MCP server credentials with before they go to the state Worker's McpDO (docs/reference/specs/mcp-tools.md). Bot-only by design: the Worker stores ciphertext. Rotation re-seals every credential — not built yet; rotate = users re-run `mcp connect`."
     },
+    {
+      "name": "MCP_ACCESS_CLIENT_ID",
+      "workers": ["bot"],
+      "optional": true,
+      "note": "Client id of the Cloudflare Access service token the bot presents to MCP servers behind Access — a pinned server's `headersEnv` names it under `CF-Access-Client-Id` (docs/reference/specs/mcp-tools.md item 11). Minted in Zero Trust → Access → Service Auth of the account that guards the server, and enrolled on that Access application's policy. Optional: without it such a server is `unavailable` naming the variable."
+    },
+    {
+      "name": "MCP_ACCESS_CLIENT_SECRET",
+      "workers": ["bot"],
+      "optional": true,
+      "note": "Client secret of that service token — `headersEnv` names it under `CF-Access-Client-Secret`. Shown once at creation; rotate by minting a new token, `deploy secrets bot --only` both names, `deploy restart`, then revoke the old one."
+    },
     {
       "name": "MEMORY_TOKEN",
       "workers": ["bot", "resident", "memory"],