@frockbot/plugin-flock 0.3.12 → 0.3.14

package/frockbot.json

@@ -22,7 +22,8 @@
         { "slot": "frockbot.overlays", "order": 10 },
         { "slot": "frockbot.bot-identity", "order": 10 },
         { "slot": "frockbot.bot-avatar", "order": 10 },
-        { "slot": "frockbot.bot-avatar-editor", "order": 10 }
+        { "slot": "frockbot.bot-avatar-editor", "order": 10 },
+        { "slot": "frockbot.bot-settings-primary-sections", "order": 900 }
       ],
       "outlets": []
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-flock",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "private": false,
   "type": "module",
   "exports": {
@@ -27,16 +27,16 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/client-core": "0.3.12",
-    "@frockbot/client-ui": "0.3.12",
-    "@frockbot/configuration-core": "0.3.12",
-    "@frockbot/kernel-contracts": "0.3.12",
-    "@frockbot/plugin-shell": "0.3.12",
+    "@frockbot/client-core": "0.3.14",
+    "@frockbot/client-ui": "0.3.14",
+    "@frockbot/configuration-core": "0.3.14",
+    "@frockbot/kernel-contracts": "0.3.14",
+    "@frockbot/plugin-shell": "0.3.14",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
-    "@frockbot/plugin-testkit": "0.3.12",
+    "@frockbot/plugin-testkit": "0.3.14",
     "@types/bun": "1.4.0",
     "@vitejs/plugin-vue": "6.0.8",
     "css-tree": "2.3.1",

package/src/agent.ts

@@ -318,7 +318,9 @@ export async function createdBotIdV1(
       .replace(/[^a-z0-9]+/g, "-")
       .replace(/^-|-$/g, "")
       .slice(0, 80) || "bot";
-  const digest = await sha256HexV1(`${owner.userId}${owner.botId}${effectId}`);
+  const digest = await sha256HexV1(
+    `${owner.userId}\u0000${owner.botId}\u0000${effectId}`,
+  );
   return `${base}-${digest.slice(0, 12)}`;
 }
 

package/src/bot.test.ts

@@ -49,6 +49,7 @@ describe("Flock Bot contribution", () => {
           return Promise.resolve();
         },
         archiveEligible: () => Promise.resolve(true),
+        tearDown: () => Promise.resolve(),
       });
     expect(await create().read(registration, "user-1")).toMatchObject({
       botId: "alpha",
@@ -95,6 +96,7 @@ describe("Flock Bot contribution", () => {
         storage,
         materializeSettings: () => Promise.resolve(),
         archiveEligible: () => Promise.resolve(eligible),
+        tearDown: () => Promise.resolve(),
       });
     const contribution = create();
     await contribution.read(registration, "user-1");
@@ -153,12 +155,95 @@ describe("Flock Bot contribution", () => {
     });
   });
 
