sticky-note-cli 3.1.14 → 3.1.16

package/sticky-server/.wrangler/tmp/dev-gZFGI3/worker.js

@@ -0,0 +1,1006 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// .wrangler/tmp/bundle-cuweP4/checked-fetch.js
+var urls = /* @__PURE__ */ new Set();
+function checkURL(request, init) {
+  const url = request instanceof URL ? request : new URL(
+    (typeof request === "string" ? new Request(request, init) : request).url
+  );
+  if (url.port && url.port !== "443" && url.protocol === "https:") {
+    if (!urls.has(url.toString())) {
+      urls.add(url.toString());
+      console.warn(
+        `WARNING: known issue with \`fetch()\` requests to custom HTTPS ports in published Workers:
+ - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler deploy\` command.
+`
+      );
+    }
+  }
+}
+__name(checkURL, "checkURL");
+globalThis.fetch = new Proxy(globalThis.fetch, {
+  apply(target, thisArg, argArray) {
+    const [request, init] = argArray;
+    checkURL(request, init);
+    return Reflect.apply(target, thisArg, argArray);
+  }
+});
+
+// adapters/cf-kv.js
+async function getThreads(kv, project, filters = {}) {
+  const indexKey = `${project}:thread-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const threads = await Promise.all(
+    index.map(async (id) => {
+      const raw = await kv.get(`${project}:thread:${id}`);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  let result = threads.filter(Boolean);
+  if (filters.status) {
+    result = result.filter((t) => t.status === filters.status);
+  }
+  if (filters.q) {
+    const q = filters.q.toLowerCase();
+    result = result.filter(
+      (t) => (t.narrative || "").toLowerCase().includes(q) || (t.handoff_summary || "").toLowerCase().includes(q) || (t.last_note || "").toLowerCase().includes(q) || (t.files_touched || []).some((f) => f.toLowerCase().includes(q))
+    );
+  }
+  return result;
+}
+__name(getThreads, "getThreads");
+async function getThread(kv, project, id) {
+  const raw = await kv.get(`${project}:thread:${id}`);
+  return raw ? JSON.parse(raw) : null;
+}
+__name(getThread, "getThread");
+async function putThread(kv, project, thread) {
+  const id = thread.id;
+  await kv.put(`${project}:thread:${id}`, JSON.stringify(thread));
+  const indexKey = `${project}:thread-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (!index.includes(id)) {
+    index.push(id);
+    await kv.put(indexKey, JSON.stringify(index));
+  }
+}
+__name(putThread, "putThread");
+async function deleteThread(kv, project, id) {
+  const existing = await getThread(kv, project, id);
+  if (existing) {
+    const tombstone = {
+      id: existing.id,
+      user: existing.user,
+      status: "expired",
+      closed_at: existing.closed_at || (/* @__PURE__ */ new Date()).toISOString(),
+      created_at: existing.created_at
+    };
+    await kv.put(`${project}:thread:${id}`, JSON.stringify(tombstone));
+  }
+}
+__name(deleteThread, "deleteThread");
+async function appendAudit(kv, project, record) {
+  const ts = record.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const uid = crypto.randomUUID();
+  const key = `${project}:audit:${ts}:${uid}`;
+  await kv.put(key, JSON.stringify(record));
+  const indexKey = `${project}:audit-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  index.push(key);
+  if (index.length > 1e4) {
+    const removed = index.splice(0, index.length - 1e4);
+    await Promise.all(removed.map((k) => kv.delete(k)));
+  }
+  await kv.put(indexKey, JSON.stringify(index));
+}
+__name(appendAudit, "appendAudit");
+async function queryAudit(kv, project, filters = {}) {
+  const indexKey = `${project}:audit-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const records = await Promise.all(
+    index.map(async (key) => {
+      const raw = await kv.get(key);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  let result = records.filter(Boolean);
+  if (filters.user) {
+    result = result.filter((r) => r.user === filters.user);
+  }
+  if (filters.file) {
+    result = result.filter((r) => (r.file || "").includes(filters.file));
+  }
+  if (filters.tool) {
+    result = result.filter((r) => r.tool === filters.tool);
+  }
+  if (filters.since) {
+    const since = new Date(filters.since).getTime();
+    result = result.filter(
+      (r) => new Date(r.timestamp || 0).getTime() >= since
+    );
+  }
+  return result;
+}
+__name(queryAudit, "queryAudit");
+var PRESENCE_TTL_SECONDS = 15 * 60;
+async function getPresence(kv, project) {
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (index.length === 0) return [];
+  const records = await Promise.all(
+    index.map(async (user) => {
+      const raw = await kv.get(`${project}:presence:${user}`);
+      return raw ? JSON.parse(raw) : null;
+    })
+  );
+  return records.filter(Boolean);
+}
+__name(getPresence, "getPresence");
+async function upsertPresence(kv, project, record) {
+  const user = record.user;
+  await kv.put(`${project}:presence:${user}`, JSON.stringify(record), {
+    expirationTtl: PRESENCE_TTL_SECONDS
+  });
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  if (!index.includes(user)) {
+    index.push(user);
+    await kv.put(indexKey, JSON.stringify(index));
+  }
+}
+__name(upsertPresence, "upsertPresence");
+async function deletePresence(kv, project, user) {
+  await kv.delete(`${project}:presence:${user}`);
+  const indexKey = `${project}:presence-index`;
+  const index = JSON.parse(await kv.get(indexKey) || "[]");
+  const filtered = index.filter((u) => u !== user);
+  await kv.put(indexKey, JSON.stringify(filtered));
+}
+__name(deletePresence, "deletePresence");
+var MAX_CHUNK_BYTES = 2 * 1024 * 1024;
+async function getEvents(kv, project, threadId) {
+  const metaKey2 = `${project}:thread:${threadId}`;
+  const meta = await kv.get(metaKey2, { type: "json" }).catch(() => null);
+  const chunkCount = meta && meta._event_chunks || 0;
+  if (chunkCount === 0) {
+    const single = await kv.get(`${metaKey2}:events`, { type: "json" }).catch(() => null);
+    return Array.isArray(single) ? single : [];
+  }
+  const chunks = await Promise.all(
+    Array.from(
+      { length: chunkCount },
+      (_, i) => kv.get(`${metaKey2}:events:${i}`, { type: "json" }).catch(() => [])
+    )
+  );
+  return chunks.flat().filter(Boolean);
+}
+__name(getEvents, "getEvents");
+async function appendEvents(kv, project, threadId, newEvents) {
+  if (!newEvents || newEvents.length === 0) return;
+  const metaKey2 = `${project}:thread:${threadId}`;
+  const meta = await kv.get(metaKey2, { type: "json" }).catch(() => ({}));
+  const chunkCount = meta && meta._event_chunks || 0;
+  let currentChunkIdx = chunkCount === 0 ? 0 : chunkCount - 1;
+  let currentChunk = [];
+  if (chunkCount > 0) {
+    currentChunk = await kv.get(`${metaKey2}:events:${currentChunkIdx}`, { type: "json" }).catch(() => []) || [];
+  }
+  const enc = new TextEncoder();
+  let chunkBytes = enc.encode(JSON.stringify(currentChunk)).length;
+  for (const event of newEvents) {
+    const eventBytes = enc.encode(JSON.stringify(event)).length;
+    if (chunkBytes + eventBytes > MAX_CHUNK_BYTES && currentChunk.length > 0) {
+      await kv.put(`${metaKey2}:events:${currentChunkIdx}`, JSON.stringify(currentChunk));
+      currentChunkIdx++;
+      currentChunk = [];
+      chunkBytes = 0;
+    }
+    currentChunk.push(event);
+    chunkBytes += eventBytes;
+  }
+  await kv.put(`${metaKey2}:events:${currentChunkIdx}`, JSON.stringify(currentChunk));
+  const newMeta = { ...meta || {}, _event_chunks: currentChunkIdx + 1 };
+  await kv.put(metaKey2, JSON.stringify(newMeta));
+}
+__name(appendEvents, "appendEvents");
+async function getConfig(kv, project) {
+  const raw = await kv.get(`${project}:config`);
+  return raw ? JSON.parse(raw) : null;
+}
+__name(getConfig, "getConfig");
+async function putConfig(kv, project, config) {
+  await kv.put(`${project}:config`, JSON.stringify(config));
+}
+__name(putConfig, "putConfig");
+
+// mcp-tools.js
+var EVENT_TYPES = Object.freeze({
+  SESSION_OPEN: "session_open",
+  SESSION_CLOSE: "session_close",
+  USER_PROMPT: "user_prompt",
+  CHECKPOINT: "checkpoint"
+});
+var MCP_TOOL_DEFINITIONS = [
+  {
+    name: "open_thread",
+    description: "Call at session start. Creates a new thread and returns its thread_id for use in subsequent append_event and close_thread calls.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Verbatim first user prompt" },
+        branch: { type: "string", description: "Current git branch" },
+        user: { type: "string", description: "Username" },
+        model: { type: "string", description: "Model ID (e.g. claude-sonnet-4-6)" },
+        mcp_servers: { type: "array", items: { type: "string" }, description: "Connected MCP server names" },
+        claude_md_hash: { type: "string", description: "SHA256 of CLAUDE.md content (optional)" }
+      },
+      required: ["prompt", "user"]
+    }
+  },
+  {
+    name: "append_event",
+    description: "Call for every action in the session. Records one event (user_prompt, ai_thinking, ai_response, tool_call, tool_result, tool_error, tool_denied, context_compressed, git_commit, subagent_spawn, subagent_result, checkpoint). Do not call for streaming tokens or internal transport retries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string", description: "thread_id returned by open_thread" },
+        type: { type: "string", description: "Event type (see description)" },
+        data: { type: "object", description: "Event-specific payload" }
+      },
+      required: ["thread_id", "type", "data"]
+    }
+  },
+  {
+    name: "set_checkpoint",
+    description: "Call when the user switches to a different topic mid-session. Marks subsequent events with the new topic for attribution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string" },
+        topic: { type: "string", description: "Short description of new work topic" }
+      },
+      required: ["thread_id", "topic"]
+    }
+  },
+  {
+    name: "close_thread",
+    description: "Call at session end. Writes the session_close event, updates thread status to closed, and triggers a git commit of thread metadata.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string" },
+        narrative: { type: "string", description: "Summary of what was accomplished" },
+        work_type: { type: "string", description: "e.g. bug-fix, feature-development, debugging, refactor, documentation" },
+        handoff_summary: { type: "string", description: "Notes for teammates picking this up" },
+        failed_approaches: { type: "array", items: { type: "string" }, description: "What was tried and didn't work" },
+        files_touched: { type: "array", items: { type: "string" }, description: "Files modified during session" }
+      },
+      required: ["thread_id", "narrative"]
+    }
+  }
+];
+async function handleMcpTool(toolName, input, env, project, getOrCreateDO2) {
+  switch (toolName) {
+    case "open_thread":
+      return handleOpenThread(input, env, project, getOrCreateDO2);
+    case "append_event":
+      return handleAppendEvent(input, env, project, getOrCreateDO2);
+    case "set_checkpoint":
+      return handleSetCheckpoint(input, env, project, getOrCreateDO2);
+    case "close_thread":
+      return handleCloseThread(input, env, project, getOrCreateDO2);
+    default:
+      throw new Error(`Unknown tool: ${toolName}`);
+  }
+}
+__name(handleMcpTool, "handleMcpTool");
+async function handleOpenThread(input, env, project, getOrCreateDO2) {
+  const threadId = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const threadMeta = {
+    id: threadId,
+    status: "open",
+    user: input.user,
+    branch: input.branch || "",
+    created_at: now,
+    last_activity_at: now,
+    files_touched: [],
+    narrative: "",
+    tool: "claude-code",
+    session_id: null,
+    // remote sessions don't have a local session_id
+    _event_chunks: 0
+  };
+  const metaKey2 = `${project}:thread:${threadId}`;
+  await env.STICKY_KV.put(metaKey2, JSON.stringify(threadMeta));
+  const openEvent = {
+    ts: now,
+    type: EVENT_TYPES.SESSION_OPEN,
+    session_id: null,
+    data: {
+      model: input.model || null,
+      branch: input.branch || null,
+      user: input.user,
+      mcp_servers: input.mcp_servers || [],
+      claude_md_hash: input.claude_md_hash || null
+    }
+  };
+  const promptEvent = {
+    ts: now,
+    type: EVENT_TYPES.USER_PROMPT,
+    session_id: null,
+    data: { content: input.prompt }
+  };
+  const do_stub = getOrCreateDO2(env, threadId);
+  await do_stub.fetch(new Request("http://do/do/open", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ thread_id: threadId, project, events: [openEvent, promptEvent] })
+  }));
+  _commitThreadToGit(env, project, threadId, getOrCreateDO2).catch(() => {
+  });
+  return { thread_id: threadId };
+}
+__name(handleOpenThread, "handleOpenThread");
+async function handleAppendEvent(input, env, project, getOrCreateDO2) {
+  const { thread_id, type, data } = input;
+  const metaKey2 = `${project}:thread:${thread_id}`;
+  const exists = await env.STICKY_KV.get(metaKey2, { type: "text" });
+  if (!exists) return { ok: false, error: "unknown thread_id" };
+  const event = { ts: (/* @__PURE__ */ new Date()).toISOString(), type, session_id: null, data: data || {} };
+  const do_stub = getOrCreateDO2(env, thread_id);
+  await do_stub.fetch(new Request("http://do/do/append", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ event })
+  }));
+  return { ok: true };
+}
+__name(handleAppendEvent, "handleAppendEvent");
+async function handleSetCheckpoint(input, env, project, getOrCreateDO2) {
+  return handleAppendEvent(
+    { thread_id: input.thread_id, type: EVENT_TYPES.CHECKPOINT, data: { topic: input.topic } },
+    env,
+    project,
+    getOrCreateDO2
+  );
+}
+__name(handleSetCheckpoint, "handleSetCheckpoint");
+async function handleCloseThread(input, env, project, getOrCreateDO2) {
+  const { thread_id, narrative, work_type, handoff_summary, failed_approaches, files_touched } = input;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const closeEvent = {
+    ts: now,
+    type: EVENT_TYPES.SESSION_CLOSE,
+    session_id: null,
+    data: {
+      narrative,
+      work_type: work_type || "general",
+      handoff_summary: handoff_summary || "",
+      failed_approaches: failed_approaches || [],
+      files_touched: files_touched || []
+    }
+  };
+  const do_stub = getOrCreateDO2(env, thread_id);
+  await do_stub.fetch(new Request("http://do/do/close", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ close_event: closeEvent })
+  }));
+  const metaKey2 = `${project}:thread:${thread_id}`;
+  const meta = await env.STICKY_KV.get(metaKey2, { type: "json" }).catch(() => ({})) || {};
+  meta.status = "closed";
+  meta.closed_at = now;
+  meta.narrative = narrative;
+  meta.work_type = work_type || "general";
+  meta.handoff_summary = handoff_summary || "";
+  meta.failed_approaches = failed_approaches || [];
+  if (files_touched) {
+    meta.files_touched = [.../* @__PURE__ */ new Set([...meta.files_touched || [], ...files_touched])];
+  }
+  await env.STICKY_KV.put(metaKey2, JSON.stringify(meta));
+  await _commitThreadToGit(env, project, thread_id, getOrCreateDO2);
+  return { ok: true };
+}
+__name(handleCloseThread, "handleCloseThread");
+async function _commitThreadToGit(env, project, threadId, getOrCreateDO2) {
+  const kv = env.STICKY_KV;
+  const threadsListKey = `${project}:threads_index`;
+  let threadIds = await kv.get(threadsListKey, { type: "json" }).catch(() => []) || [];
+  if (!threadIds.includes(threadId)) {
+    threadIds = [threadId, ...threadIds].slice(0, 500);
+    await kv.put(threadsListKey, JSON.stringify(threadIds));
+  }
+  const pat = env.GITHUB_PAT;
+  const repoFull = env.GITHUB_REPO;
+  if (!pat || !repoFull) return;
+  const [owner, repo] = repoFull.split("/");
+  if (!owner || !repo) return;
+  const allMeta = await Promise.all(
+    threadIds.map((id) => kv.get(`${project}:thread:${id}`, { type: "json" }).catch(() => null))
+  );
+  const threads = allMeta.filter(Boolean).map((m) => {
+    const { _event_chunks, _last_recovery_attempt, ...rest } = m;
+    return rest;
+  });
+  const newContent = JSON.stringify({ version: "2", project, threads }, null, 2) + "\n";
+  const do_stub = getOrCreateDO2(env, threadId);
+  await do_stub.fetch(new Request("http://do/do/github-commit", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      owner,
+      repo,
+      path: ".sticky-note/sticky-note.json",
+      content: newContent,
+      message: `chore(sticky-note): sync thread ${threadId.slice(0, 8)}`,
+      pat
+    })
+  }));
+}
+__name(_commitThreadToGit, "_commitThreadToGit");
+
+// sticky-thread-do.js
+var StickyThread = class {
+  static {
+    __name(this, "StickyThread");
+  }
+  constructor(state, env) {
+    this.state = state;
+    this.env = env;
+    this.buffer = [];
+    this.flushThreshold = 10;
+    this.threadId = null;
+    this.project = "default";
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    const body = await request.json().catch(() => ({}));
+    if (url.pathname === "/do/open") {
+      this.threadId = body.thread_id;
+      this.project = body.project || "default";
+      for (const ev of body.events || []) this.buffer.push(ev);
+      await this._scheduleFlush();
+      return new Response(JSON.stringify({ ok: true, thread_id: this.threadId }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (url.pathname === "/do/append") {
+      const event = body.event;
+      if (event) this.buffer.push(event);
+      if (this.buffer.length >= this.flushThreshold) {
+        await this._flush();
+      } else {
+        await this._scheduleFlush();
+      }
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (url.pathname === "/do/close") {
+      const closeEvent = body.close_event;
+      if (closeEvent) this.buffer.push(closeEvent);
+      await this._flush();
+      try {
+        await this.state.storage.deleteAlarm();
+      } catch (_) {
+      }
+      return new Response(JSON.stringify({ ok: true, flushed: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (url.pathname === "/do/github-commit") {
+      const result = await this._githubCommit(body);
+      return new Response(JSON.stringify(result), {
+        headers: { "Content-Type": "application/json" },
+        status: result.ok ? 200 : 500
+      });
+    }
+    return new Response("not found", { status: 404 });
+  }
+  async alarm() {
+    if (this.buffer.length > 0) {
+      await this._flush();
+    }
+  }
+  async _scheduleFlush() {
+    try {
+      const existing = await this.state.storage.getAlarm();
+      if (!existing) {
+        await this.state.storage.setAlarm(Date.now() + 5e3);
+      }
+    } catch (_) {
+    }
+  }
+  async _flush() {
+    if (this.buffer.length === 0 || !this.threadId) return;
+    const toFlush = this.buffer.splice(0);
+    try {
+      await appendEvents(this.env.STICKY_KV, this.project, this.threadId, toFlush);
+    } catch (err) {
+      this.buffer.unshift(...toFlush);
+    }
+  }
+  async _githubCommit(body) {
+    const { owner, repo, path: filePath, content, message, pat } = body;
+    if (!pat) return { ok: false, error: "no PAT" };
+    const apiBase = `https://api.github.com/repos/${owner}/${repo}/contents/${filePath}`;
+    const headers = {
+      Authorization: `Bearer ${pat}`,
+      Accept: "application/vnd.github+json",
+      "Content-Type": "application/json",
+      "User-Agent": "sticky-note-worker"
+    };
+    let sha = null;
+    let retries = 3;
+    while (retries-- > 0) {
+      const getResp = await fetch(apiBase, { headers }).catch(() => null);
+      if (getResp && getResp.ok) {
+        const data = await getResp.json().catch(() => ({}));
+        sha = data.sha || null;
+      }
+      const putBody = {
+        message,
+        content: btoa(unescape(encodeURIComponent(content))),
+        // base64 encode UTF-8
+        ...sha ? { sha } : {}
+      };
+      const putResp = await fetch(apiBase, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify(putBody)
+      }).catch(() => null);
+      if (!putResp) return { ok: false, error: "network error" };
+      if (putResp.ok) return { ok: true };
+      if (putResp.status === 409) {
+        await new Promise((r) => setTimeout(r, 200));
+        continue;
+      }
+      const errBody = await putResp.json().catch(() => ({}));
+      return { ok: false, error: errBody.message || `HTTP ${putResp.status}` };
+    }
+    return { ok: false, error: "max retries exceeded (409 conflict)" };
+  }
+};
+
+// worker.js
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(json, "json");
+function error(message, status = 400) {
+  return json({ error: message }, status);
+}
+__name(error, "error");
+function authenticate(request, env) {
+  const key = request.headers.get("X-Sticky-API-Key");
+  if (!env.STICKY_API_KEY) return true;
+  return key === env.STICKY_API_KEY;
+}
+__name(authenticate, "authenticate");
+function getProject(request) {
+  return request.headers.get("X-Sticky-Project") || "default";
+}
+__name(getProject, "getProject");
+function matchRoute(method, pathname) {
+  if (method === "POST" && pathname === "/threads") return { handler: "createThread" };
+  if (method === "GET" && pathname === "/threads") return { handler: "listThreads" };
+  if (method === "POST" && pathname.match(/^\/threads\/[^/]+\/events$/)) {
+    const id = pathname.split("/")[2];
+    return { handler: "appendThreadEvents", id };
+  }
+  if (method === "GET" && pathname.match(/^\/threads\/[^/]+\/events$/)) {
+    const id = pathname.split("/")[2];
+    return { handler: "getThreadEvents", id };
+  }
+  if (method === "GET" && pathname.startsWith("/threads/")) {
+    return { handler: "getThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "PUT" && pathname.startsWith("/threads/")) {
+    return { handler: "updateThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "DELETE" && pathname.startsWith("/threads/")) {
+    return { handler: "deleteThread", id: pathname.slice("/threads/".length) };
+  }
+  if (method === "GET" && pathname === "/audit") return { handler: "queryAudit" };
+  if (method === "POST" && pathname === "/audit") return { handler: "appendAudit" };
+  if (method === "GET" && pathname === "/presence") return { handler: "getPresence" };
+  if (method === "POST" && pathname === "/presence") return { handler: "upsertPresence" };
+  if (method === "DELETE" && pathname.startsWith("/presence/")) {
+    return { handler: "deletePresence", user: decodeURIComponent(pathname.slice("/presence/".length)) };
+  }
+  if (method === "GET" && pathname === "/config") return { handler: "getConfig" };
+  if (method === "PUT" && pathname === "/config") return { handler: "putConfig" };
+  if (method === "GET" && pathname === "/mcp") return { handler: "mcpListTools" };
+  if (method === "POST" && pathname === "/mcp") return { handler: "mcpCallTool" };
+  if (method === "GET" && pathname === "/health") return { handler: "health" };
+  return null;
+}
+__name(matchRoute, "matchRoute");
+var handlers = {
+  async health() {
+    return json({ status: "ok", version: "3.0.0" });
+  },
+  // ── Threads ──
+  async createThread(request, kv, project) {
+    const thread = await request.json();
+    if (!thread.id) return error("thread.id is required");
+    await putThread(kv, project, thread);
+    return json(thread, 201);
+  },
+  async listThreads(request, kv, project) {
+    const url = new URL(request.url);
+    const filters = {
+      status: url.searchParams.get("status") || void 0,
+      q: url.searchParams.get("q") || void 0
+    };
+    const threads = await getThreads(kv, project, filters);
+    return json({ threads });
+  },
+  async getThread(_request, kv, project, { id }) {
+    const thread = await getThread(kv, project, id);
+    if (!thread) return error("Thread not found", 404);
+    return json(thread);
+  },
+  async updateThread(request, kv, project, { id }) {
+    const thread = await request.json();
+    thread.id = id;
+    await putThread(kv, project, thread);
+    return json(thread);
+  },
+  async deleteThread(_request, kv, project, { id }) {
+    await deleteThread(kv, project, id);
+    return json({ deleted: id });
+  },
+  // ── Thread Events ──
+  async appendThreadEvents(request, kv, project, { id }) {
+    const body = await request.json().catch(() => ({}));
+    const events = Array.isArray(body.events) ? body.events : [];
+    await appendEvents(kv, project, id, events);
+    return json({ ok: true, appended: events.length });
+  },
+  async getThreadEvents(_request, kv, project, { id }) {
+    const events = await getEvents(kv, project, id);
+    return json({ events });
+  },
+  // ── Audit ──
+  async queryAudit(request, kv, project) {
+    const url = new URL(request.url);
+    const filters = {
+      user: url.searchParams.get("user") || void 0,
+      file: url.searchParams.get("file") || void 0,
+      tool: url.searchParams.get("tool") || void 0,
+      since: url.searchParams.get("since") || void 0
+    };
+    const records = await queryAudit(kv, project, filters);
+    return json({ audit: records });
+  },
+  async appendAudit(request, kv, project) {
+    const record = await request.json();
+    await appendAudit(kv, project, record);
+    return json({ ok: true }, 201);
+  },
+  // ── Presence ──
+  async getPresence(_request, kv, project) {
+    const records = await getPresence(kv, project);
+    return json({ presence: records });
+  },
+  async upsertPresence(request, kv, project) {
+    const record = await request.json();
+    if (!record.user) return error("record.user is required");
+    await upsertPresence(kv, project, record);
+    return json({ ok: true });
+  },
+  async deletePresence(_request, kv, project, { user }) {
+    await deletePresence(kv, project, user);
+    return json({ deleted: user });
+  },
+  // ── MCP ──
+  async mcpListTools() {
+    return json({ tools: MCP_TOOL_DEFINITIONS });
+  },
+  async mcpCallTool(request, _kv, project, _route, env) {
+    const body = await request.json().catch(() => ({}));
+    const toolName = body.tool || body.name;
+    const toolInput = body.input || body.arguments || {};
+    if (!toolName) return error("tool name required");
+    try {
+      const result = await handleMcpTool(toolName, toolInput, env, project, getOrCreateDO);
+      return json({ content: [{ type: "text", text: JSON.stringify(result) }] });
+    } catch (err) {
+      return error(err.message, 400);
+    }
+  },
+  // ── Config ──
+  async getConfig(_request, kv, project) {
+    const config = await getConfig(kv, project);
+    if (!config) return json({});
+    return json(config);
+  },
+  async putConfig(request, kv, project) {
+    const config = await request.json();
+    await putConfig(kv, project, config);
+    return json(config);
+  }
+};
+function getOrCreateDO(env, threadId) {
+  const id = env.STICKY_THREAD.idFromName(threadId);
+  return env.STICKY_THREAD.get(id);
+}
+__name(getOrCreateDO, "getOrCreateDO");
+var worker_default = {
+  async fetch(request, env) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, X-Sticky-API-Key, X-Sticky-Project"
+        }
+      });
+    }
+    if (!authenticate(request, env)) {
+      return error("Unauthorized", 401);
+    }
+    const url = new URL(request.url);
+    const route = matchRoute(request.method, url.pathname);
+    if (!route) {
+      return error("Not found", 404);
+    }
+    const project = getProject(request);
+    const kv = env.STICKY_KV;
+    try {
+      const handler = handlers[route.handler];
+      const response = await handler(request, kv, project, route, env);
+      const headers = new Headers(response.headers);
+      headers.set("Access-Control-Allow-Origin", "*");
+      return new Response(response.body, {
+        status: response.status,
+        headers
+      });
+    } catch (err) {
+      return error(`Internal error: ${err.message}`, 500);
+    }
+  },
+  async scheduled(event, env, ctx) {
+    ctx.waitUntil(runCrashRecovery(env));
+  }
+};
+async function runCrashRecovery(env) {
+  const projects = ["default"];
+  const staleThresholdMs = 30 * 60 * 1e3;
+  const now = Date.now();
+  for (const project of projects) {
+    const threadsListKey = `${project}:threads_index`;
+    const threadIds = await env.STICKY_KV.get(threadsListKey, { type: "json" }).catch(() => []) || [];
+    const metas = await Promise.all(
+      threadIds.map(
+        (id) => env.STICKY_KV.get(`${project}:thread:${id}`, { type: "json" }).catch(() => null)
+      )
+    );
+    for (let i = 0; i < threadIds.length; i++) {
+      const meta = metas[i];
+      const threadId = threadIds[i];
+      if (!meta || meta.status !== "open") continue;
+      const lastActivity = new Date(meta.last_activity_at || meta.created_at).getTime();
+      if (now - lastActivity < staleThresholdMs) continue;
+      const lastAttempt = meta._last_recovery_attempt || 0;
+      if (now - lastAttempt < 5 * 60 * 1e3) continue;
+      try {
+        const do_stub = getOrCreateDO(env, threadId);
+        const recovery_event = {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          type: EVENT_TYPES.SESSION_CLOSE,
+          session_id: null,
+          data: { narrative: "[recovered by cron]", work_type: "unknown", handoff_summary: "", failed_approaches: [], files_touched: [] }
+        };
+        meta._last_recovery_attempt = now;
+        await env.STICKY_KV.put(metaKey, JSON.stringify(meta));
+        await do_stub.fetch(new Request("http://do/do/close", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ close_event: recovery_event })
+        }));
+        meta.status = "stale";
+        meta.last_activity_at = (/* @__PURE__ */ new Date()).toISOString();
+        await env.STICKY_KV.put(metaKey, JSON.stringify(meta));
+        await _commitThreadToGit(env, project, threadId, getOrCreateDO).catch(() => {
+        });
+      } catch (_) {
+        console.error(`[sticky-note] crash recovery failed for thread ${threadId}`);
+      }
+    }
+  }
+}
+__name(runCrashRecovery, "runCrashRecovery");
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/middleware-ensure-req-body-drained.ts
+var drainBody = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } finally {
+    try {
+      if (request.body !== null && !request.bodyUsed) {
+        const reader = request.body.getReader();
+        while (!(await reader.read()).done) {
+        }
+      }
+    } catch (e) {
+      console.error("Failed to drain the unused request body.", e);
+    }
+  }
+}, "drainBody");
+var middleware_ensure_req_body_drained_default = drainBody;
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/middleware-miniflare3-json-error.ts
+function reduceError(e) {
+  return {
+    name: e?.name,
+    message: e?.message ?? String(e),
+    stack: e?.stack,
+    cause: e?.cause === void 0 ? void 0 : reduceError(e.cause)
+  };
+}
+__name(reduceError, "reduceError");
+var jsonError = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } catch (e) {
+    const error2 = reduceError(e);
+    const body = JSON.stringify(error2);
+    const headers = {
+      "Content-Type": "application/json",
+      "MF-Experimental-Error-Stack": "true"
+    };
+    const encoded = encodeURIComponent(body);
+    if (encoded.length <= 8192) {
+      headers["MF-Experimental-Error-Stack-Payload"] = encoded;
+    }
+    return new Response(body, { status: 500, headers });
+  }
+}, "jsonError");
+var middleware_miniflare3_json_error_default = jsonError;
+
+// .wrangler/tmp/bundle-cuweP4/middleware-insertion-facade.js
+var __INTERNAL_WRANGLER_MIDDLEWARE__ = [
+  middleware_ensure_req_body_drained_default,
+  middleware_miniflare3_json_error_default
+];
+var middleware_insertion_facade_default = worker_default;
+
+// ../../../../../AppData/Roaming/npm/node_modules/wrangler/templates/middleware/common.ts
+var __facade_middleware__ = [];
+function __facade_register__(...args) {
+  __facade_middleware__.push(...args.flat());
+}
+__name(__facade_register__, "__facade_register__");
+function __facade_invokeChain__(request, env, ctx, dispatch, middlewareChain) {
+  const [head, ...tail] = middlewareChain;
+  const middlewareCtx = {
+    dispatch,
+    next(newRequest, newEnv) {
+      return __facade_invokeChain__(newRequest, newEnv, ctx, dispatch, tail);
+    }
+  };
+  return head(request, env, ctx, middlewareCtx);
+}
+__name(__facade_invokeChain__, "__facade_invokeChain__");
+function __facade_invoke__(request, env, ctx, dispatch, finalMiddleware) {
+  return __facade_invokeChain__(request, env, ctx, dispatch, [
+    ...__facade_middleware__,
+    finalMiddleware
+  ]);
+}
+__name(__facade_invoke__, "__facade_invoke__");
+
+// .wrangler/tmp/bundle-cuweP4/middleware-loader.entry.ts
+var __Facade_ScheduledController__ = class ___Facade_ScheduledController__ {
+  constructor(scheduledTime, cron, noRetry) {
+    this.scheduledTime = scheduledTime;
+    this.cron = cron;
+    this.#noRetry = noRetry;
+  }
+  scheduledTime;
+  cron;
+  static {
+    __name(this, "__Facade_ScheduledController__");
+  }
+  #noRetry;
+  noRetry() {
+    if (!(this instanceof ___Facade_ScheduledController__)) {
+      throw new TypeError("Illegal invocation");
+    }
+    this.#noRetry();
+  }
+};
+function wrapExportedHandler(worker) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return worker;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  const fetchDispatcher = /* @__PURE__ */ __name(function(request, env, ctx) {
+    if (worker.fetch === void 0) {
+      throw new Error("Handler does not export a fetch() function.");
+    }
+    return worker.fetch(request, env, ctx);
+  }, "fetchDispatcher");
+  return {
+    ...worker,
+    fetch(request, env, ctx) {
+      const dispatcher = /* @__PURE__ */ __name(function(type, init) {
+        if (type === "scheduled" && worker.scheduled !== void 0) {
+          const controller = new __Facade_ScheduledController__(
+            Date.now(),
+            init.cron ?? "",
+            () => {
+            }
+          );
+          return worker.scheduled(controller, env, ctx);
+        }
+      }, "dispatcher");
+      return __facade_invoke__(request, env, ctx, dispatcher, fetchDispatcher);
+    }
+  };
+}
+__name(wrapExportedHandler, "wrapExportedHandler");
+function wrapWorkerEntrypoint(klass) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return klass;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  return class extends klass {
+    #fetchDispatcher = /* @__PURE__ */ __name((request, env, ctx) => {
+      this.env = env;
+      this.ctx = ctx;
+      if (super.fetch === void 0) {
+        throw new Error("Entrypoint class does not define a fetch() function.");
+      }
+      return super.fetch(request);
+    }, "#fetchDispatcher");
+    #dispatcher = /* @__PURE__ */ __name((type, init) => {
+      if (type === "scheduled" && super.scheduled !== void 0) {
+        const controller = new __Facade_ScheduledController__(
+          Date.now(),
+          init.cron ?? "",
+          () => {
+          }
+        );
+        return super.scheduled(controller);
+      }
+    }, "#dispatcher");
+    fetch(request) {
+      return __facade_invoke__(
+        request,
+        this.env,
+        this.ctx,
+        this.#dispatcher,
+        this.#fetchDispatcher
+      );
+    }
+  };
+}
+__name(wrapWorkerEntrypoint, "wrapWorkerEntrypoint");
+var WRAPPED_ENTRY;
+if (typeof middleware_insertion_facade_default === "object") {
+  WRAPPED_ENTRY = wrapExportedHandler(middleware_insertion_facade_default);
+} else if (typeof middleware_insertion_facade_default === "function") {
+  WRAPPED_ENTRY = wrapWorkerEntrypoint(middleware_insertion_facade_default);
+}
+var middleware_loader_entry_default = WRAPPED_ENTRY;
+export {
+  StickyThread,
+  __INTERNAL_WRANGLER_MIDDLEWARE__,
+  middleware_loader_entry_default as default
+};
+//# sourceMappingURL=worker.js.map