@frockbot/plugin-flock 0.1.4 → 0.2.1

package/package.json

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

package/src/shared.test.ts

@@ -9,6 +9,7 @@ import {
   decodeCreateBotCommandV1,
   decodeDirectoryViewV1,
   decodeSheepRecipeV1,
+  migrateStoredBotDirectoryV1,
   randomSheepRecipeV1,
   sheepCatalog,
   sheepLayerIds,
@@ -184,3 +185,75 @@ describe("Flock v1 contracts", () => {
     ).toThrow("duplicate IDs");
   });
 });
+
+describe("stored Bot directory migration", () => {
+  const sheep = randomSheepRecipeV1(() => 0);
+  const legacyBot = () => ({
+    schemaVersion: 1,
+    botId: "alpha",
+    registeredAt: "2026-08-29T00:00:00.000Z",
+    initialName: "Alpha",
+    initialModel: { connectionId: "openai", providerModelId: "gpt-5" },
+    initialModelBinding: {
+      assignment: {
+        assignmentId: "assignment-1",
+        packageId: "models",
+        capabilityId: "chat",
+        connectionId: "openai",
+        state: "enabled",
+      },
+      generation: "generation-1",
+    },
+    initialAssignments: [],
+    sheep,
+  });
+
+  test("drops the retired model and Assignment seed fields", () => {
+    const stored = { schemaVersion: 1, revision: 1, bots: [legacyBot()] };
+    // Without migration this is exactly the failure the sidebar reported.
+    expect(() => decodeDirectoryViewV1(stored)).toThrow(
+      "unknown or missing field",
+    );
+    const directory = decodeDirectoryViewV1(
+      migrateStoredBotDirectoryV1(stored),
+    );
+    expect(directory.revision).toBe(1);
+    const [bot] = directory.bots;
+    expect(bot).toMatchObject({ botId: "alpha", initialName: "Alpha" });
+    for (const key of [
+      "initialModel",
+      "initialModelBinding",
+      "initialAssignments",
+    ])
+      expect(Object.hasOwn(bot!, key)).toBe(false);
+    // Migration is read-time: the durable record itself is left alone.
+    expect(Object.hasOwn(stored.bots[0]!, "initialModel")).toBe(true);
+  });
+
+  test("returns a current-shape record untouched", () => {
+    const current = {
+      schemaVersion: 1,
+      revision: 0,
+      bots: [
+        {
+          schemaVersion: 1,
+          botId: "alpha",
+          registeredAt: "2026-08-29T00:00:00.000Z",
+          initialName: "Alpha",
+          sheep,
+        },
+      ],
+    };
+    expect(migrateStoredBotDirectoryV1(current)).toBe(current);
+  });
+
+  test("leaves records it does not recognise for the decoder to reject", () => {
+    expect(migrateStoredBotDirectoryV1(undefined)).toBeUndefined();
+    expect(migrateStoredBotDirectoryV1("nope")).toBe("nope");
+    expect(() =>
+      decodeDirectoryViewV1(
+        migrateStoredBotDirectoryV1({ schemaVersion: 1, revision: 0 }),
+      ),
+    ).toThrow("unknown or missing field");
+  });
+});

package/src/shared.ts

@@ -361,6 +361,57 @@ export function decodeBotRegistrationV1(input: unknown): BotRegistrationV1 {
   };
 }
 
+/**
+ * Fields a Bot registration seed carried before per-Bot model bindings and
+ * Assignments were removed (commit 03034e0). A directory written before that
+ * refactor still holds them on disk, and the exact-field decoder rejects every
+ * read of it — which takes out the sidebar and Bot creation together, because
+ * both start by decoding the stored directory. Migration drops the fields
+ * without interpreting them: a Bot's model and tools now resolve from the
+ * User's enabled Packages and Connections at its next admitted Turn (ADR 0019).
+ */
+const PRE_ACCOUNT_WIDE_REGISTRATION_FIELDS_V1 = [
+  "initialModel",
+  "initialModelBinding",
+  "initialAssignments",
+] as const;
+
+/** A durable record only ever deserializes to a plain object; nothing else. */
+function storedPlainRecordV1(
+  value: unknown,
+): Record<string, unknown> | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return undefined;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/**
+ * Migrates one raw stored Bot directory across known durable shapes before the
+ * current exact-field decoder sees it. A record already in the current shape is
+ * returned untouched, so this is safe to apply on every read.
+ */
+export function migrateStoredBotDirectoryV1(stored: unknown): unknown {
+  const directory = storedPlainRecordV1(stored);
+  if (!directory || !Array.isArray(directory.bots)) return stored;
+  let changed = false;
+  const bots = directory.bots.map((storedBot) => {
+    const bot = storedPlainRecordV1(storedBot);
+    if (!bot) return storedBot;
+    const removed = PRE_ACCOUNT_WIDE_REGISTRATION_FIELDS_V1.filter((key) =>
+      Object.hasOwn(bot, key),
+    );
+    if (removed.length === 0) return storedBot;
+    changed = true;
+    const next = { ...bot };
+    for (const key of removed) delete next[key];
+    return next;
+  });
+  return changed ? { ...directory, bots } : stored;
+}
+
 export function decodeBotMembershipViewV1(input: unknown): BotMembershipViewV1 {
   const value = record(input, "Bot membership");
   exact(value, ["schemaVersion", "botId", "registered"]);

package/src/user.test.ts

@@ -126,6 +126,53 @@ describe("Flock User contribution", () => {
     );
   });
 
