flyspace-cli 0.1.15 → 0.1.16

package/dist/{chunk-KFT2YP5W.js → chunk-2OGLCT7I.js}

@@ -263,7 +263,7 @@ function stopAutomationRegistryPolling() {
 }
 
 // src/channels.ts
-import { existsSync as existsSync2, mkdirSync, statSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, realpathSync, statSync } from "fs";
 import { homedir } from "os";
 import { isAbsolute, resolve as resolve2, sep } from "path";
 function isLogicalCwd(p) {
@@ -272,11 +272,22 @@ function isLogicalCwd(p) {
 function logicalRoot() {
   return process.env["FLYSPACE_ROOT"] || resolve2(homedir(), "Flyspace");
 }
+var workspaceRoots = /* @__PURE__ */ new Map();
+async function refreshWorkspaceRoots() {
+  const { data, error } = await getSupabaseClient().from("workspaces").select("slug, root_path");
+  if (error) return;
+  workspaceRoots = new Map(
+    (data ?? []).filter((w) => w.root_path).map((w) => [w.slug, expandPath(w.root_path)])
+  );
+}
 function resolveLogicalCwd(p) {
-  return resolve2(logicalRoot(), p);
+  const [slug, name] = p.split("/");
+  const root = workspaceRoots.get(slug);
+  return root ? resolve2(root, name) : resolve2(logicalRoot(), p);
 }
 function ensureLogicalCwdDir(cwd) {
-  if (!cwd.startsWith(logicalRoot() + sep) || existsSync2(cwd)) return;
+  const roots = [logicalRoot(), ...workspaceRoots.values()];
+  if (!roots.some((r) => cwd.startsWith(r + sep)) || existsSync2(cwd)) return;
   mkdirSync(cwd, { recursive: true });
 }
 function expandPath(p) {
@@ -358,6 +369,9 @@ function indexRegistry(list) {
   );
 }
 async function refreshChannelRegistry() {
+  const rootsBefore = JSON.stringify([...workspaceRoots]);
+  await refreshWorkspaceRoots();
+  if (JSON.stringify([...workspaceRoots]) !== rootsBefore) lastSnapshot2 = void 0;
   const { data, error } = await getSupabaseClient().from("channels").select("*").order("position", { ascending: true });
   if (error) {
     console.error("[channels] refreshChannelRegistry failed:", error.message);
@@ -522,7 +536,44 @@ function toRow(input) {
   if (input.archivedAt !== void 0) row["archived_at"] = input.archivedAt;
   return row;
 }
+var ChannelCwdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChannelCwdError";
+  }
+};
+function realpathOrSelf(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+async function assertCwdInWorkspace(profile, cwd) {
+  if (isLogicalCwd(cwd)) {
+    if (cwd.split("/")[0] !== profile) {
+      throw new ChannelCwdError(`Folder "${cwd}" belongs to another workspace.`);
+    }
+    return cwd;
+  }
+  const { data, error } = await getSupabaseClient().from("workspaces").select("slug, root_path");
+  if (error) throw new Error(error.message);
+  const workspaces = data ?? [];
+  const ownRoot = workspaces.find((w) => w.slug === profile)?.root_path;
+  const home = ownRoot?.match(/^(\/Users\/[^/]+|\/home\/[^/]+|\/root)(?=\/|$)/)?.[1];
+  const absolute = home && (cwd === "~" || cwd.startsWith("~/")) ? resolve2(home, cwd.slice(2)) : expandPath(cwd);
+  const path = realpathOrSelf(absolute);
+  const roots = workspaces.filter((w) => w.root_path).map((w) => ({ slug: w.slug, root: realpathOrSelf(expandPath(w.root_path)) }));
+  const owner = roots.filter(({ root }) => path === root || path.startsWith(root + sep)).sort((a, b) => b.root.length - a.root.length)[0];
+  if (owner ? owner.slug !== profile : roots.some((r) => r.slug === profile)) {
+    throw new ChannelCwdError(
+      owner ? `Folder "${cwd}" belongs to the "${owner.slug}" workspace.` : `Folder "${cwd}" is outside this workspace's folder.`
+    );
+  }
+  return absolute;
+}
 async function createChannel(input) {
+  input = { ...input, cwd: await assertCwdInWorkspace(getProfile(), input.cwd) };
   const { data, error } = await getSupabaseClient().from("channels").insert({ ...toRow(input), profile: getProfile() }).select().single();
   if (error) throw new Error(error.message);
   const channel = rowToChannel(data);
@@ -547,6 +598,9 @@ async function updateChannelById(id, patch) {
   if (existing?.isDefault && (patch.visibility === "private" || patch.archivedAt || patch.isDefault === false || patch.name !== void 0 && patch.name.trim() !== existing.name)) {
     throw new DefaultChannelError();
   }
+  if (patch.cwd !== void 0) {
+    patch = { ...patch, cwd: await assertCwdInWorkspace(existing?.profile ?? getProfile(), patch.cwd) };
+  }
   const { data, error } = await getSupabaseClient().from("channels").update({ ...toRow(patch), updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", id).select().single();
   if (error) throw new Error(error.message);
   await refreshChannelRegistry();
@@ -1543,9 +1597,9 @@ function isAuthError(text) {
 }
 function authErrorMessage(raw) {
   return `The agent can't sign in to Claude right now (the Host's login expired and could not be refreshed).
-A workspace admin can see how to fix it under Settings \u2192 Agent \u2192 Providers.
+To fix it, a workspace admin can open Settings \u2192 Agent \u2192 Providers and click Sign in next to Claude Code.
 
-Original error: ${raw}`;
+> Original error: ${raw}`;
 }
 function isTransientError(text, apiErrorStatus) {
   if (apiErrorStatus == null) {
@@ -2111,7 +2165,7 @@ var featureFlags = {
   dictation: {
     title: "Dictation",
     description: "A mic button in the message composer that turns speech into text as you talk. Each phrase uses speech-to-text.",
-    stage: "dev"
+    stage: "beta"
   },
   "agent-memory": {
     title: "Agent memory",
@@ -2161,6 +2215,7 @@ async function disableFeatureFlag(workspaceId, flagId) {
 
 // src/store/memory-store.ts
 var MEMORY_TYPES = ["preference", "decision", "fact", "reference"];
+var channelTarget = (channelId) => ({ scope: "channel", channelId });
 var NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var DESCRIPTION_MAX = 200;
 var BODY_MAX = 16e3;
@@ -2184,7 +2239,10 @@ function validateMemoryInput(input) {
 function rowToMemory(row) {
   return {
     id: row["id"],
-    channelId: row["channel_id"],
+    scope: row["scope"] ?? "channel",
+    workspaceId: row["workspace_id"],
+    channelId: row["channel_id"] ?? null,
+    userId: row["user_id"] ?? null,
     name: row["name"],
     description: row["description"],
     type: row["type"],
@@ -2192,23 +2250,40 @@ function rowToMemory(row) {
     sourceThreadId: row["source_thread_id"] ?? null,
     createdBy: row["created_by"],
     createdAt: row["created_at"],
-    updatedAt: row["updated_at"]
+    updatedAt: row["updated_at"],
+    lastUsedAt: row["last_used_at"] ?? null
   };
 }
-async function listChannelMemories(channelId) {
-  const { data, error } = await getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).order("updated_at", { ascending: false });
-  if (error) throw new Error(`listChannelMemories(${channelId}): ${error.message}`);
+function targetRow(target) {
+  switch (target.scope) {
+    case "channel":
+      return { scope: "channel", channel_id: target.channelId };
+    case "workspace":
+      return { scope: "workspace", workspace_id: target.workspaceId };
+    case "user":
+      return { scope: "user", workspace_id: target.workspaceId, user_id: target.userId };
+  }
+}
+function inTarget(query, target) {
+  let q = query;
+  for (const [column, value] of Object.entries(targetRow(target))) q = q.eq(column, value);
+  return q;
+}
+var describeTarget = (t) => t.scope === "channel" ? t.channelId : t.scope === "workspace" ? `workspace ${t.workspaceId}` : `user ${t.userId}`;
+async function listMemories(target) {
+  const { data, error } = await inTarget(getSupabaseClient().from("memories").select("*"), target).order("updated_at", { ascending: false });
+  if (error) throw new Error(`listMemories(${describeTarget(target)}): ${error.message}`);
   return (data ?? []).map(rowToMemory);
 }
-async function getChannelMemory(channelId, name) {
-  const { data, error } = await getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).eq("name", name).maybeSingle();
-  if (error) throw new Error(`getChannelMemory(${channelId}, ${name}): ${error.message}`);
+async function getMemory(target, name) {
+  const { data, error } = await inTarget(getSupabaseClient().from("memories").select("*"), target).eq("name", name).maybeSingle();
+  if (error) throw new Error(`getMemory(${describeTarget(target)}, ${name}): ${error.message}`);
   return data ? rowToMemory(data) : null;
 }
-async function saveChannelMemory(input, actor) {
+async function saveMemory(target, input, actor) {
   validateMemoryInput(input);
   const supabase = getSupabaseClient();
-  const existing = await getChannelMemory(input.channelId, input.name);
+  const existing = await getMemory(target, input.name);
   const fields = {
     description: input.description.trim(),
     type: input.type,
@@ -2219,9 +2294,9 @@ async function saveChannelMemory(input, actor) {
   if (existing && sameContent(existing, fields)) {
     return { memory: existing, created: false, changed: false };
   }
-  const { data, error } = existing ? await supabase.from("memories").update({ ...fields, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", existing.id).select("*").single() : await supabase.from("memories").insert({ ...fields, scope: "channel", channel_id: input.channelId, name: input.name }).select("*").single();
+  const { data, error } = existing ? await supabase.from("memories").update({ ...fields, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", existing.id).select("*").single() : await supabase.from("memories").insert({ ...fields, ...targetRow(target), name: input.name }).select("*").single();
   if (error)
-    throw new Error(`saveChannelMemory(${input.channelId}, ${input.name}): ${error.message}`);
+    throw new Error(`saveMemory(${describeTarget(target)}, ${input.name}): ${error.message}`);
   const memory = rowToMemory(data);
   await logMemoryEvent({
     memory,
@@ -2233,12 +2308,12 @@ async function saveChannelMemory(input, actor) {
   });
   return { memory, created: !existing, changed: true };
 }
-async function updateChannelMemory(channelId, memoryId, patch, actor) {
-  const existing = (await listChannelMemories(channelId)).find((m) => m.id === memoryId);
+async function updateMemory(target, memoryId, patch, actor) {
+  const existing = (await listMemories(target)).find((m) => m.id === memoryId);
   if (!existing) return null;
-  const { memory } = await saveChannelMemory(
+  const { memory } = await saveMemory(
+    target,
     {
-      channelId,
       name: existing.name,
       description: patch.description ?? existing.description,
       type: patch.type ?? existing.type,
@@ -2249,20 +2324,28 @@ async function updateChannelMemory(channelId, memoryId, patch, actor) {
   );
   return memory;
 }
-async function searchChannelMemories(channelId, query) {
+async function searchMemories(target, query) {
   const words = query.replaceAll(/[,()*%\\]/g, " ").split(/\s+/).filter(Boolean);
   if (!words.length) return [];
-  let request = getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId);
+  let request = inTarget(getSupabaseClient().from("memories").select("*"), target);
   for (const word of words) {
     request = request.or(`name.ilike.*${word}*,description.ilike.*${word}*,body.ilike.*${word}*`);
   }
   const { data, error } = await request.order("updated_at", { ascending: false }).limit(20);
-  if (error) throw new Error(`searchChannelMemories(${channelId}): ${error.message}`);
+  if (error) throw new Error(`searchMemories(${describeTarget(target)}): ${error.message}`);
   return (data ?? []).map(rowToMemory);
 }
-async function deleteChannelMemory(channelId, idOrName, actor, threadId) {
-  const { data, error } = await getSupabaseClient().from("memories").delete().eq("scope", "channel").eq("channel_id", channelId).eq(isUuid(idOrName) ? "id" : "name", idOrName).select("*");
-  if (error) throw new Error(`deleteChannelMemory(${channelId}, ${idOrName}): ${error.message}`);
+var USED_GRANULARITY_MS = 24 * 60 * 6e4;
+async function markMemoryUsed(memory) {
+  const cutoff = new Date(Date.now() - USED_GRANULARITY_MS).toISOString();
+  if (memory.lastUsedAt && memory.lastUsedAt > cutoff) return;
+  const { error } = await getSupabaseClient().from("memories").update({ last_used_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", memory.id).or(`last_used_at.is.null,last_used_at.lt.${cutoff}`);
+  if (error) console.error(`[memory] markMemoryUsed(${memory.id}) failed:`, error.message);
+}
+async function deleteMemory(target, idOrName, actor, threadId) {
+  const { data, error } = await inTarget(getSupabaseClient().from("memories").delete(), target).eq(isUuid(idOrName) ? "id" : "name", idOrName).select("*");
+  if (error)
+    throw new Error(`deleteMemory(${describeTarget(target)}, ${idOrName}): ${error.message}`);
   const deleted = (data ?? []).map(rowToMemory);
   for (const memory of deleted) {
     await logMemoryEvent({
@@ -2276,6 +2359,25 @@ async function deleteChannelMemory(channelId, idOrName, actor, threadId) {
   }
   return deleted.length > 0;
 }
+async function promoteChannelMemory(channelId, memoryId) {
+  const supabase = getSupabaseClient();
+  const existing = (await listChannelMemories(channelId)).find((m) => m.id === memoryId);
+  if (!existing) return { ok: false, reason: "not-found" };
+  if (await getMemory({ scope: "workspace", workspaceId: existing.workspaceId }, existing.name)) {
+    return { ok: false, reason: "name-taken" };
+  }
+  const { data, error } = await supabase.from("memories").update({ scope: "workspace", channel_id: null, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", memoryId).eq("scope", "channel").select("*").maybeSingle();
+  if (error) throw new Error(`promoteChannelMemory(${memoryId}): ${error.message}`);
+  if (!data) return { ok: false, reason: "not-found" };
+  const memory = rowToMemory(data);
+  await logMemoryEvent({ memory, action: "create", before: null, after: snapshot(memory), actor: "user", threadId: null });
+  return { ok: true, memory };
+}
+var listChannelMemories = (channelId) => listMemories(channelTarget(channelId));
+var getChannelMemory = (channelId, name) => getMemory(channelTarget(channelId), name);
+var saveChannelMemory = ({ channelId, ...fields }, actor) => saveMemory(channelTarget(channelId), fields, actor);
+var updateChannelMemory = (channelId, memoryId, patch, actor) => updateMemory(channelTarget(channelId), memoryId, patch, actor);
+var deleteChannelMemory = (channelId, idOrName, actor, threadId) => deleteMemory(channelTarget(channelId), idOrName, actor, threadId);
 function unchangedSince(current, after) {
   return current && after ? sameContent(current, after) : !current && !after;
 }
@@ -2294,6 +2396,10 @@ function sameContent(m, other) {
 async function logMemoryEvent(e) {
   const { error } = await getSupabaseClient().from("memory_events").insert({
     channel_id: e.memory.channelId,
+    // A channel event's workspace comes from its channel (0100 trigger).
+    ...e.memory.channelId ? {} : { workspace_id: e.memory.workspaceId },
+    scope: e.memory.scope,
+    user_id: e.memory.userId,
     memory_id: e.action === "delete" ? null : e.memory.id,
     thread_id: e.threadId,
     name: e.memory.name,
@@ -2319,15 +2425,18 @@ function rowToEvent(row) {
     undoneAt: row["undone_at"] ?? null
   };
 }
-async function listThreadMemoryEvents(channelId, threadId) {
+async function listMemoryEvents(channelId, filter = {}) {
   const supabase = getSupabaseClient();
-  const { data, error } = await supabase.from("memory_events").select("*").eq("channel_id", channelId).eq("thread_id", threadId).order("created_at", { ascending: false }).limit(50);
-  if (error) throw new Error(`listThreadMemoryEvents(${threadId}): ${error.message}`);
+  let query = supabase.from("memory_events").select("*").eq("channel_id", channelId);
+  if (filter.threadId) query = query.eq("thread_id", filter.threadId);
+  if (filter.actor) query = query.eq("actor", filter.actor);
+  const { data, error } = await query.order("created_at", { ascending: false }).limit(filter.limit ?? 50);
+  if (error) throw new Error(`listMemoryEvents(${channelId}): ${error.message}`);
   const events = (data ?? []).map(rowToEvent);
   if (!events.length) return [];
   const names = [...new Set(events.map((e) => e.name))];
   const live = await supabase.from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).in("name", names);
-  if (live.error) throw new Error(`listThreadMemoryEvents(${threadId}): ${live.error.message}`);
+  if (live.error) throw new Error(`listMemoryEvents(${channelId}): ${live.error.message}`);
   const byName = new Map(
     (live.data ?? []).map((r) => [
       r["name"],
@@ -2344,6 +2453,7 @@ async function listThreadMemoryEvents(channelId, threadId) {
     };
   });
 }
+var listThreadMemoryEvents = (channelId, threadId) => listMemoryEvents(channelId, { threadId, actor: "agent" });
 async function undoMemoryEvent(channelId, eventId) {
   const supabase = getSupabaseClient();
   const { data, error } = await supabase.from("memory_events").select("*").eq("id", eventId).eq("channel_id", channelId).maybeSingle();
@@ -2374,21 +2484,29 @@ async function undoMemoryEvent(channelId, eventId) {
 function isUuid(value) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
-function formatMemoryPrompt(channelId, memories) {
-  const lines = [];
+function formatMemoryPrompt(channelId, memories, extras = {}) {
   let used = 0;
-  let omitted = 0;
-  for (const m of memories) {
-    const line = `- \`${m.name}\` (${m.type}): ${m.description}`;
-    if (used + line.length > MEMORY_INDEX_MAX_CHARS) {
-      omitted++;
-      continue;
+  const indexOf = (list, searchHint) => {
+    const lines = [];
+    let omitted = 0;
+    for (const m of list) {
+      const line = `- \`${m.name}\` (${m.type}): ${m.description}`;
+      if (used + line.length > MEMORY_INDEX_MAX_CHARS) {
+        omitted++;
+        continue;
+      }
+      lines.push(line);
+      used += line.length + 1;
     }
-    lines.push(line);
-    used += line.length + 1;
-  }
-  const index = lines.length ? lines.join("\n") + (omitted ? `
-- (${omitted} older memories not listed; find them with \`memory search\`)` : "") : "(none yet)";
+    if (!lines.length && !omitted) return "(none yet)";
+    return lines.join("\n") + (omitted ? `
+- (${omitted} older memories not listed; find them with \`${searchHint}\`)` : "");
+  };
+  const user = extras.user;
+  const userFlags2 = user ? `--scope user --user ${user.userId}` : "";
+  const userIndex = user ? indexOf(user.memories, `memory search --channel ${channelId} ${userFlags2}`) : "";
+  const channelIndex = indexOf(memories, "memory search");
+  const workspaceIndex = extras.workspace?.length ? indexOf(extras.workspace, `memory search --channel ${channelId} --scope workspace`) : "";
   return [
     `## Channel memory`,
     ``,
@@ -2400,26 +2518,22 @@ function formatMemoryPrompt(channelId, memories) {
     `- Delete one that turned out wrong: \`flyspace memory delete --channel ${channelId} <name> [--thread <thread-id>]\``,
     ``,
     `Save when someone asks you to remember something, corrects you, or a decision is made that later threads will need. Save what is not derivable from the code, git history or docs: decisions and why, preferences, corrections, where external things live. Do not save one-off details of this conversation. Check the index first and update an existing memory rather than adding a near-duplicate. Write memories in English. Pass \`--thread\` with the thread id from the \`[context: ...]\` header, so the thread shows what changed and it can be undone there.`,
+    ...user ? [
+      ``,
+      `A personal preference of @${user.handle} (language, tone, reply length, time zone, how they like to work) belongs in their personal memory instead, which only their own turns see: add \`${userFlags2}\` to the same commands. Never save someone else's preferences there, and never put project knowledge there.`
+    ] : [],
+    ...workspaceIndex ? [
+      ``,
+      `Workspace memories below apply to every channel. They are read-only to you: read one with \`--scope workspace\` on \`get\`; a Workspace Admin manages them.`
+    ] : [],
     ``,
+    ...user ? [`Personal memory of @${user.handle}:`, userIndex, ``] : [],
     `Index:`,
-    index
+    channelIndex,
+    ...workspaceIndex ? [``, `Workspace memory:`, workspaceIndex] : []
   ].join("\n");
 }
 
-// src/store/memory-context.ts
-async function loadAgentMemory(profile, channelId, opts = {}) {
-  const enabled = await listEnabledFeatureFlagsBySlug(profile).then((ids) => resolveFeatureFlags(ids, false)["agent-memory"]).catch((err) => {
-    console.error("[memory] feature flag lookup failed:", err.message);
-    return false;
-  });
-  if (!enabled || opts.readable === false || !channelId || !isUuid(channelId)) return { enabled };
-  const memoryPrompt = await listChannelMemories(channelId).then((memories) => formatMemoryPrompt(channelId, memories)).catch((err) => {
-    console.error("[memory] memory lookup failed:", err.message);
-    return void 0;
-  });
-  return memoryPrompt ? { enabled, memoryPrompt } : { enabled };
-}
-
 // src/store/workspace-store.ts
 function rowToMembership(row) {
   return {
@@ -2431,7 +2545,8 @@ function rowToMembership(row) {
     role: row["role"],
     status: row["status"],
     invitedAt: row["invited_at"],
-    acceptedAt: row["accepted_at"] ?? null
+    acceptedAt: row["accepted_at"] ?? null,
+    memoryAutoPaused: row["memory_auto_paused"] === true
   };
 }
 var WORKSPACE_CACHE_TTL_MS = 6e4;
@@ -2587,6 +2702,10 @@ async function listMembershipsByEmail(email) {
   if (error) throw new Error(`listMembershipsByEmail: ${error.message}`);
   return (data ?? []).map(rowToMembership);
 }
+async function setMemoryAutoPaused(workspaceId, userId, paused) {
+  const { error } = await getSupabaseClient().from("memberships").update({ memory_auto_paused: paused }).eq("workspace_id", workspaceId).eq("user_id", userId);
+  if (error) throw new Error(`setMemoryAutoPaused(${workspaceId}): ${error.message}`);
+}
 async function listMemberships(workspaceId) {
   const { data, error } = await getSupabaseClient().from("memberships").select("*").eq("workspace_id", workspaceId).order("invited_at", { ascending: true });
   if (error) throw new Error(`listMemberships(${workspaceId}): ${error.message}`);
@@ -2710,6 +2829,37 @@ async function setAgentPaused(workspaceId, paused) {
   if (error) throw new Error(`setAgentPaused(${workspaceId}): ${error.message}`);
 }
 
+// src/store/memory-context.ts
+async function loadAgentMemory(profile, channelId, opts = {}) {
+  const enabled = await listEnabledFeatureFlagsBySlug(profile).then((ids) => resolveFeatureFlags(ids, false)["agent-memory"]).catch((err) => {
+    console.error("[memory] feature flag lookup failed:", err.message);
+    return false;
+  });
+  if (!enabled || opts.readable === false || !channelId || !isUuid(channelId)) return { enabled };
+  const memoryPrompt = await buildPrompt(profile, channelId, opts).catch((err) => {
+    console.error("[memory] memory lookup failed:", err.message);
+    return void 0;
+  });
+  return memoryPrompt ? { enabled, memoryPrompt } : { enabled };
+}
+async function buildPrompt(profile, channelId, opts) {
+  const workspace = await getWorkspaceBySlug(profile);
+  const handle = opts.senderHandle?.toLowerCase();
+  const sender = workspace && handle ? (await listMemberships(workspace.id)).find(
+    (m) => m.userId && m.handle.toLowerCase() === handle
+  ) : void 0;
+  const [channel, shared, own] = await Promise.all([
+    listMemories({ scope: "channel", channelId }),
+    workspace ? listMemories({ scope: "workspace", workspaceId: workspace.id }) : [],
+    workspace && sender ? listMemories({ scope: "user", workspaceId: workspace.id, userId: sender.userId }) : []
+  ]);
+  const extras = {
+    workspace: shared,
+    ...sender ? { user: { userId: sender.userId, handle: sender.handle, memories: own } } : {}
+  };
+  return formatMemoryPrompt(channelId, channel, extras);
+}
+
 // src/dashboard/settings.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
 import { dirname, resolve as resolve5 } from "path";
@@ -4427,6 +4577,11 @@ import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   jobs = /* @__PURE__ */ new Map();
   caughtUp = /* @__PURE__ */ new Set();
+  // A run is only recorded when it finishes, so while one is in flight the
+  // store still shows the previous tick. Without this guard, a registry
+  // reload during a long run re-registers the schedule and catchup starts a
+  // second, overlapping copy (sah-budget-fetch ran twice a day this way).
+  running = /* @__PURE__ */ new Set();
   store;
   constructor(store) {
     this.store = store;
@@ -4478,6 +4633,11 @@ var Scheduler = class {
     wrappedRun();
   }
   async runAndRecord(name, runFn) {
+    if (this.running.has(name)) {
+      console.log(`[scheduler] ${name} is still running, skipping overlapping run`);
+      return;
+    }
+    this.running.add(name);
     const startedAt = /* @__PURE__ */ new Date();
     const elapsed = () => Date.now() - startedAt.getTime();
     try {
@@ -4486,6 +4646,8 @@ var Scheduler = class {
     } catch (err) {
       console.error(`[scheduler] Error in ${name}:`, err);
       this.store?.recordRun(name, "error", startedAt, elapsed());
+    } finally {
+      this.running.delete(name);
     }
   }
   unregister(name) {
@@ -8718,6 +8880,7 @@ export {
   warnOnBrokenChannelCwds,
   resolveCwd,
   resolveChannelPrompt,
+  ChannelCwdError,
   createChannel,
   DefaultChannelError,
   updateChannelById,
@@ -8745,6 +8908,7 @@ export {
   modelLabel,
   usageLimitedUntil,
   usageLimitedModels,
+  clearClaudeAuthFailed,
   claudeAuthFailed,
   buildSystemPrompt,
   docsAccessPromptNote,
@@ -8761,16 +8925,23 @@ export {
   MEMORY_TYPES,
   isMemoryType,
   validateMemoryInput,
+  listMemories,
+  getMemory,
+  saveMemory,
+  updateMemory,
+  searchMemories,
+  markMemoryUsed,
+  deleteMemory,
+  promoteChannelMemory,
   listChannelMemories,
   getChannelMemory,
   saveChannelMemory,
   updateChannelMemory,
-  searchChannelMemories,
   deleteChannelMemory,
+  listMemoryEvents,
   listThreadMemoryEvents,
   undoMemoryEvent,
   isUuid,
-  loadAgentMemory,
   getWorkspaceBySlug,
   getWorkspaceById,
   listWorkspaces,
@@ -8790,6 +8961,7 @@ export {
   getMembershipByEmail,
   getMembershipByUserId,
   listMembershipsByEmail,
+  setMemoryAutoPaused,
   listMemberships,
   createMembership,
   HANDLE_PATTERN,
@@ -8806,6 +8978,7 @@ export {
   setAllowGuestAccess,
   getAgentPaused,
   setAgentPaused,
+  loadAgentMemory,
   DEFAULT_TITLE_RULES,
   extractCategories,
   buildAutoTitle,