@@ -224,8 +254,12 @@ export function PrivateChannels({
)}
{confirming && (
setConfirming(undefined)}
actions={
<>
@@ -234,10 +268,10 @@ export function PrivateChannels({
variant="prominent"
onClick={() => {
setConfirming(undefined);
- void add(confirming);
+ void (former ? remove : add)(confirming);
}}
>
- Add to all
+ {former ? "Remove from all" : "Add to all"}
}
diff --git a/src/bundled/bestie/README.md b/src/bundled/bestie/README.md
index 61977b455..aca9cb2a4 100644
--- a/src/bundled/bestie/README.md
+++ b/src/bundled/bestie/README.md
@@ -34,9 +34,8 @@ Bestie, each with **Remove**. **Add to a channel** (**Choose…**) and **Add to
all my private channels** add it to the private channels you are in, most
recently active first; each channel's members see that you added it. Each
action has a row of its own, so in a narrow panel its button wraps under it.
-Public channels
-need nothing: agents read them already. Adding Bestie to new channels you
-create is not set up yet.
+Public channels need nothing: agents read them already. Adding Bestie to new
+channels you create is not set up yet.
**Check-ins → Every hour** needs Remembers you, and turning memory off turns it
off too. On adds the `buzz:bestie/checkin.hourly` Hourly upkeep section to the
@@ -50,6 +49,15 @@ every agent. While the timer can't run, the row says it is paused. After a
sleep it runs once, not once for each missed hour. Each
check-in is a feature in `features.ts`, so another kind is one more entry.
+**Changing your Bestie.** Only your Bestie checks in: whenever the saved Bestie
+is known, on this device or synced from another, any other agent here has its
+check-ins removed. Its memory section and channels stay. An agent this device
+makes Bestie starts with Remembers you on; a choice synced from elsewhere
+changes nothing, so memory turned off stays off. A former Bestie keeps a
+**Former Bestie** tab while it has a Bestie section, or, if this device saw it
+as Bestie, while it is in one of your private channels. The tab has the same
+switches, **Remove from all** for its channels, and **Make my Bestie again**.
+
---
## Changing Bestie's instructions
diff --git a/src/bundled/bestie/features.test.ts b/src/bundled/bestie/features.test.ts
index 55263db3e..0a7135dbe 100644
--- a/src/bundled/bestie/features.test.ts
+++ b/src/bundled/bestie/features.test.ts
@@ -1,6 +1,6 @@
import { expect, it } from "vitest";
import {
- type Feature,
+ checkinHourly,
featureState,
hasFeature,
memory,
@@ -8,8 +8,6 @@ import {
withFeature,
} from "./features";
-// Another feature, whose markers are not memory's.
-const another: Feature = { ...memory, id: "other", text: "other" };
const OPEN = "";
const CLOSE = "";
@@ -95,7 +93,9 @@ it("shows a section whose markers were edited, and adds no second one", () => {
}
expect(featureState("Be brief.", memory)).toBe("off");
// Another feature's markers are not this one's.
- expect(featureState(withFeature("", another, true), memory)).toBe("off");
+ expect(featureState(withFeature("", checkinHourly, true), memory)).toBe(
+ "off",
+ );
});
it("restores an edited section only where its markers show it was", () => {
@@ -126,7 +126,7 @@ it("restores an edited section only where its markers show it was", () => {
memory,
),
).toBeUndefined();
- const other = withFeature("", another, true);
+ const other = withFeature("", checkinHourly, true);
expect(
restoredFeature(
`${OPEN.replace(" v1", "")}\nrules\n\n${other}\n${CLOSE.replace(" -->", "-->")}`,
diff --git a/src/bundled/bestie/features.ts b/src/bundled/bestie/features.ts
index 1f3c4361e..7581752b2 100644
--- a/src/bundled/bestie/features.ts
+++ b/src/bundled/bestie/features.ts
@@ -35,7 +35,7 @@ Your owner turned on "Remembers you": keep memory about them, so your help gets
Your memory has these slugs:
- core: who you are to this owner and your durable operating rules. Link the slugs below from it, as [[mem/user]].
- mem/user: the owner's facts, preferences, timezone, notification preferences, and an "Open loops" section of things they asked you to follow up on.
-- mem/notes/YYYY-MM-DD: sparse dated notes of significant events, each with its source event id. Append only.
+- mem/notes/YYYY-MM-DD: sparse dated notes of significant events, each with its source event id, dated by this device's local date. Append only.
- mem/memory: curated longer-term knowledge. Replace superseded claims; never duplicate.
Rules:
diff --git a/src/bundled/bestie/former.test.ts b/src/bundled/bestie/former.test.ts
new file mode 100644
index 000000000..d74d07d74
--- /dev/null
+++ b/src/bundled/bestie/former.test.ts
@@ -0,0 +1,269 @@
+// @vitest-environment jsdom
+import { afterEach, expect, it, vi } from "vitest";
+import type { Agent, Agents } from "../../features/agents/service";
+import type { ChannelSummary } from "../../features/relay/contracts";
+import type { RelayData, RelaySnapshot } from "../../features/relay/service";
+import { checkinHourly, memory, withFeature } from "./features";
+import {
+ formerWithSettings,
+ rememberNewBestie,
+ stopFormerCheckIns,
+} from "./former";
+
+afterEach(() => localStorage.clear());
+
+const OWNER = "f".repeat(64);
+const SCOPE = `https://relay.example:${OWNER}`;
+const DM = "0f0f0f0f-0000-4000-8000-000000000001";
+const TIMER = {
+ "interest/bestie-hourly-check-in": { type: "interest" },
+ "watch/bestie-hourly-check-in": { type: "timer", channel: DM },
+};
+const checkingIn = withFeature(
+ withFeature("Be brief.\n", memory, true),
+ checkinHourly,
+ true,
+);
+const agent = (digit: string, instructions = "", attention = {}): Agent =>
+ ({
+ key: digit.repeat(64),
+ pubkey: digit.repeat(64),
+ name: digit,
+ type: "test/echo",
+ owner: OWNER,
+ relay: "wss://relay.example",
+ place: "here",
+ attention,
+ config: { instructions },
+ }) as unknown as Agent;
+const ada = agent("a", checkingIn, TIMER);
+const bea = agent("b");
+
+/** A community whose account read of the saved Bestie waits until `settle`. */
+function community(channels: readonly ChannelSummary[] = [], account = true) {
+ let settle: (pubkey: string | undefined) => void = () => {};
+ const read = new Promise((resolve) => {
+ settle = resolve;
+ });
+ const session = {
+ viewer: OWNER,
+ ...(account && {
+ mainAgent: { read: () => read, write: vi.fn(async () => {}) },
+ }),
+ channels: {
+ list: () => ({ channels }),
+ subscribeList: () => () => {},
+ ensureList: () => {},
+ },
+ };
+ const snapshot = { status: "ready", scope: SCOPE, session };
+ const relay = {
+ snapshot: () => snapshot,
+ subscribe: () => () => {},
+ } as unknown as RelayData;
+ return {
+ relay,
+ snapshot: snapshot as unknown as RelaySnapshot,
+ settle: async (pubkey: string | undefined) => {
+ settle(pubkey);
+ await read;
+ await Promise.resolve();
+ },
+ };
+}
+
+function host(list: Agent[], running: Agent[] = []) {
+ let agents = list;
+ const listeners = new Set<() => void>();
+ const save = vi.fn(async (key, change) => {
+ agents = agents.map((each) =>
+ each.key !== key
+ ? each
+ : ({
+ ...each,
+ ...(change.config !== undefined && { config: change.config }),
+ ...(change.attention && {
+ attention: Object.fromEntries(
+ Object.entries({
+ ...each.attention,
+ ...change.attention,
+ }).filter(([, value]) => value),
+ ),
+ }),
+ } as Agent),
+ );
+ for (const listener of listeners) listener();
+ });
+ return {
+ save,
+ /** The agents' listeners are told, with nothing changed. */
+ notify: () => {
+ for (const listener of listeners) listener();
+ },
+ agents: {
+ save,
+ types: () => [{ key: "test/echo", adopt: () => ({}) }],
+ snapshot: () => ({ agents, running: [...agents, ...running] }),
+ subscribe: (listener: () => void) => {
+ listeners.add(listener);
+ return () => void listeners.delete(listener);
+ },
+ } as unknown as Pick,
+ };
+}
+
+it("stops a former Bestie's check-ins once the Bestie is known, and leaves its memory", async () => {
+ const { relay, settle } = community();
+ const { agents, save, notify } = host([ada, bea]);
+ const stop = stopFormerCheckIns(relay, agents);
+ // While the saved Bestie is being read, nobody is former.
+ await Promise.resolve();
+ expect(save).not.toHaveBeenCalled();
+ await settle(bea.pubkey);
+ await vi.waitFor(() => expect(save).toHaveBeenCalledTimes(2));
+ expect(save.mock.calls).toEqual([
+ [
+ ada.key,
+ {
+ attention: {
+ "interest/bestie-hourly-check-in": null,
+ "watch/bestie-hourly-check-in": null,
+ },
+ },
+ ],
+ [
+ ada.key,
+ { config: { instructions: withFeature("Be brief.\n", memory, true) } },
+ ],
+ ]);
+ // Once stopped there is nothing more to do.
+ save.mockClear();
+ notify();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(save).not.toHaveBeenCalled();
+ stop();
+});
+
+it("does nothing while the saved Bestie is unknown, or to the Bestie itself", async () => {
+ const unknown = community();
+ const first = host([ada]);
+ const stopUnknown = stopFormerCheckIns(unknown.relay, first.agents);
+ // An account with no saved Bestie, or a read that failed, isn't "none".
+ await unknown.settle(undefined);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(first.save).not.toHaveBeenCalled();
+ stopUnknown();
+
+ const known = community();
+ const second = host([ada]);
+ const stopKnown = stopFormerCheckIns(known.relay, second.agents);
+ await known.settle(ada.pubkey);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(second.save).not.toHaveBeenCalled();
+ stopKnown();
+});
+
+it("stops a timer left without its section, and doesn't retry a failed save until something changes", async () => {
+ const { relay, settle } = community();
+ const half = agent("c", "Be brief.", TIMER);
+ const { agents, save, notify } = host([half]);
+ save.mockRejectedValueOnce(new Error("offline"));
+ const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+ const stop = stopFormerCheckIns(relay, agents);
+ await settle(bea.pubkey);
+ await vi.waitFor(() => expect(warn).toHaveBeenCalled());
+ expect(save).toHaveBeenCalledTimes(1);
+ // The same state seen again isn't saved again.
+ notify();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(save).toHaveBeenCalledTimes(1);
+ stop();
+ warn.mockRestore();
+});
+
+it("turns memory on for a local agent made Bestie here, unless it has it", async () => {
+ const { relay } = community();
+ const { agents, save } = host([ada, bea]);
+ await rememberNewBestie(relay, agents, ada.pubkey);
+ expect(save).not.toHaveBeenCalled();
+ await rememberNewBestie(relay, agents, bea.pubkey);
+ expect(save).toHaveBeenCalledWith(bea.key, {
+ config: { instructions: withFeature("", memory, true) },
+ });
+ // A remote agent, or one in another community, is left alone.
+ save.mockClear();
+ await rememberNewBestie(relay, agents, "9".repeat(64));
+ expect(save).not.toHaveBeenCalled();
+ // Nor is one whose section was edited by hand: no second section.
+ const edited = host([
+ {
+ ...bea,
+ config: {
+ instructions: withFeature("", memory, true).replace(
+ "",
+ "",
+ ),
+ },
+ } as Agent,
+ ]);
+ await rememberNewBestie(relay, edited.agents, bea.pubkey);
+ expect(edited.save).not.toHaveBeenCalled();
+});
+
+it("counts a former Bestie as on while it has a section, or a private channel once seen as Bestie", async () => {
+ const channel = {
+ id: "c1",
+ name: "plans",
+ channelType: "stream",
+ private: true,
+ members: [OWNER, bea.pubkey],
+ } as unknown as ChannelSummary;
+ const { relay, snapshot, settle } = community([channel]);
+ const { agents } = host([ada, bea]);
+ expect(formerWithSettings(ada, snapshot)).toBe(true);
+ // Any agent in a private channel isn't a former Bestie...
+ expect(formerWithSettings(bea, snapshot)).toBe(false);
+ // ...but one this device saw as Bestie is, once another one is.
+ const stop = stopFormerCheckIns(relay, agents);
+ await settle(bea.pubkey);
+ expect(formerWithSettings(bea, snapshot)).toBe(true);
+ expect(
+ formerWithSettings({ ...bea, pubkey: "d".repeat(64) } as Agent, snapshot),
+ ).toBe(false);
+ stop();
+});
+
+it("leaves a Bestie kept only on this device alone, as an automatic pick looks the same", async () => {
+ const { relay } = community([], false);
+ localStorage.setItem(
+ `buzz-view.v1:${JSON.stringify([SCOPE, "solo:default-agent"])}`,
+ JSON.stringify(bea.pubkey),
+ );
+ const { agents, save } = host([ada, bea]);
+ const stop = stopFormerCheckIns(relay, agents);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(save).not.toHaveBeenCalled();
+ stop();
+});
+
+it("stops only the timer of an agent also in another community, whose instructions it shares", async () => {
+ const { relay, settle } = community();
+ const elsewhere = { ...ada, relay: "wss://other.example" } as Agent;
+ const { agents, save } = host([ada, bea], [elsewhere]);
+ const stop = stopFormerCheckIns(relay, agents);
+ await settle(bea.pubkey);
+ await vi.waitFor(() => expect(save).toHaveBeenCalled());
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(save.mock.calls).toEqual([
+ [
+ ada.key,
+ {
+ attention: {
+ "interest/bestie-hourly-check-in": null,
+ "watch/bestie-hourly-check-in": null,
+ },
+ },
+ ],
+ ]);
+ stop();
+});
diff --git a/src/bundled/bestie/former.ts b/src/bundled/bestie/former.ts
new file mode 100644
index 000000000..50237cf9d
--- /dev/null
+++ b/src/bundled/bestie/former.ts
@@ -0,0 +1,195 @@
+import type { Agent, Agents } from "../../features/agents/service";
+import type { RelayData, RelaySnapshot } from "../../features/relay/service";
+import type { RelaySession } from "../../features/relay/session";
+import { FEATURES, featureState, memory } from "./features";
+import { privateChannels } from "./PrivateChannels";
+import {
+ cannotEdit,
+ type FeatureAgents,
+ featurePresent,
+ instructionsOf,
+ saveFeature,
+} from "./save";
+import { inCommunity, savedBestie } from "./saved";
+import { readView, writeView } from "../../shared/view-state";
+
+type ReconcileAgents = FeatureAgents & Pick;
+
+const FORMER = "bestie:former";
+/** The agents this device has seen as the community's Bestie, newest last. */
+function seenAsBestie(scope: string) {
+ const value = readView(scope, FORMER, []);
+ return Array.isArray(value)
+ ? value.filter((pubkey): pubkey is string => typeof pubkey === "string")
+ : [];
+}
+function rememberBestie(scope: string, pubkey: string) {
+ const seen = seenAsBestie(scope);
+ if (!seen.includes(pubkey))
+ writeView(scope, FORMER, [...seen, pubkey].slice(-20));
+}
+
+/** Whether `agent`, which isn't Bestie, was one and still has something on
+ * that the Former Bestie tab can turn off. A Bestie section in its
+ * instructions shows it was Bestie, on any device, and is on. Membership of
+ * one of the viewer's private channels counts only for an agent this device
+ * saw as Bestie: nothing records which channels Bestie's switches added. */
+export function formerWithSettings(
+ agent: Agent,
+ { session, scope }: RelaySnapshot,
+) {
+ const instructions = instructionsOf(agent);
+ if (FEATURES.some((feature) => featureState(instructions, feature) !== "off"))
+ return true;
+ return (
+ !!scope &&
+ seenAsBestie(scope).includes(agent.pubkey) &&
+ privateChannels(
+ session.channels.list().channels,
+ session.viewer ?? "",
+ agent.pubkey,
+ ).joined.length > 0
+ );
+}
+
+/** Calls `listener` when who is in the viewer's private channels changes,
+ * across reconnections, but not for each new message in them. */
+export function subscribePrivateMembers(
+ relay: RelayData,
+ listener: () => void,
+) {
+ const members = (session: RelaySession) =>
+ privateChannels(session.channels.list().channels, session.viewer ?? "", "")
+ .others.map(({ id, members = [] }) => `${id}:${[...members].sort()}`)
+ .sort()
+ .join(" ");
+ let session = relay.snapshot().session;
+ let last = members(session);
+ const changed = () => {
+ const next = members(session);
+ if (next === last) return;
+ last = next;
+ listener();
+ };
+ const follow = () => {
+ session.channels.ensureList();
+ return session.channels.subscribeList(changed);
+ };
+ let stop = follow();
+ const stopRelay = relay.subscribe(() => {
+ const next = relay.snapshot().session;
+ if (next === session) return;
+ stop();
+ session = next;
+ stop = follow();
+ changed();
+ });
+ return () => {
+ stopRelay();
+ stop();
+ };
+}
+
+/** Stops the check-ins of each agent here that isn't the community's Bestie,
+ * whenever the saved Bestie or the agents change, wherever the change was
+ * made. It acts only on a Bestie saved to the account and read: while the
+ * choice is loading or unknown, or kept only on this device, where an
+ * automatic pick looks the same, nobody counts as former. An agent also in
+ * another community, where it may be Bestie, loses only its timer here, as
+ * its instructions are shared. Memory and channels stay as they are. */
+export function stopFormerCheckIns(relay: RelayData, agents: ReconcileAgents) {
+ const bestie = savedBestie(relay);
+ const checkIns = FEATURES.filter(({ timer }) => timer);
+ /** Agents being saved, and what each was like when last tried, so a state
+ * is tried once per connection, and a save that left it as it was doesn't
+ * loop. */
+ const saving = new Set();
+ const tried = new Map();
+ let session = relay.snapshot().session;
+ const reconcile = () => {
+ const relaySnapshot = relay.snapshot();
+ if (relaySnapshot.session !== session) {
+ session = relaySnapshot.session;
+ tried.clear();
+ }
+ const current = session.mainAgent ? bestie.snapshot() : undefined;
+ if (!current) return;
+ if (relaySnapshot.scope) rememberBestie(relaySnapshot.scope, current);
+ const { agents: here, running = [] } = agents.snapshot();
+ for (const agent of here) {
+ const on = checkIns.filter((feature) => featurePresent(agent, feature));
+ const seen = JSON.stringify([instructionsOf(agent), agent.attention]);
+ if (
+ !on.length ||
+ agent.pubkey === current ||
+ agent.place !== "here" ||
+ saving.has(agent.key) ||
+ tried.get(agent.key) === seen ||
+ cannotEdit(agents, agent) ||
+ !inCommunity(agent, relaySnapshot)
+ )
+ continue;
+ const timerOnly = running.some(
+ (other) =>
+ other.pubkey === agent.pubkey && !inCommunity(other, relaySnapshot),
+ );
+ saving.add(agent.key);
+ tried.set(agent.key, seen);
+ // Not while the agents are telling their listeners of a change.
+ void Promise.resolve()
+ .then(async () => {
+ for (const feature of on) {
+ // Each save starts from the agent as the last one left it, and
+ // stops if it was made Bestie again meanwhile.
+ const fresh = agents
+ .snapshot()
+ .agents.find((each) => each.key === agent.key);
+ if (!fresh || bestie.snapshot() === agent.pubkey) return;
+ await saveFeature(agents, fresh, feature, false, { timerOnly });
+ }
+ })
+ .catch((error: unknown) =>
+ console.warn("A former Bestie's check-ins didn't stop", error),
+ )
+ .finally(() => {
+ saving.delete(agent.key);
+ // What changed while it saved.
+ reconcile();
+ });
+ }
+ };
+ const stopBestie = bestie.subscribe(reconcile);
+ const stopAgents = agents.subscribe(reconcile);
+ const stopRelay = relay.subscribe(reconcile);
+ reconcile();
+ return () => {
+ stopBestie();
+ stopAgents();
+ stopRelay();
+ };
+}
+
+/** Turns Remembers you on for a local agent this device just made Bestie,
+ * unless its type can't take it or it already has it. */
+export function rememberNewBestie(
+ relay: RelayData,
+ agents: ReconcileAgents,
+ pubkey: string,
+) {
+ const agent = agents
+ .snapshot()
+ .agents.find(
+ (candidate) =>
+ candidate.pubkey === pubkey &&
+ candidate.place === "here" &&
+ inCommunity(candidate, relay.snapshot()),
+ );
+ if (
+ !agent ||
+ cannotEdit(agents, agent) ||
+ // Never a second section, even beside one edited by hand.
+ featureState(instructionsOf(agent), memory) !== "off"
+ )
+ return Promise.resolve();
+ return saveFeature(agents, agent, memory, true);
+}
diff --git a/src/bundled/bestie/index.tsx b/src/bundled/bestie/index.tsx
index 5583497eb..7b2d838d5 100644
--- a/src/bundled/bestie/index.tsx
+++ b/src/bundled/bestie/index.tsx
@@ -29,7 +29,9 @@ import {
type RemoteBestie,
} from "./setup";
import type { RemoteAgentModel } from "../builderlab/agents/client";
-import { bestieTab } from "./BestieTab";
+import { onBestieMade } from "../agents/BestieChoice";
+import { bestieTab, formerBestieTab } from "./BestieTab";
+import { rememberNewBestie, stopFormerCheckIns } from "./former";
export const inject = [
"pages",
@@ -68,6 +70,18 @@ export const apply: PluginModule["apply"] = (ctx) => {
});
ctx.effect(() => () => listeners.clear());
ctx.agents.registerTab(bestieTab(ctx.relay, ctx.agents));
+ ctx.agents.registerTab(formerBestieTab(ctx.relay, ctx.agents));
+ // Whoever is Bestie, on any device, only it checks in.
+ ctx.effect(() => stopFormerCheckIns(ctx.relay, ctx.agents));
+ // A Bestie made on this device starts out remembering its owner. One made
+ // elsewhere keeps what it has, so memory turned off stays off.
+ ctx.effect(() =>
+ onBestieMade((pubkey) => {
+ rememberNewBestie(ctx.relay, ctx.agents, pubkey).catch((error) =>
+ console.warn("Bestie's memory wasn't turned on", error),
+ );
+ }),
+ );
ctx.pages.register({
id: "bestie",
title: "Bestie",
diff --git a/src/bundled/bestie/save.test.ts b/src/bundled/bestie/save.test.ts
new file mode 100644
index 000000000..b41c4ca4a
--- /dev/null
+++ b/src/bundled/bestie/save.test.ts
@@ -0,0 +1,24 @@
+import { expect, it, vi } from "vitest";
+import type { Agent, Agents } from "../../features/agents/service";
+import { checkinHourly, memory, withFeature } from "./features";
+import { saveFeature } from "./save";
+
+it("refuses to turn on a section edited by hand, saving nothing", async () => {
+ const save = vi.fn(async () => {});
+ const agents = { save, types: () => [] };
+ const instructions = withFeature(
+ withFeature("Be brief.", memory, true),
+ checkinHourly,
+ true,
+ ).replace("", "");
+ const agent = {
+ key: "a".repeat(64),
+ attention: {},
+ config: { instructions },
+ } as unknown as Agent;
+ await expect(
+ saveFeature(agents, agent, checkinHourly, true, { channel: "dm" }),
+ ).rejects.toThrow("restore it first");
+ // Its timer would otherwise be saved first, leaving half of it on.
+ expect(save).not.toHaveBeenCalled();
+});
diff --git a/src/bundled/bestie/save.ts b/src/bundled/bestie/save.ts
new file mode 100644
index 000000000..fe08369f4
--- /dev/null
+++ b/src/bundled/bestie/save.ts
@@ -0,0 +1,140 @@
+import {
+ type AttentionValue,
+ interestSlug,
+ watchSlug,
+} from "../../features/agents/attention";
+import type { Agent, Agents } from "../../features/agents/service";
+import {
+ FEATURES,
+ type Feature,
+ featureState,
+ hasFeature,
+ restoredFeature,
+ withFeature,
+} from "./features";
+
+export type FeatureAgents = Pick;
+
+/** The agent's instructions, as its synced editor shows them. */
+export function instructionsOf(agent: Agent) {
+ const { instructions } = (agent.config ?? {}) as { instructions?: unknown };
+ return typeof instructions === "string" ? instructions : "";
+}
+
+/** Why the agent's instructions can't take a feature here, if they can't. */
+export function cannotEdit(agents: FeatureAgents, agent: Agent) {
+ // A type without `adopt` has no instructions, as `updateKind` says.
+ if (!agents.types().find(({ key }) => key === agent.type)?.adopt)
+ return "This agent's type has no instructions to add this to.";
+ // Without a confirmed copy its instructions aren't shown, so a save here
+ // would replace them.
+ return agent.configProblem;
+}
+
+/** Whether `agent` has `feature` on: its section, and its timer if it has
+ * one. Half of one, such as a timer deleted in Watching, reads as off. */
+export function featureOn(agent: Agent, feature: Feature) {
+ return (
+ hasFeature(instructionsOf(agent), feature) &&
+ (!feature.timer || !!agent.attention[watchSlug(feature.timer.id)])
+ );
+}
+
+/** Whether any of the feature's parts is there: its section, whole or
+ * edited, or its timer. */
+export function featurePresent(agent: Agent, feature: Feature) {
+ return (
+ featureState(instructionsOf(agent), feature) !== "off" ||
+ (!!feature.timer && !!agent.attention[watchSlug(feature.timer.id)])
+ );
+}
+
+/** Turns `feature` on or off as its switch does, revising the synced
+ * instructions as their editor would. Off also turns off the features that
+ * require it. A timer is delivered to `channel`, the owner's DM with the
+ * agent. With `timerOnly`, the instructions, which each of the agent's
+ * communities shares, are left as they are. Attention is saved first: if the
+ * instructions then fail to save, the half left reads as off, and turning it
+ * either way finishes it. On refuses a section edited by hand: Restore puts
+ * it back first. */
+export async function saveFeature(
+ agents: FeatureAgents,
+ agent: Agent,
+ feature: Feature,
+ on: boolean,
+ {
+ channel,
+ timerOnly = false,
+ }: { channel?: string; timerOnly?: boolean } = {},
+) {
+ if (on && featureState(instructionsOf(agent), feature) === "edited")
+ throw new Error(
+ `${feature.title} was edited in Instructions; restore it first.`,
+ );
+ const off = on
+ ? []
+ : [feature, ...FEATURES.filter(({ requires }) => requires === feature.id)];
+ const attention: Record = {};
+ for (const { timer } of off)
+ for (const slug of timer
+ ? [interestSlug(timer.id), watchSlug(timer.id)]
+ : [])
+ if (agent.attention[slug]) attention[slug] = null;
+ const timer = on && feature.timer;
+ if (timer) {
+ if (!channel) throw new Error("A check-in needs your DM with the agent.");
+ attention[interestSlug(timer.id)] = {
+ type: "interest",
+ instructions: timer.interest,
+ };
+ attention[watchSlug(timer.id)] = {
+ type: "timer",
+ interest_id: timer.id,
+ prompt: timer.prompt,
+ enabled: true,
+ interval_secs: timer.everySecs,
+ armed_at: Math.floor(Date.now() / 1000),
+ max_occurrences: null,
+ expires_at: null,
+ channel,
+ };
+ }
+ if (Object.keys(attention).length)
+ await agents.save(agent.key, {
+ attention,
+ // Its timer runs only while the agent's Attention is on. Off leaves it
+ // on: the agent's other watches may need it.
+ ...(timer && { attentionEnabled: true }),
+ });
+ if (timerOnly) return;
+ const instructions = instructionsOf(agent);
+ const next = on
+ ? withFeature(instructions, feature, true)
+ : off.reduce((text, item) => withFeature(text, item, false), instructions);
+ if (next !== instructions) await saveInstructions(agents, agent, next);
+}
+
+/** Puts back the feature's section edited by hand, as the editor would save
+ * it. */
+export async function restoreFeature(
+ agents: FeatureAgents,
+ agent: Agent,
+ feature: Feature,
+) {
+ const next = restoredFeature(instructionsOf(agent), feature);
+ if (next === undefined)
+ throw new Error(`Fix ${feature.title}'s markers in Instructions.`);
+ await saveInstructions(agents, agent, next);
+}
+
+/** Saves `instructions` as the next revision of the copy `agent` shows. */
+function saveInstructions(
+ agents: FeatureAgents,
+ agent: Agent,
+ instructions: string,
+) {
+ return agents.save(agent.key, {
+ config: { ...(agent.config as object), instructions },
+ ...(agent.configBase && { base: agent.configBase }),
+ });
+}
diff --git a/src/bundled/bestie/saved.ts b/src/bundled/bestie/saved.ts
new file mode 100644
index 000000000..6c4249447
--- /dev/null
+++ b/src/bundled/bestie/saved.ts
@@ -0,0 +1,63 @@
+import type { Agent } from "../../features/agents/service";
+import { relayOrigin } from "../../features/communities/destination";
+import { relayPartition } from "../../features/relay/partition";
+import type { RelayData, RelaySnapshot } from "../../features/relay/service";
+import { savedAgentStore } from "../../features/solo/default-agent";
+
+/** The saved Bestie in the connected community, across reconnections. */
+export function savedBestie(relay: RelayData) {
+ let current:
+ | Readonly<{
+ snapshot: RelaySnapshot;
+ store: ReturnType;
+ }>
+ | undefined;
+ const store = () => {
+ const snapshot = relay.snapshot();
+ if (
+ current?.snapshot.session !== snapshot.session ||
+ current.snapshot.scope !== snapshot.scope
+ )
+ current = {
+ snapshot,
+ store: savedAgentStore(snapshot.session, snapshot.scope ?? ""),
+ };
+ return current.store;
+ };
+ return {
+ snapshot: () => store().snapshot(),
+ subscribe(listener: () => void) {
+ // The saved choice's sources also change for unrelated view state, so
+ // only a different Bestie, or community, is passed on.
+ let following = store();
+ let last = following.snapshot();
+ const changed = () => {
+ const next = following.snapshot();
+ if (next === last) return;
+ last = next;
+ listener();
+ };
+ let stop = following.subscribe(changed);
+ const stopRelay = relay.subscribe(() => {
+ if (store() === following) return;
+ stop();
+ following = store();
+ last = following.snapshot();
+ stop = following.subscribe(changed);
+ listener();
+ });
+ return () => {
+ stopRelay();
+ stop();
+ };
+ },
+ };
+}
+
+export function inCommunity(agent: Agent, { scope }: RelaySnapshot) {
+ try {
+ return relayPartition(relayOrigin(agent.relay), agent.owner) === scope;
+ } catch {
+ return false;
+ }
+}
diff --git a/tests/browser/bestie-tab.spec.mjs b/tests/browser/bestie-tab.spec.mjs
new file mode 100644
index 000000000..06a605d6d
--- /dev/null
+++ b/tests/browser/bestie-tab.spec.mjs
@@ -0,0 +1,52 @@
+import { test, expect } from "./source-fixture.mjs";
+
+// Real layout is outside jsdom: the tab at the Agents side panel's default and
+// narrowest widths, with large text, never runs off the panel.
+// With a section edited by hand, its row shows Restore instead of a switch.
+for (const [variant, query] of [
+ ["bestie", ""],
+ ["former", "?former"],
+ ["edited", "?edited"],
+]) {
+ test(`The ${variant} Bestie tab fits the side panel at every width and text size`, async ({
+ page,
+ }) => {
+ await page.goto(`/tests/fixtures/bestie-tab.html${query}`);
+ if (variant === "edited")
+ await expect(page.getByRole("button", { name: "Restore" })).toBeVisible();
+ const panel = page.getByRole("complementary", { name: "Agent panel" });
+ await expect(
+ page.getByText("Private channels", { exact: false }).first(),
+ ).toBeVisible();
+ for (const width of ["28rem", "20rem"]) {
+ for (const fontSize of ["16px", "20px"]) {
+ await page.evaluate(
+ ([width, fontSize]) => {
+ document.documentElement.style.setProperty(
+ "--secondary-panel-width",
+ width,
+ );
+ document.documentElement.style.fontSize = fontSize;
+ },
+ [width, fontSize],
+ );
+ if (process.env.BESTIE_SHOTS)
+ await panel.screenshot({
+ path: `${process.env.BESTIE_SHOTS}/${variant}-${width}-${fontSize}.png`,
+ });
+ expect(
+ await panel.evaluate((el) => el.scrollWidth <= el.clientWidth),
+ `${width} at ${fontSize}`,
+ ).toBe(true);
+ for (const button of await panel.getByRole("button").all()) {
+ const box = await button.boundingBox();
+ const bounds = await panel.boundingBox();
+ expect(
+ box && bounds && box.x + box.width <= bounds.x + bounds.width + 0.5,
+ `${await button.textContent()} at ${width} ${fontSize}`,
+ ).toBe(true);
+ }
+ }
+ }
+ });
+}
diff --git a/tests/fixtures/bestie-tab.html b/tests/fixtures/bestie-tab.html
new file mode 100644
index 000000000..e3ed30ce9
--- /dev/null
+++ b/tests/fixtures/bestie-tab.html
@@ -0,0 +1,2 @@
+
+Bestie tab fixture
diff --git a/tests/fixtures/bestie-tab.tsx b/tests/fixtures/bestie-tab.tsx
new file mode 100644
index 000000000..c552f66e5
--- /dev/null
+++ b/tests/fixtures/bestie-tab.tsx
@@ -0,0 +1,131 @@
+// The production Bestie tabs in the Agents side panel's layout, with only the
+// host data boundary replaced. `?former` shows the Former Bestie tab, and
+// `?edited` a memory section whose closing marker was edited by hand.
+import { createRoot } from "react-dom/client";
+import styles from "../../src/bundled/agents/AgentsPage.module.css";
+import { bestieTab, formerBestieTab } from "../../src/bundled/bestie/BestieTab";
+import {
+ checkinHourly,
+ memory,
+ withFeature,
+} from "../../src/bundled/bestie/features";
+import type { Agent } from "../../src/features/agents/service";
+import type { RelayData } from "../../src/features/relay/service";
+import "../../src/shared/styles/globals.css";
+
+const OWNER = "f".repeat(64);
+const ADA = "a".repeat(64);
+const BEA = "b".repeat(64);
+const query = new URLSearchParams(location.search);
+const former = query.has("former");
+const edited = query.has("edited");
+const channel = (name: string, members: string[]) => ({
+ id: `id-${name}`,
+ name,
+ channelType: "stream",
+ private: true,
+ members,
+});
+const list = {
+ channels: [
+ channel("design-reviews-and-weekly-planning-notes", [OWNER, ADA]),
+ channel("family", [OWNER, ADA]),
+ channel("leadership-offsite", [OWNER]),
+ channel("hiring", [OWNER]),
+ ],
+};
+const choice = (pubkey: string, name: string) => ({
+ pubkey,
+ name,
+ managed: true,
+});
+const choices = {
+ status: "ready",
+ complete: true,
+ pending: false,
+ identities: [choice(ADA, "Ada"), choice(BEA, "Bea")],
+ selectable: [choice(ADA, "Ada"), choice(BEA, "Bea")],
+ archives: { status: "unavailable", archived: [] },
+};
+const connection = {
+ status: "ready",
+ scope: `https://relay.example:${OWNER}`,
+ session: {
+ viewer: OWNER,
+ outbox: { supports: () => true },
+ directMessages: { open: async () => "dm" },
+ channels: {
+ list: () => list,
+ subscribeList: () => () => {},
+ ensureList: () => {},
+ },
+ memberAdditions: { add: async () => {} },
+ memberAdministration: {
+ refresh: async () => {},
+ run: async () => {},
+ snapshot: () => ({ status: "ready", authority: { roles: {} } }),
+ },
+ mainAgent: {
+ read: async () => (former ? BEA : ADA),
+ write: async () => {},
+ },
+ agentChoices: {
+ snapshot: () => choices,
+ subscribe: () => () => {},
+ retain: () => () => {},
+ },
+ },
+};
+const relay = {
+ snapshot: () => connection,
+ subscribe: () => () => {},
+} as unknown as RelayData;
+const agents = {
+ save: async () => {},
+ types: () => [{ key: "claude-code", adopt: () => ({}) }],
+};
+const agent = {
+ key: ADA,
+ pubkey: ADA,
+ name: "Ada",
+ type: "claude-code",
+ owner: OWNER,
+ relay: "wss://relay.example",
+ place: "here",
+ attentionEnabled: true,
+ attention: {
+ "interest/bestie-hourly-check-in": { value: { type: "interest" } },
+ "watch/bestie-hourly-check-in": { value: { type: "timer" } },
+ },
+ config: {
+ instructions: withFeature(
+ withFeature("Be brief.", memory, true),
+ checkinHourly,
+ true,
+ ).replace(
+ "",
+ edited ? " Also answer in French." : "$&",
+ ),
+ },
+} as unknown as Agent;
+const tab = (former ? formerBestieTab : bestieTab)(relay, agents);
+const Tab = tab.component;
+const root = document.getElementById("root");
+if (!root) throw new Error("Missing fixture root");
+createRoot(root).render(
+ ,
+);