+  test("lists and extends a directory stored before Bots lost their model seed", async () => {
+    const storage = new MemoryStorage();
+    const contribution = createFlockUserBackendContribution({
+      storage,
+      now: () => new Date("2026-09-02T00:00:00.000Z"),
+      commandBotLifecycle: () => Promise.reject(new Error("not used")),
+      readBotLifecycle: () => Promise.reject(new Error("not used")),
+    });
+    await storage.put("flock:directory:v1", {
+      schemaVersion: 1,
+      revision: 1,
+      bots: [
+        {
+          schemaVersion: 1,
+          botId: "legacy",
+          registeredAt: "2026-08-29T00:00:00.000Z",
+          initialName: "Legacy",
+          initialModel: { connectionId: "openai", providerModelId: "gpt-5" },
+          initialAssignments: [],
+          sheep: randomSheepRecipeV1(() => 0),
+        },
+      ],
+    });
+    const directory = await contribution.listBots();
+    expect(directory.bots.map((bot) => bot.botId)).toEqual(["legacy"]);
+    expect(Object.hasOwn(directory.bots[0]!, "initialModel")).toBe(false);
+    // Creating a Bot reads the same record, so it died on the same field.
+    const receipt = await contribution.createBot(
+      "user-1",
+      command("create-1", 1),
+    );
+    expect(receipt.status).toBe("applied");
+    const migrated = await contribution.listBots();
+    expect(migrated.bots.map((bot) => bot.botId)).toEqual(["legacy", "alpha"]);
+    // The write settles the migrated shape durably.
+    expect(
+      Object.hasOwn(
+        (
+          storage.values.get("flock:directory:v1") as {
+            bots: Record<string, unknown>[];
+          }
+        ).bots[0]!,
+        "initialModel",
+      ),
+    ).toBe(false);
+  });
+
   test("coordinates archive through durable intent and reconciles a lost response", async () => {
     const storage = new MemoryStorage();
     let botStatus: "active" | "archived" = "active";

package/src/user.ts

@@ -11,6 +11,7 @@ import {
   decodeStoredBotLifecycleReceiptV1,
   decodeStoredFlockReceiptV1,
   flockCommandFingerprint,
+  migrateStoredBotDirectoryV1,
   randomSheepRecipeV1,
   type BotDirectoryViewV1,
   type BotLifecycleCommandV1,
@@ -99,7 +100,9 @@ export class FlockUserBackendContribution {
   async listBots(): Promise<BotDirectoryViewV1> {
     const stored = await this.host.storage.get<unknown>(DIRECTORY_KEY);
     return structuredClone(
-      stored === undefined ? initialDirectory() : decodeDirectoryViewV1(stored),
+      stored === undefined
+        ? initialDirectory()
+        : decodeDirectoryViewV1(migrateStoredBotDirectoryV1(stored)),
     );
   }
 
@@ -138,7 +141,7 @@ export class FlockUserBackendContribution {
       const current =
         currentValue === undefined
           ? initialDirectory()
-          : decodeDirectoryViewV1(currentValue);
+          : decodeDirectoryViewV1(migrateStoredBotDirectoryV1(currentValue));
       if (current.revision !== command.expectedRevision)
         throw new FlockConflictError(current.revision);
       let receipt: FlockReceiptV1;
@@ -248,7 +251,7 @@ export class FlockUserBackendContribution {
       const directory =
         directoryValue === undefined
           ? initialDirectory()
-          : decodeDirectoryViewV1(directoryValue);
+          : decodeDirectoryViewV1(migrateStoredBotDirectoryV1(directoryValue));
       if (!directory.bots.some((bot) => bot.botId === command.botId))
         throw new BotNotFoundError(command.botId);
       const lifecycleValue = await storage.get<unknown>(