flyspace-cli 0.1.14 → 0.1.16

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

@@ -163,9 +163,9 @@ async function refreshAutomationRegistry() {
     return;
   }
   const next = data ?? [];
-  const snapshot = JSON.stringify(next, (key, value) => key === "updated_at" ? void 0 : value);
-  if (snapshot === lastSnapshot) return;
-  lastSnapshot = snapshot;
+  const snapshot2 = JSON.stringify(next, (key, value) => key === "updated_at" ? void 0 : value);
+  if (snapshot2 === lastSnapshot) return;
+  lastSnapshot = snapshot2;
   rows = next;
   for (const cb of changeListeners) {
     try {
@@ -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,18 +369,21 @@ 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);
     return;
   }
   const rows2 = data ?? [];
-  const snapshot = JSON.stringify(
+  const snapshot2 = JSON.stringify(
     rows2,
     (key, value) => key === "updated_at" || key === "created_at" ? void 0 : value
   );
-  if (snapshot === lastSnapshot2) return;
-  lastSnapshot2 = snapshot;
+  if (snapshot2 === lastSnapshot2) return;
+  lastSnapshot2 = snapshot2;
   indexRegistry(rows2.map(rowToChannel));
   for (const cb of changeListeners2) {
     try {
@@ -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) {
@@ -2086,6 +2140,400 @@ Fix the channel's working directory in its settings (or recreate the directory),
   }
 }
 
+// src/feature-flags.ts
+var featureFlags = {
+  "ai-cost": {
+    title: "AI cost",
+    description: "Shows admins what the agent has spent: a Cost section in a channel's AI overview and a per-thread cost in the thread menu. Estimated at API list rates, so on a Claude subscription it will not match your bill.",
+    stage: "beta"
+  },
+  "read-aloud": {
+    title: "Read aloud",
+    description: "Listen to messages, threads and docs as audio. Still rough in places, and each playback uses text-to-speech.",
+    stage: "beta"
+  },
+  excalidraw: {
+    title: "Excalidraw",
+    description: "Create and edit whiteboard drawings (.excalidraw files) in the Docs pane. Existing drawings stay viewable with this off.",
+    stage: "beta"
+  },
+  sandbox: {
+    title: "Sandbox runtime",
+    description: "Run a channel agent in an isolated sandbox without Docker. Channels already on Sandbox keep working with this off.",
+    stage: "beta"
+  },
+  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: "beta"
+  },
+  "agent-memory": {
+    title: "Agent memory",
+    description: "Channel memory the agent reads every turn, saved by the agent and picked up from idle threads, with a Memory tab and an undo chip. While on, Claude's built-in auto memory is switched off so the two can be compared; turning this off keeps every memory.",
+    stage: "beta"
+  }
+};
+var featureFlagIds = Object.keys(featureFlags);
+function isFeatureFlagId(id) {
+  return Object.hasOwn(featureFlags, id);
+}
+function isFeatureVisible(stage, devHost) {
+  return stage === "beta" || stage === "dev" && devHost;
+}
+function resolveFeatureFlags(enabledIds, devHost) {
+  const enabled = new Set(enabledIds);
+  const out = {};
+  for (const id of featureFlagIds) {
+    const stage = featureFlags[id].stage;
+    out[id] = stage === "ga" || isFeatureVisible(stage, devHost) && enabled.has(id);
+  }
+  return out;
+}
+
+// src/store/feature-flag-store.ts
+async function listEnabledFeatureFlags(workspaceId) {
+  const { data, error } = await getSupabaseClient().from("feature_flags").select("flag_id").eq("workspace_id", workspaceId);
+  if (error) throw new Error(`listEnabledFeatureFlags(${workspaceId}): ${error.message}`);
+  return (data ?? []).map((r) => r.flag_id);
+}
+async function listEnabledFeatureFlagsBySlug(slug) {
+  const { data, error } = await getSupabaseClient().from("workspaces").select("id").eq("slug", slug).maybeSingle();
+  if (error) throw new Error(`listEnabledFeatureFlagsBySlug(${slug}): ${error.message}`);
+  return data ? listEnabledFeatureFlags(data.id) : [];
+}
+async function enableFeatureFlag(workspaceId, flagId, userId) {
+  const { error } = await getSupabaseClient().from("feature_flags").upsert(
+    { workspace_id: workspaceId, flag_id: flagId, enabled_by: userId },
+    { onConflict: "workspace_id,flag_id" }
+  );
+  if (error) throw new Error(`enableFeatureFlag(${workspaceId}, ${flagId}): ${error.message}`);
+}
+async function disableFeatureFlag(workspaceId, flagId) {
+  const { error } = await getSupabaseClient().from("feature_flags").delete().eq("workspace_id", workspaceId).eq("flag_id", flagId);
+  if (error) throw new Error(`disableFeatureFlag(${workspaceId}, ${flagId}): ${error.message}`);
+}
+
+// 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;
+var MEMORY_INDEX_MAX_CHARS = 8e3;
+function isMemoryType(value) {
+  return MEMORY_TYPES.includes(value);
+}
+function validateMemoryInput(input) {
+  if (!NAME_RE.test(input.name))
+    throw new Error("name must be a kebab-case slug, e.g. deploy-flow");
+  if (!isMemoryType(input.type)) throw new Error(`type must be one of ${MEMORY_TYPES.join(", ")}`);
+  const description = input.description.trim();
+  if (!description || description.includes("\n") || description.length > DESCRIPTION_MAX) {
+    throw new Error(`description must be one line of at most ${DESCRIPTION_MAX} characters`);
+  }
+  const body = input.body.trim();
+  if (!body || body.length > BODY_MAX) {
+    throw new Error(`body must be 1 to ${BODY_MAX} characters`);
+  }
+}
+function rowToMemory(row) {
+  return {
+    id: row["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"],
+    body: row["body"],
+    sourceThreadId: row["source_thread_id"] ?? null,
+    createdBy: row["created_by"],
+    createdAt: row["created_at"],
+    updatedAt: row["updated_at"],
+    lastUsedAt: row["last_used_at"] ?? null
+  };
+}
+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 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 saveMemory(target, input, actor) {
+  validateMemoryInput(input);
+  const supabase = getSupabaseClient();
+  const existing = await getMemory(target, input.name);
+  const fields = {
+    description: input.description.trim(),
+    type: input.type,
+    body: input.body.trim(),
+    source_thread_id: input.sourceThreadId ?? existing?.sourceThreadId ?? null,
+    created_by: input.createdBy
+  };
+  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, ...targetRow(target), name: input.name }).select("*").single();
+  if (error)
+    throw new Error(`saveMemory(${describeTarget(target)}, ${input.name}): ${error.message}`);
+  const memory = rowToMemory(data);
+  await logMemoryEvent({
+    memory,
+    action: existing ? "update" : "create",
+    before: existing ? snapshot(existing) : null,
+    after: snapshot(memory),
+    actor,
+    threadId: input.sourceThreadId ?? null
+  });
+  return { memory, created: !existing, changed: true };
+}
+async function updateMemory(target, memoryId, patch, actor) {
+  const existing = (await listMemories(target)).find((m) => m.id === memoryId);
+  if (!existing) return null;
+  const { memory } = await saveMemory(
+    target,
+    {
+      name: existing.name,
+      description: patch.description ?? existing.description,
+      type: patch.type ?? existing.type,
+      body: patch.body ?? existing.body,
+      createdBy: existing.createdBy
+    },
+    actor
+  );
+  return memory;
+}
+async function searchMemories(target, query) {
+  const words = query.replaceAll(/[,()*%\\]/g, " ").split(/\s+/).filter(Boolean);
+  if (!words.length) return [];
+  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(`searchMemories(${describeTarget(target)}): ${error.message}`);
+  return (data ?? []).map(rowToMemory);
+}
+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({
+      memory,
+      action: "delete",
+      before: snapshot(memory),
+      after: null,
+      actor,
+      threadId: threadId ?? null
+    });
+  }
+  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;
+}
+function snapshot(m) {
+  return {
+    description: m.description,
+    type: m.type,
+    body: m.body,
+    sourceThreadId: m.sourceThreadId,
+    createdBy: m.createdBy
+  };
+}
+function sameContent(m, other) {
+  return m.description === other.description && m.type === other.type && m.body === other.body;
+}
+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,
+    action: e.action,
+    before: e.before,
+    after: e.after,
+    actor: e.actor
+  });
+  if (error) console.error(`[memory] event log failed for ${e.memory.name}:`, error.message);
+}
+function rowToEvent(row) {
+  return {
+    id: row["id"],
+    channelId: row["channel_id"],
+    memoryId: row["memory_id"] ?? null,
+    threadId: row["thread_id"] ?? null,
+    name: row["name"],
+    action: row["action"],
+    before: row["before"] ?? null,
+    after: row["after"] ?? null,
+    actor: row["actor"],
+    createdAt: row["created_at"],
+    undoneAt: row["undone_at"] ?? null
+  };
+}
+async function listMemoryEvents(channelId, filter = {}) {
+  const supabase = getSupabaseClient();
+  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(`listMemoryEvents(${channelId}): ${live.error.message}`);
+  const byName = new Map(
+    (live.data ?? []).map((r) => [
+      r["name"],
+      rowToMemory(r)
+    ])
+  );
+  return events.map((e) => {
+    const current = byName.get(e.name) ?? null;
+    const unchanged = unchangedSince(current, e.after);
+    return {
+      ...e,
+      currentState: unchanged ? "current" : current ? "changed" : "deleted",
+      undoable: !e.undoneAt && unchanged
+    };
+  });
+}
+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();
+  if (error) throw new Error(`undoMemoryEvent(${eventId}): ${error.message}`);
+  if (!data) return "not-found";
+  const event = rowToEvent(data);
+  if (event.undoneAt) return "already-undone";
+  const current = await getChannelMemory(channelId, event.name);
+  if (!unchangedSince(current, event.after)) return "conflict";
+  const claimed = await supabase.from("memory_events").update({ undone_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", eventId).is("undone_at", null).select("id");
+  if (claimed.error) throw new Error(`undoMemoryEvent(${eventId}): ${claimed.error.message}`);
+  if (!(claimed.data ?? []).length) return "already-undone";
+  const before = event.before;
+  const restore = before ? {
+    description: before.description,
+    type: before.type,
+    body: before.body,
+    source_thread_id: before.sourceThreadId,
+    created_by: before.createdBy
+  } : null;
+  const { error: writeError } = !restore ? await supabase.from("memories").delete().eq("id", current.id) : current ? await supabase.from("memories").update({ ...restore, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", current.id) : await supabase.from("memories").insert({ ...restore, scope: "channel", channel_id: channelId, name: event.name });
+  if (writeError) {
+    await supabase.from("memory_events").update({ undone_at: null }).eq("id", eventId);
+    throw new Error(`undoMemoryEvent(${eventId}): ${writeError.message}`);
+  }
+  return "undone";
+}
+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, extras = {}) {
+  let used = 0;
+  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;
+    }
+    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`,
+    ``,
+    `This channel has a persistent memory shared by every thread in it and by every agent runner. Use it instead of any built-in memory directory of your own CLI.`,
+    ``,
+    `- Read a memory: \`flyspace memory get --channel ${channelId} <name>\``,
+    `- Search: \`flyspace memory search --channel ${channelId} <words>\``,
+    `- Save or overwrite: \`flyspace memory save --channel ${channelId} --name <kebab-slug> --type <${MEMORY_TYPES.join("|")}> --description "<one line>" --body "<text>" [--thread <thread-id>]\``,
+    `- 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:`,
+    channelIndex,
+    ...workspaceIndex ? [``, `Workspace memory:`, workspaceIndex] : []
+  ].join("\n");
+}
+
 // src/store/workspace-store.ts
 function rowToMembership(row) {
   return {
@@ -2097,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;
@@ -2163,6 +2612,7 @@ async function deleteWorkspace(workspace) {
 }
 async function setWorkspaceStripeSubscription(workspaceId, fields) {
   const { error } = await getSupabaseClient().from("workspaces").update({
+    plan: fields.plan,
     stripe_customer_id: fields.stripeCustomerId,
     stripe_subscription_id: fields.stripeSubscriptionId,
     plan_status: fields.planStatus
@@ -2198,11 +2648,12 @@ async function getWorkspaceByStripeCustomerId(stripeCustomerId) {
   return data;
 }
 async function getWorkspaceBilling(workspaceId) {
-  const { data, error } = await getSupabaseClient().from("workspaces").select("plan_status, stripe_customer_id, stripe_subscription_id").eq("id", workspaceId).maybeSingle();
+  const { data, error } = await getSupabaseClient().from("workspaces").select("plan, plan_status, stripe_customer_id, stripe_subscription_id").eq("id", workspaceId).maybeSingle();
   if (error) throw new Error(`getWorkspaceBilling(${workspaceId}): ${error.message}`);
   const row = data ?? {};
   return {
     planStatus: row["plan_status"] ?? null,
+    plan: row["plan"] ?? null,
     stripeCustomerId: row["stripe_customer_id"] ?? null,
     stripeSubscriptionId: row["stripe_subscription_id"] ?? null
   };
@@ -2251,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}`);
@@ -2374,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";
@@ -3739,17 +4225,21 @@ async function runAutomation(opts) {
 
 `;
   try {
+    const memory = await loadAgentMemory(getProfile(), channel && findChannel(channel)?.id);
     const useCodex = (explicitModel ? runnerForModel(explicitModel) === "codex" : runnerForModel(loadDashboardSettings().agent) === "codex") && !requiresClaudeAutomationRunner(prompt);
     const response = useCodex ? await askCodex(automationPrefix + prompt, cwd, {
       ...explicitModel && runnerForModel(explicitModel) === "codex" ? { model: explicitModel } : codexModel?.trim() ? { model: codexModel.trim() } : {},
       // Same reason as the interactive paths: no --append-system-prompt on
       // Codex, so the persona and channel instructions go in the prompt.
-      systemPrompt: buildSystemPrompt(
-        botName,
-        void 0,
-        resolveChannelPrompt(channel),
-        resolveSelectedOutputStyle(claudeConfigDir)?.body
-      ),
+      systemPrompt: [
+        buildSystemPrompt(
+          botName,
+          void 0,
+          resolveChannelPrompt(channel),
+          resolveSelectedOutputStyle(claudeConfigDir)?.body
+        ),
+        memory.memoryPrompt
+      ].filter(Boolean).join("\n\n"),
       // Same attribution as the Claude branch below — no userId, the
       // schedule's name is the label.
       usageContext: { source: "automation", channelId: channel, label: name }
@@ -3763,6 +4253,8 @@ async function runAutomation(opts) {
         model,
         maxBudgetUsd,
         channelPrompt: resolveChannelPrompt(channel),
+        ...memory.memoryPrompt ? { memoryPrompt: memory.memoryPrompt } : {},
+        ...memory.enabled ? { disableAutoMemory: true } : {},
         // No userId: nobody triggered this. The schedule's name is the
         // label, which is what makes "which automation is burning tokens"
         // answerable without joining anything.
@@ -4085,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;
@@ -4136,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 {
@@ -4144,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) {
@@ -8376,6 +8880,7 @@ export {
   warnOnBrokenChannelCwds,
   resolveCwd,
   resolveChannelPrompt,
+  ChannelCwdError,
   createChannel,
   DefaultChannelError,
   updateChannelById,
@@ -8403,11 +8908,40 @@ export {
   modelLabel,
   usageLimitedUntil,
   usageLimitedModels,
+  clearClaudeAuthFailed,
   claudeAuthFailed,
   buildSystemPrompt,
   docsAccessPromptNote,
   pinnedClaudeConfigDir,
   askClaude,
+  featureFlags,
+  featureFlagIds,
+  isFeatureFlagId,
+  isFeatureVisible,
+  resolveFeatureFlags,
+  listEnabledFeatureFlags,
+  enableFeatureFlag,
+  disableFeatureFlag,
+  MEMORY_TYPES,
+  isMemoryType,
+  validateMemoryInput,
+  listMemories,
+  getMemory,
+  saveMemory,
+  updateMemory,
+  searchMemories,
+  markMemoryUsed,
+  deleteMemory,
+  promoteChannelMemory,
+  listChannelMemories,
+  getChannelMemory,
+  saveChannelMemory,
+  updateChannelMemory,
+  deleteChannelMemory,
+  listMemoryEvents,
+  listThreadMemoryEvents,
+  undoMemoryEvent,
+  isUuid,
   getWorkspaceBySlug,
   getWorkspaceById,
   listWorkspaces,
@@ -8427,6 +8961,7 @@ export {
   getMembershipByEmail,
   getMembershipByUserId,
   listMembershipsByEmail,
+  setMemoryAutoPaused,
   listMemberships,
   createMembership,
   HANDLE_PATTERN,
@@ -8443,6 +8978,7 @@ export {
   setAllowGuestAccess,
   getAgentPaused,
   setAgentPaused,
+  loadAgentMemory,
   DEFAULT_TITLE_RULES,
   extractCategories,
   buildAutoTitle,