+  test("deletes every key, cancels the alarm, and refuses to come back", async () => {
+    const storage = new MemoryStorage();
+    // Whatever else the Bot owned: a run, a Routine schedule, its transcript.
+    // The teardown is the host's, so the test plays the host and asserts that
+    // the Contribution asked for one and left nothing but the tombstone.
+    let alarms = 1;
+    const torn: Array<{ userId: string; botId: string }> = [];
+    const create = () =>
+      createFlockBotBackendContribution({
+        storage,
+        materializeSettings: () => Promise.resolve(),
+        archiveEligible: () => Promise.resolve(false),
+        tearDown: (identity) => {
+          torn.push(identity);
+          alarms = 0;
+          storage.values.clear();
+          return Promise.resolve();
+        },
+      });
+    const contribution = create();
+    await contribution.read(registration, "user-1");
+    await storage.put("run:run-1", { schemaVersion: 1 });
+    await storage.put("conversation", { schemaVersion: 1 });
+    await storage.put("routine-schedule:daily", { schemaVersion: 1 });
+    const command = {
+      schemaVersion: 1 as const,
+      type: "bot/delete" as const,
+      commandId: "delete-1",
+      botId: "alpha",
+    };
+    const applied = await contribution.executeLifecycle(
+      registration,
+      "user-1",
+      command,
+    );
+    expect(applied).toMatchObject({
+      status: "applied",
+      lifecycle: { botId: "alpha", status: "deleted" },
+    });
+    // Deletion is not gated on `archiveEligible`: a Bot mid-run is still
+    // deleted when its owner says so.
+    expect(torn).toEqual([{ userId: "user-1", botId: "alpha" }]);
+    expect(alarms).toBe(0);
+    // Nothing survives but the tombstone and the receipt that proves it.
+    expect([...storage.values.keys()].sort()).toEqual([
+      "flock:lifecycle-receipt:delete-1",
+      "flock:lifecycle:v1",
+    ]);
+    // Replaying the command, and replaying it against a fresh instance, both
+    // settle from the tombstone without tearing anything down again.
+    expect(
+      await contribution.executeLifecycle(registration, "user-1", command),
+    ).toEqual(applied);
+    const reconstructed = create();
+    expect(
+      await reconstructed.executeLifecycle(registration, "user-1", {
+        ...command,
+        commandId: "delete-2",
+      }),
+    ).toMatchObject({ status: "applied", lifecycle: { status: "deleted" } });
+    expect(torn).toHaveLength(1);
+    expect(
+      await reconstructed.readLifecycle(registration, "user-1"),
+    ).toMatchObject({ botId: "alpha", status: "deleted" });
+    // Neither restore nor archive resurrects it, and no Turn or sheep command
+    // may run against it.
+    expect(
+      await reconstructed.executeLifecycle(registration, "user-1", {
+        schemaVersion: 1,
+        type: "bot/restore",
+        commandId: "restore-1",
+        botId: "alpha",
+      }),
+    ).toMatchObject({ status: "rejected", failure: 'Bot "alpha" is deleted' });
+    await expect(reconstructed.read(registration, "user-1")).rejects.toThrow(
+      "deleted",
+    );
+    await expect(reconstructed.assertActive(storage, "alpha")).rejects.toThrow(
+      "deleted",
+    );
+  });
+
   test("rejects malformed durable sheep identity and receipt records", async () => {
     const storage = new MemoryStorage();
     const contribution = createFlockBotBackendContribution({
       storage,
       materializeSettings: () => Promise.resolve(),
       archiveEligible: () => Promise.resolve(true),
+      tearDown: () => Promise.resolve(),
     });
     await storage.put("flock:sheep:v1", {
       schemaVersion: 1,

package/src/bot.ts

@@ -42,6 +42,17 @@ export interface FlockBotBackendHost {
     userId: string,
   ): Promise<void>;
   archiveEligible(storage: FlockBotTransaction): Promise<boolean>;
+  /**
+   * Destroy everything this Bot owns: every durable key in its own Durable
+   * Object, its scheduled alarm, and any object-store root keyed to it.
+   *
+   * The host owns this rather than the Contribution because the surfaces are
+   * the application's — `deleteAll()` and `deleteAlarm()` are not part of the
+   * transaction seam this Package writes against, and the object store is not
+   * named here at all. It must be idempotent: the delete saga replays, and a
+   * Bot torn down twice is torn down once.
+   */
+  tearDown(identity: { userId: string; botId: string }): Promise<void>;
 }
 
 export class BotArchivedError extends Error {
@@ -51,6 +62,19 @@ export class BotArchivedError extends Error {
   }
 }
 
+/**
+ * A Bot that has been permanently deleted. Distinct from `BotNotFoundError`
+ * because the tombstone is the one thing a deleted Bot still knows about
+ * itself: the registration may already be gone from the User's directory, or
+ * it may not be gone yet, and either way no Turn, command or routine may run.
+ */
+export class BotDeletedError extends Error {
+  constructor(readonly botId: string) {
+    super(`Bot "${botId}" is deleted`);
+    this.name = "BotDeletedError";
+  }
+}
+
 export class FlockBotBackendContribution {
   constructor(private readonly host: FlockBotBackendHost) {}
 
@@ -59,6 +83,10 @@ export class FlockBotBackendContribution {
     userId: string,
   ): Promise<SheepIdentityViewV1> {
     const registration = decodeBotRegistrationV1(registrationInput);
+    // A tombstone is checked before anything is written back: materializing a
+    // deleted Bot would recreate the very rows the delete removed.
+    const tombstone = await this.deletedLifecycle();
+    if (tombstone) throw new BotDeletedError(registration.botId);
     await this.host.materializeSettings(registration, userId);
     return this.host.storage.transaction(async (storage) => {
       const existingValue = await storage.get<unknown>(IDENTITY_KEY);
@@ -155,10 +183,28 @@ export class FlockBotBackendContribution {
     });
   }
 
+  /**
+   * The tombstone, if this Bot has been deleted.
+   *
+   * The delete teardown wipes every key and then writes the lifecycle back as
+   * `deleted`, so this single read is the whole of what a deleted Bot is.
+   */
+  private async deletedLifecycle(): Promise<BotLifecycleViewV1 | undefined> {
+    const stored = await this.host.storage.get<unknown>(LIFECYCLE_KEY);
+    if (stored === undefined) return undefined;
+    const lifecycle = decodeBotLifecycleViewV1(stored);
+    return lifecycle.status === "deleted" ? lifecycle : undefined;
+  }
+
   async readLifecycle(
     registration: BotRegistrationV1,
     userId: string,
   ): Promise<BotLifecycleViewV1> {
+    // The saga reconciles an uncertain delete by reading the lifecycle back,
+    // so a tombstone answers here rather than throwing: it is the proof the
+    // teardown ran.
+    const tombstone = await this.deletedLifecycle();
+    if (tombstone) return structuredClone(tombstone);
     await this.materialize(registration, userId);
     const stored = await this.host.storage.get<unknown>(LIFECYCLE_KEY);
     if (stored === undefined)
@@ -174,8 +220,25 @@ export class FlockBotBackendContribution {
     const command = decodeBotLifecycleCommandV1(input);
     if (registration.botId !== command.botId)
       throw new Error("lifecycle command does not match Bot registration");
-    await this.materialize(registration, userId);
     const fingerprint = flockCommandFingerprint(command);
+    // Deletion is terminal, so the tombstone is read before the Bot is
+    // materialized: a replayed `bot/delete` settles from it, and archive or
+    // restore is refused instead of resurrecting the Bot.
+    const tombstone = await this.deletedLifecycle();
+    if (tombstone)
+      return {
+        schemaVersion: 1,
+        commandId: command.commandId,
+        botId: command.botId,
+        status: command.type === "bot/delete" ? "applied" : "rejected",
+        lifecycle: structuredClone(tombstone),
+        ...(command.type === "bot/delete"
+          ? {}
+          : { failure: `Bot "${command.botId}" is deleted` }),
+      } satisfies BotLifecycleReceiptV1;
+    if (command.type === "bot/delete")
+      return this.delete(registration, userId, command, fingerprint);
+    await this.materialize(registration, userId);
     return this.host.storage.transaction(async (storage) => {
       const receiptKey = `${LIFECYCLE_RECEIPT_PREFIX}${command.commandId}`;
       const storedReceipt = await storage.get<unknown>(receiptKey);
@@ -229,6 +292,52 @@ export class FlockBotBackendContribution {
     });
   }
 
+  /**
+   * Permanent deletion, as one replayable step.
+   *
+   * The teardown runs first and the tombstone is written after it, so a crash
+   * anywhere in between leaves an empty Durable Object that the saga's retry
+   * tears down again — `tearDown` is idempotent, and an empty object has
+   * nothing left to remove. Writing the tombstone first would be the unsafe
+   * order: `deleteAll` would take it out again and the Bot would look alive.
+   */
+  private async delete(
+    registration: BotRegistrationV1,
+    userId: string,
+    command: BotLifecycleCommandV1,
+    fingerprint: string,
+  ): Promise<BotLifecycleReceiptV1> {
+    const currentValue = await this.host.storage.get<unknown>(LIFECYCLE_KEY);
+    const current =
+      currentValue === undefined
+        ? undefined
+        : decodeBotLifecycleViewV1(currentValue);
+    if (current && current.botId !== registration.botId)
+      throw new Error("Bot lifecycle identity does not match");
+    await this.host.tearDown({ userId, botId: registration.botId });
+    const lifecycle = {
+      schemaVersion: 1,
+      botId: command.botId,
+      status: "deleted",
+      revision: (current?.revision ?? 0) + 1,
+    } satisfies BotLifecycleViewV1;
+    const receipt = {
+      schemaVersion: 1,
+      commandId: command.commandId,
+      botId: command.botId,
+      status: "applied",
+      lifecycle,
+    } satisfies BotLifecycleReceiptV1;
+    await this.host.storage.put({
+      [LIFECYCLE_KEY]: lifecycle,
+      [`${LIFECYCLE_RECEIPT_PREFIX}${command.commandId}`]: {
+        fingerprint,
+        receipt,
+      },
+    });
+    return decodeBotLifecycleReceiptV1(receipt);
+  }
+
   async assertActive(
     storage: FlockBotTransaction,
     botId: string,
@@ -238,6 +347,7 @@ export class FlockBotBackendContribution {
     const lifecycle = decodeBotLifecycleViewV1(value);
     if (lifecycle.botId !== botId)
       throw new Error("Bot lifecycle identity does not match");
+    if (lifecycle.status === "deleted") throw new BotDeletedError(botId);
     if (lifecycle.status === "archived") throw new BotArchivedError(botId);
   }
 }

package/src/client/FlockDangerZone.vue

@@ -0,0 +1,71 @@
+<script setup lang="ts">
+// Deleting a Bot is Flock's authority — the directory it removes the
+// registration from is Flock's — so the affordance is contributed into the Bot
+// settings screen from here rather than reimplemented inside the Settings
+// Package, which would have to reach across a Package seam for the store.
+//
+// The confirmation itself is `FlockOverlay`'s: one dialog, one focus trap, one
+// mobile layout, and no second copy of the copy.
+import { inject } from "vue";
+import { flockWebDataKey } from "./state.js";
+import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
+
+const flock = inject(flockWebDataKey);
+if (!flock) throw new Error("Flock client data was not provided");
+const shell = inject(frockBotWebDataKey);
+if (!shell) throw new Error("FrockBot client data was not provided");
+</script>
+<template>
+  <section v-if="shell.activeBotId" class="flock-danger-zone">
+    <div>
+      <strong>Delete Bot</strong>
+      <small>This Bot and its chat history will be permanently deleted.</small>
+    </div>
+    <button
+      type="button"
+      class="flock-danger-zone__action"
+      @click="flock.openDelete(shell.activeBotId)"
+    >
+      Delete Bot
+    </button>
+  </section>
+</template>
+<style scoped>
+.flock-danger-zone {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 12px 14px;
+  border: 1px solid var(--frock-danger-border);
+  border-radius: var(--frock-radius-surface, 12px);
+  background: var(--frock-danger-surface);
+}
+
+.flock-danger-zone div {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.flock-danger-zone small {
+  color: var(--frock-text-muted);
+}
+
+.flock-danger-zone__action {
+  flex: none;
+  height: var(--frock-control-md, 32px);
+  padding: 0 14px;
+  border: 1px solid var(--frock-danger-strong);
+  border-radius: 999px;
+  background: var(--frock-danger-strong);
+  color: var(--frock-on-accent);
+  font: inherit;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+.flock-danger-zone__action:hover {
+  background: var(--frock-danger-text);
+}
+</style>

package/src/client/FlockOverlay.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { inject, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { computed, inject, nextTick, onBeforeUnmount, ref, watch } from "vue";
 import { sheepCatalog } from "../shared.js";
 import { flockWebDataKey } from "./state.js";
 import { dialogFocusWrapTarget } from "./dialog-focus.js";
@@ -8,6 +8,22 @@ const providedFlock = inject(flockWebDataKey);
 if (!providedFlock) throw new Error("Flock client data was not provided");
 const flock = providedFlock;
 
+/**
+ * The name the confirmation names. The live profile is the Bot's current name;
+ * the registration seed is what it was called when it was made, and is the
+ * fallback for a Bot whose identity read has not landed.
+ */
+const pendingName = computed(() => {
+  const botId = flock.value.lifecyclePending;
+  if (!botId) return "this Bot";
+  return (
+    flock.value.profiles[botId]?.name ??
+    flock.value.directory.bots.find((bot) => bot.botId === botId)
+      ?.initialName ??
+    "this Bot"
+  );
+});
+
 const dialog = ref<HTMLElement>();
 let restoreFocus: HTMLElement | undefined;
 const focusable =
@@ -90,6 +106,25 @@ onBeforeUnmount(() => restoreFocus?.focus());
           </button>
         </div>
       </div>
+      <div v-else-if="flock.overlay === 'delete'" class="flock-form">
+        <span class="flock-eyebrow">Delete Bot</span>
+        <h1 id="flock-title">Delete {{ pendingName }}?</h1>
+        <p>This Bot and its chat history will be permanently deleted.</p>
+        <p
+          v-if="flock.error"
+          class="flock-error"
+          role="alert"
+          aria-live="assertive"
+        >
+          {{ flock.error }}
+        </p>
+        <div class="flock-actions">
+          <button type="button" @click="flock.closeOverlay">Cancel</button>
+          <button class="danger" type="button" @click="flock.deleteBot">
+            Delete
+          </button>
+        </div>
+      </div>
       <template v-else>
         <div class="flock-preview">
           <SheepAvatar

package/src/client/FlockSidebar.vue

@@ -279,6 +279,14 @@ onMounted(() => void flock.value.load());
             >
               Archive
             </button>
+            <button
+              v-if="flock.showArchived"
+              type="button"
+              class="flock-lifecycle flock-lifecycle--danger"
+              @click="flock.openDelete(bot.botId)"
+            >
+              Delete
+            </button>
           </div>
         </TransitionGroup>
       </section>

package/src/client/index.test.ts

@@ -411,6 +411,114 @@ describe("Flock client reconciliation", () => {
     expect(state.value.directory.bots).toEqual([]);
   });
 
+  test("deletes with confirmation and drops the Bot from the list", async () => {
+    installStorage();
+    const location = { href: "https://app.example/?bot=alpha" };
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: {
+        location,
+        history: {
+          state: null,
+          replaceState: (_state: unknown, _title: string, url: URL) => {
+            location.href = url.href;
+          },
+        },
+      },
+    });
+    const sheep = randomSheepRecipeV1(() => 0);
+    // A deleted Bot leaves the directory outright, unlike an archived one.
+    let bots = ["alpha", "beta"];
+    let deleteCommands = 0;
+    const state = mount((path, method, body) => {
+      if (path === "/api/bots/identities")
+        return Promise.resolve({ schemaVersion: 1, identities: [] });
+      if (path === "/api/bots/alpha/lifecycle" && method === "POST") {
+        const command = JSON.parse(body ?? "") as {
+          commandId: string;
+          botId: string;
+          type: string;
+        };
+        expect(command.type).toBe("bot/delete");
+        deleteCommands += 1;
+        bots = bots.filter((botId) => botId !== "alpha");
+        return Promise.resolve({
+          schemaVersion: 1,
+          commandId: command.commandId,
+          botId: command.botId,
+          status: "applied",
+          lifecycle: {
+            schemaVersion: 1,
+            botId: command.botId,
+            status: "deleted",
+            revision: 1,
+          },
+        });
+      }
+      if (path === "/api/bots")
+        return Promise.resolve({
+          schemaVersion: 1,
+          revision: 3,
+          bots: bots.map((botId) => ({
+            schemaVersion: 1,
+            botId,
+            registeredAt: new Date(0).toISOString(),
+            initialName: botId,
+            sheep,
+          })),
+        });
+      if (path === "/api/bots/lifecycles")
+        return Promise.resolve({
+          schemaVersion: 1,
+          lifecycles: bots.map((botId) => ({
+            schemaVersion: 1,
+            botId,
+            status: "active",
+            revision: 0,
+          })),
+        });
+      if (path.endsWith("/sheep")) {
+        const botId = path.split("/")[3]!;
+        return Promise.resolve({ schemaVersion: 1, botId, revision: 0, sheep });
+      }
+      return Promise.reject(new Error(`unexpected request: ${path}`));
+    });
+    const selected: string[] = [];
+    const forgotten: (string | undefined)[] = [];
+    state.value.bindShell(
+      ref({
+        activeBotId: "alpha",
+        selectBot: (botId: string) => {
+          selected.push(botId);
+          return Promise.resolve();
+        },
+        transcripts: {
+          rememberViewport: () => undefined,
+          viewportFor: () => undefined,
+          forget: (botId?: string) => forgotten.push(botId),
+        },
+      }) as unknown as Ref<FrockBotWebData>,
+    );
+    await state.value.load();
+    state.value.openDelete("alpha");
+    expect(state.value.overlay).toBe("delete");
+    expect(state.value.lifecyclePending).toBe("alpha");
+    await state.value.deleteBot();
+    expect(deleteCommands).toBe(1);
+    expect(state.value.overlay).toBeUndefined();
+    expect(state.value.directory.bots.map((bot) => bot.botId)).toEqual([
+      "beta",
+    ]);
+    expect(selected.at(-1)).toBe("beta");
+    expect(new URL(location.href).searchParams.get("bot")).toBe("beta");
+    // The held transcript goes with the Bot: unlike an archive, there is no
+    // Bot left to read it back from.
+    expect(forgotten).toEqual(["alpha"]);
+    // A Bot that is no longer in the directory cannot be confirmed for delete.
+    state.value.openDelete("alpha");
+    expect(state.value.overlay).toBeUndefined();
+  });
+
   test("archives with confirmation, hides archived Bots, and selects a fallback", async () => {
     installStorage();
     const location = { href: "https://app.example/?bot=alpha" };

package/src/client/index.ts

@@ -20,6 +20,7 @@ import FlockIdentity from "./FlockIdentity.vue";
 import FlockAvatar from "./FlockAvatar.vue";
 import FlockAvatarEditor from "./FlockAvatarEditor.vue";
 import FlockCreateButton from "./FlockCreateButton.vue";
+import FlockDangerZone from "./FlockDangerZone.vue";
 import {
   decodeBotNotificationDirectoryViewV1,
   decodeBotUnreadDirectoryViewV1,
@@ -559,6 +560,59 @@ export const flockClientPlugin: ClientPlugin = (ctx) => {
         console.debug("bot archive failed", clientFailureDetailV1(error));
       }
     },
+    openDelete(botId) {
+      if (!state.value.directory.bots.some((bot) => bot.botId === botId))
+        return;
+      state.value.lifecyclePending = botId;
+      state.value.overlay = "delete";
+      state.value.error = undefined;
+    },
+    async deleteBot() {
+      const botId = state.value.lifecyclePending;
+      if (!botId) return;
+      try {
+        const receipt = decodeBotLifecycleReceiptV1(
+          await request(
+            `/api/bots/${encodeURIComponent(botId)}/lifecycle`,
+            "POST",
+            JSON.stringify({
+              schemaVersion: 1,
+              type: "bot/delete",
+              commandId: crypto.randomUUID(),
+              botId,
+            }),
+          ),
+        );
+        if (receipt.status === "rejected")
+          throw new Error(receipt.failure ?? "Couldn't delete this Bot.");
+        if (receipt.status === "pending") {
+          state.value.error = "Still deleting — this will finish shortly.";
+          return;
+        }
+        state.value.overlay = undefined;
+        state.value.lifecyclePending = undefined;
+        // An archived Bot's cached transcript is merely stale; a deleted one's
+        // is a lie, and there is no Bot left to read it from again.
+        shell?.value.transcripts.forget(botId);
+        // Move off the deleted Bot before anything else. Selecting aborts the
+        // Shell's in-flight reads for it, and every one of those is now a 404
+        // waiting to happen: the panels poll the Bot the User is looking at,
+        // and that Bot has just stopped existing.
+        const next = state.value.directory.bots.find(
+          (bot) =>
+            bot.botId !== botId &&
+            state.value.lifecycles[bot.botId] !== "archived",
+        );
+        if (next && shell?.value.activeBotId === botId)
+          await state.value.select(next.botId);
+        // The Bot is gone from the directory, so the reload re-derives the
+        // list, the selection and the `?bot=` parameter without a page reload.
+        await state.value.load();
+      } catch (error) {
+        state.value.error = presentClientFailureV1(error, "delete this Bot");
+        console.debug("bot delete failed", clientFailureDetailV1(error));
+      }
+    },
     async restore(botId) {
       try {
         const receipt = decodeBotLifecycleReceiptV1(
@@ -845,6 +899,13 @@ export const flockClientPlugin: ClientPlugin = (ctx) => {
       order: 10,
       component: FlockAvatarEditor,
     }),
+    // Last on the Bot's settings screen, below every setting it could still
+    // change: the one action that ends the Bot.
+    ctx.slot({
+      slot: "frockbot.bot-settings-primary-sections",
+      order: 900,
+      component: FlockDangerZone,
+    }),
   ];
 };
 export default flockClientPlugin;

package/src/client/state.ts

@@ -31,7 +31,7 @@ export interface FlockWebData {
    */
   loaded: boolean;
   error?: string;
-  overlay?: "create" | "edit" | "archive";
+  overlay?: "create" | "edit" | "archive" | "delete";
   lifecycles: Record<string, BotLifecycleStatusV1>;
   showArchived: boolean;
   lifecyclePending?: string;
@@ -52,6 +52,9 @@ export interface FlockWebData {
   toggleHidden(): void;
   openArchive(botId: string): void;
   archive(): Promise<void>;
+  /** Confirmation first: deleting a Bot destroys its chat history. */
+  openDelete(botId: string): void;
+  deleteBot(): Promise<void>;
   restore(botId: string): Promise<void>;
   closeOverlay(): void;
   reroll(): void;

package/src/client/styles.css

@@ -70,6 +70,11 @@
   color: var(--frock-text);
 }
 
+.flock-lifecycle--danger,
+.flock-lifecycle--danger:hover {
+  color: var(--frock-danger-text);
+}
+
 /*
  * Pinned Bots. A wrapping row of large round tiles above the labelled groups,
  * each one a whole Bot rather than a line of text about it.
@@ -624,6 +629,17 @@
   background: var(--frock-action-primary-pressed);
 }
 
+/* The one irreversible action in this dialog set, and it says so. */
+.flock-actions .danger {
+  border-color: var(--frock-danger-strong);
+  background: var(--frock-danger-strong);
+  color: var(--frock-on-accent);
+}
+
+.flock-actions .danger:hover {
+  background: var(--frock-danger-text);
+}
+
 @media (max-width: 600px) {
   .flock-backdrop {
     padding: 10px;

package/src/shared.test.ts

@@ -4,11 +4,13 @@ import {
   decodeBotIdentityViewV1,
   decodeBotLifecycleCommandV1,
   decodeBotLifecycleReceiptV1,
+  decodeBotLifecycleViewV1,
   decodeBotMembershipViewV1,
   decodeBotRegistrationV1,
   decodeCreateBotCommandV1,
   decodeDirectoryViewV1,
   decodeSheepRecipeV1,
+  lifecycleTargetStatusV1,
   migrateStoredBotDirectoryV1,
   randomSheepRecipeV1,
   sheepCatalog,
@@ -38,6 +40,45 @@ describe("Flock v1 contracts", () => {
     ).toThrow("unknown or missing field");
   });
 
+  test("strictly decodes the delete command and its terminal status", () => {
+    const command = {
+      schemaVersion: 1 as const,
+      type: "bot/delete" as const,
+      commandId: "delete-1",
+      botId: "alpha",
+    };
+    expect(decodeBotLifecycleCommandV1(command)).toEqual(command);
+    expect(lifecycleTargetStatusV1("bot/delete")).toBe("deleted");
+    expect(lifecycleTargetStatusV1("bot/archive")).toBe("archived");
+    expect(lifecycleTargetStatusV1("bot/restore")).toBe("active");
+    expect(
+      decodeBotLifecycleReceiptV1({
+        schemaVersion: 1,
+        commandId: "delete-1",
+        botId: "alpha",
+        status: "applied",
+        lifecycle: {
+          schemaVersion: 1,
+          botId: "alpha",
+          status: "deleted",
+          revision: 1,
+        },
+      }),
+    ).toMatchObject({ lifecycle: { status: "deleted" } });
+    // A near-miss is still a rejection: the union is exact, not prefixed.
+    expect(() =>
+      decodeBotLifecycleCommandV1({ ...command, type: "bot/delete-all" }),
+    ).toThrow("unsupported Bot lifecycle command");
+    expect(() =>
+      decodeBotLifecycleViewV1({
+        schemaVersion: 1,
+        botId: "alpha",
+        status: "removed",
+        revision: 1,
+      }),
+    ).toThrow("Bot lifecycle is invalid");
+  });
+
   test("strictly decodes archive and restore DTOs", () => {
     const command = {
       schemaVersion: 1 as const,

package/src/shared.ts

@@ -52,7 +52,12 @@ export interface BotDirectoryViewV1 {
   revision: number;
   bots: BotRegistrationV1[];
 }
-export type BotLifecycleStatusV1 = "active" | "archived";
+/**
+ * A Bot's durable lifecycle. `deleted` is terminal: the Bot and its chat
+ * history are gone, and the status survives only as a tombstone so a late
+ * command or Turn is refused rather than resurrecting the Bot.
+ */
+export type BotLifecycleStatusV1 = "active" | "archived" | "deleted";
 export interface BotLifecycleViewV1 {
   schemaVersion: 1;
   botId: string;
@@ -65,7 +70,7 @@ export interface BotLifecycleDirectoryViewV1 {
 }
 export interface BotLifecycleCommandV1 {
   schemaVersion: 1;
-  type: "bot/archive" | "bot/restore";
+  type: "bot/archive" | "bot/restore" | "bot/delete";
   commandId: string;
   botId: string;
 }
@@ -162,6 +167,19 @@ export class FlockConflictError extends Error {
     this.name = "FlockConflictError";
   }
 }
+/**
+ * The status a lifecycle command settles on. The saga on the User side and the
+ * Bot Durable Object both read the target from here rather than each writing
+ * out the same mapping.
+ */
+export function lifecycleTargetStatusV1(
+  type: BotLifecycleCommandV1["type"],
+): BotLifecycleStatusV1 {
+  if (type === "bot/archive") return "archived";
+  if (type === "bot/delete") return "deleted";
+  return "active";
+}
+
 export class BotNotFoundError extends Error {
   constructor(readonly botId: string) {
     super(`Bot "${botId}" is not registered`);
@@ -456,7 +474,9 @@ export function decodeBotLifecycleCommandV1(
   exact(value, ["schemaVersion", "type", "commandId", "botId"]);
   if (
     value.schemaVersion !== 1 ||
-    (value.type !== "bot/archive" && value.type !== "bot/restore")
+    (value.type !== "bot/archive" &&
+      value.type !== "bot/restore" &&
+      value.type !== "bot/delete")
   )
     throw new FlockDecodeError("unsupported Bot lifecycle command");
   return {
@@ -472,7 +492,9 @@ export function decodeBotLifecycleViewV1(input: unknown): BotLifecycleViewV1 {
   exact(value, ["schemaVersion", "botId", "status", "revision"]);
   if (
     value.schemaVersion !== 1 ||
-    (value.status !== "active" && value.status !== "archived")
+    (value.status !== "active" &&
+      value.status !== "archived" &&
+      value.status !== "deleted")
   )
     throw new FlockDecodeError("Bot lifecycle is invalid");
   return {

package/src/user.test.ts

@@ -287,6 +287,110 @@ describe("Flock User contribution", () => {
     ).toMatchObject({ status: "applied", lifecycle: { status: "archived" } });
   });
 
+  test("removes a deleted Bot from the directory and queues its sweep", async () => {
+    const storage = new MemoryStorage();
+    let botStatus: "active" | "deleted" = "active";
+    const contribution = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: (_userId, lifecycleCommand) => {
+        botStatus = "deleted";
+        return Promise.resolve({
+          schemaVersion: 1,
+          commandId: lifecycleCommand.commandId,
+          botId: lifecycleCommand.botId,
+          status: "applied",
+          lifecycle: {
+            schemaVersion: 1,
+            botId: lifecycleCommand.botId,
+            status: "deleted",
+            revision: 1,
+          },
+        });
+      },
+      readBotLifecycle: (_userId, botId) =>
+        Promise.resolve({
+          schemaVersion: 1,
+          botId,
+          status: botStatus,
+          revision: 1,
+        }),
+    });
+    await contribution.createBot("user-1", command());
+    const remove = {
+      schemaVersion: 1 as const,
+      type: "bot/delete" as const,
+      commandId: "delete-1",
+      botId: "alpha",
+    };
+    const applied = await contribution.executeLifecycle("user-1", remove);
+    expect(applied).toMatchObject({
+      status: "applied",
+      lifecycle: { status: "deleted" },
+    });
+    // Gone from every read the sidebar, the fan-outs and the debug surface do.
+    expect(await contribution.listBots()).toMatchObject({
+      revision: 2,
+      bots: [],
+    });
+    expect(await contribution.listBotLifecycles()).toEqual({
+      schemaVersion: 1,
+      lifecycles: [],
+    });
+    expect(storage.values.has("flock:lifecycle:alpha")).toBe(false);
+    // The User-scoped projections are somebody else's to sweep, so the
+    // removal leaves the to-do entry that says so.
+    expect(await contribution.listDeletedBotIds()).toEqual(["alpha"]);
+    await contribution.forgetDeletedBot("alpha");
+    expect(await contribution.listDeletedBotIds()).toEqual([]);
+    // Replaying the command settles from the stored receipt rather than
+    // reporting a Bot that is no longer registered.
+    expect(await contribution.executeLifecycle("user-1", remove)).toEqual(
+      applied,
+    );
+    // A fresh delete of a Bot that is already gone is a plain 404.
+    await expect(
+      contribution.executeLifecycle("user-1", {
+        ...remove,
+        commandId: "delete-2",
+      }),
+    ).rejects.toThrow('Bot "alpha" is not registered');
+  });
+
+  test("finishes a half-done delete from the User alarm", async () => {
+    const storage = new MemoryStorage();
+    // The Bot tore itself down but the reply never arrived, so the saga is the
+    // only thing that knows the registration still has to go.
+    const contribution = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: () => Promise.reject(new Error("response lost")),
+      readBotLifecycle: (_userId, botId) =>
+        Promise.resolve({
+          schemaVersion: 1,
+          botId,
+          status: "deleted",
+          revision: 1,
+        }),
+    });
+    await contribution.createBot("user-1", command());
+    const failing = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: () => Promise.reject(new Error("response lost")),
+      readBotLifecycle: () => Promise.reject(new Error("Bot unavailable")),
+    });
+    expect(
+      await failing.executeLifecycle("user-1", {
+        schemaVersion: 1,
+        type: "bot/delete",
+        commandId: "delete-alarm",
+        botId: "alpha",
+      }),
+    ).toMatchObject({ status: "pending" });
+    expect((await contribution.listBots()).bots).toHaveLength(1);
+    await contribution.alarm();
+    expect((await contribution.listBots()).bots).toEqual([]);
+    expect(await contribution.listDeletedBotIds()).toEqual(["alpha"]);
+  });
+
   test("reconciles uncorrelated, pending, and wrong-target Bot replies", async () => {
     for (const variant of [
       "wrong-command",

package/src/user.ts

@@ -11,6 +11,7 @@ import {
   decodeStoredBotLifecycleReceiptV1,
   decodeStoredFlockReceiptV1,
   flockCommandFingerprint,
+  lifecycleTargetStatusV1,
   migrateStoredBotDirectoryV1,
   randomSheepRecipeV1,
   type BotDirectoryViewV1,
@@ -30,6 +31,18 @@ const LIFECYCLE_PREFIX = "flock:lifecycle:";
 const LIFECYCLE_RECEIPT_PREFIX = "flock:lifecycle-receipt:";
 const LIFECYCLE_SAGA_PREFIX = "flock:lifecycle-saga:";
 const LIFECYCLE_OPERATION_PREFIX = "flock:lifecycle-operation:";
+/**
+ * One key per Bot whose registration this object has removed, and whose
+ * User-scoped projections — the transcript index and the audit table — have
+ * not yet been swept.
+ *
+ * The saga can settle a delete on its alarm rather than on the command that
+ * started it, and the projections live outside this Package. Without a durable
+ * to-do list the sweep would be lost with the call that missed it, so the
+ * removal writes one and the application clears it once the projections are
+ * gone.
+ */
+const DELETED_PREFIX = "flock:deleted:";
 export interface FlockUserTransaction {
   get<T>(key: string): Promise<T | undefined>;
   put<T>(key: string, value: T): Promise<void>;
@@ -207,6 +220,53 @@ export class FlockUserBackendContribution {
     });
   }
 
+  /**
+   * Drops one Bot out of the directory and out of the lifecycle projection,
+   * and records that its User-scoped projections still need sweeping.
+   *
+   * Idempotent by construction: a directory that no longer holds the Bot is
+   * left at its current revision, and both deletes and the tombstone write are
+   * safe to repeat.
+   */
+  private async removeRegistration(
+    storage: FlockUserTransaction,
+    botId: string,
+  ): Promise<void> {
+    const currentValue = await storage.get<unknown>(DIRECTORY_KEY);
+    const current =
+      currentValue === undefined
+        ? initialDirectory()
+        : decodeDirectoryViewV1(migrateStoredBotDirectoryV1(currentValue));
+    if (current.bots.some((bot) => bot.botId === botId)) {
+      await storage.put(DIRECTORY_KEY, {
+        ...current,
+        revision: current.revision + 1,
+        bots: current.bots.filter((bot) => bot.botId !== botId),
+      } satisfies BotDirectoryViewV1);
+    }
+    await storage.delete(`${LIFECYCLE_PREFIX}${botId}`);
+    await storage.put(`${DELETED_PREFIX}${botId}`, {
+      schemaVersion: 1,
+      botId,
+    });
+  }
+
+  /**
+   * Bots whose registration is gone but whose User-scoped projections have not
+   * been swept yet. The application sweeps and then calls `forgetDeletedBot`.
+   */
+  async listDeletedBotIds(): Promise<string[]> {
+    const entries = await this.host.storage.list<unknown>({
+      prefix: DELETED_PREFIX,
+    });
+    return [...entries.keys()].map((key) => key.slice(DELETED_PREFIX.length));
+  }
+
+  /** The sweep is done; drop the to-do entry. */
+  async forgetDeletedBot(botId: string): Promise<void> {
+    await this.host.storage.delete(`${DELETED_PREFIX}${botId}`);
+  }
+
   async listBotLifecycles(): Promise<BotLifecycleDirectoryViewV1> {
     const directory = await this.listBots();
     const lifecycles = await Promise.all(
@@ -317,7 +377,7 @@ export class FlockUserBackendContribution {
       return decodeStoredBotLifecycleReceiptV1(receipt).receipt;
     }
     const saga = decodeStoredLifecycleSagaV1(sagaValue);
-    const target = saga.command.type === "bot/archive" ? "archived" : "active";
+    const target = lifecycleTargetStatusV1(saga.command.type);
     let outcome: BotLifecycleReceiptV1 | undefined;
     let reconcileMarker = false;
     try {
@@ -383,12 +443,21 @@ export class FlockUserBackendContribution {
       const currentSaga = decodeStoredLifecycleSagaV1(currentSagaValue);
       if (currentSaga.fingerprint !== saga.fingerprint)
         throw new FlockDecodeError(`command ID collision: ${commandId}`);
-      await storage.put({
-        [`${LIFECYCLE_PREFIX}${saga.command.botId}`]: outcome!.lifecycle,
-        [`${LIFECYCLE_RECEIPT_PREFIX}${commandId}`]: {
-          fingerprint: saga.fingerprint,
-          receipt: outcome,
-        },
+      if (outcome!.lifecycle.status === "deleted") {
+        // The Bot has torn itself down, so the registration leaves the
+        // directory in the same transaction that settles the receipt: the
+        // sidebar, every fan-out and the debug surface all read the directory,
+        // and none of them may see a Bot whose history is already gone.
+        await this.removeRegistration(storage, saga.command.botId);
+      } else {
+        await storage.put(
+          `${LIFECYCLE_PREFIX}${saga.command.botId}`,
+          outcome!.lifecycle,
+        );
+      }
+      await storage.put(`${LIFECYCLE_RECEIPT_PREFIX}${commandId}`, {
+        fingerprint: saga.fingerprint,
+        receipt: outcome,
       });
       await storage.delete(`${LIFECYCLE_SAGA_PREFIX}${commandId}`);
       await storage.delete(