@frockbot/plugin-subagents 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-subagents",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -27,8 +27,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-agent-loop": "0.1.3",
-    "@frockbot/kernel-contracts": "0.1.3",
+    "@frockbot/kernel-agent-loop": "0.2.0",
+    "@frockbot/kernel-contracts": "0.2.0",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/agent.test.ts

@@ -23,7 +23,6 @@ import {
 import type { ToolExecutionContext } from "@frockbot/kernel-contracts";
 
 const BINDING: TaskModelBindingV1 = {
-  assignmentId: "asg-1",
   packageId: "provider-ollama-cloud",
   capabilityId: "ollama-cloud-models",
   connectionId: "conn-1",
@@ -55,7 +54,7 @@ function tool(
     turnType,
     models: () =>
       subagentModelCatalogV1({
-        assignments: [BINDING],
+        bindings: [BINDING],
         defaultBinding: BINDING,
         turnType,
       }),
@@ -194,7 +193,7 @@ describe("the <available_subagent_models> section", () => {
     const section = createSubagentModelsPromptSectionV1({
       models: () =>
         subagentModelCatalogV1({
-          assignments: [BINDING],
+          bindings: [BINDING],
           defaultBinding: BINDING,
           turnType: "chat",
         }),
@@ -210,7 +209,7 @@ describe("the <available_subagent_models> section", () => {
     );
   });
 
-  test("renders nothing for a Bot with no enabled model Assignment", async () => {
+  test("renders nothing for a Bot with no enabled model binding", async () => {
     const section = createSubagentModelsPromptSectionV1({ models: () => [] });
     expect(
       await section.render({

package/src/agent.ts

@@ -244,7 +244,7 @@ export interface SubagentsRuntimeHostV1 {
    * into each step of its Turn and folds what it gets into that step's inputs.
    */
   drainMessages?(): Promise<readonly PendingTaskMessageV1[]>;
-  /** The models this Turn may dispatch onto, resolved from enabled Assignments. */
+  /** The models this Turn may dispatch onto, resolved from enabled bindings. */
   models(): readonly SubagentModelOptionV1[];
   dispatch(
     request: SubagentDispatchRequestV1,

package/src/models.test.ts

@@ -7,23 +7,22 @@ import {
 } from "./models.js";
 import type { TaskModelBindingV1 } from "./records.js";
 
-function assignment(
+function binding(
   packageId: string,
   providerModelId: string,
-  assignmentId = `asg-${providerModelId}`,
+  connectionId = `conn-${providerModelId}`,
 ): TaskModelBindingV1 {
   return {
-    assignmentId,
     packageId,
     capabilityId: `${packageId}-models`,
-    connectionId: `conn-${assignmentId}`,
+    connectionId,
     provider: packageId,
     providerModelId,
   };
 }
 
-const DEFAULT = assignment("provider-ollama-cloud", "glm-5.3-flash:cloud");
-const SECOND = assignment("provider-foundation", "sand-automation");
+const DEFAULT = binding("provider-ollama-cloud", "glm-5.3-flash:cloud");
+const SECOND = binding("provider-foundation", "sand-automation");
 
 describe("the slug", () => {
   test("is the Package and the provider model, and nothing else", () => {
@@ -34,9 +33,9 @@ describe("the slug", () => {
 });
 
 describe("the catalog one Turn is offered", () => {
-  test("is built from the Bot's enabled model Assignments, default first", () => {
+  test("is built from the User's enabled model bindings, default first", () => {
     const catalog = subagentModelCatalogV1({
-      assignments: [SECOND, DEFAULT],
+      bindings: [SECOND, DEFAULT],
       defaultBinding: DEFAULT,
       turnType: "chat",
     });
@@ -48,15 +47,15 @@ describe("the catalog one Turn is offered", () => {
     expect(catalog[1]?.isDefault).toBe(false);
   });
 
-  test("keeps one entry per slug when two Assignments name one model", () => {
-    const twin = assignment(
+  test("keeps one entry per slug when two bindings name one model", () => {
+    const twin = binding(
       "provider-ollama-cloud",
       "glm-5.3-flash:cloud",
       "asg-twin",
     );
     expect(
       subagentModelCatalogV1({
-        assignments: [DEFAULT, twin],
+        bindings: [DEFAULT, twin],
         defaultBinding: DEFAULT,
         turnType: "chat",
       }),
@@ -66,7 +65,7 @@ describe("the catalog one Turn is offered", () => {
   test("renders exactly one slug on an automation turn — the Bot's own binding", () => {
     for (const turnType of ["automation", "subagent"] as const) {
       const catalog = subagentModelCatalogV1({
-        assignments: [SECOND, DEFAULT],
+        bindings: [SECOND, DEFAULT],
         defaultBinding: DEFAULT,
         turnType,
       });
@@ -76,16 +75,16 @@ describe("the catalog one Turn is offered", () => {
     }
   });
 
-  test("is empty for a Bot with no enabled model Assignment", () => {
-    expect(
-      subagentModelCatalogV1({ assignments: [], turnType: "chat" }),
-    ).toEqual([]);
+  test("is empty for a Bot with no enabled model binding", () => {
+    expect(subagentModelCatalogV1({ bindings: [], turnType: "chat" })).toEqual(
+      [],
+    );
   });
 });
 
 describe("resolving a `Task` model against the catalog", () => {
   const catalog = subagentModelCatalogV1({
-    assignments: [SECOND, DEFAULT],
+    bindings: [SECOND, DEFAULT],
     defaultBinding: DEFAULT,
     turnType: "chat",
   });
@@ -98,14 +97,14 @@ describe("resolving a `Task` model against the catalog", () => {
     });
   });
 
-  test("a named slug resolves to the Assignment that carries it", () => {
+  test("a named slug resolves to the binding that carries it", () => {
     const resolved = resolveSubagentModelV1(
       catalog,
       "provider-foundation/sand-automation",
     );
     expect(resolved).toMatchObject({
       status: "resolved",
-      model: { binding: { assignmentId: SECOND.assignmentId } },
+      model: { binding: { connectionId: SECOND.connectionId } },
     });
   });
 
@@ -119,7 +118,7 @@ describe("resolving a `Task` model against the catalog", () => {
 
   test("an automation turn refuses the second slug it was not shown", () => {
     const narrowed = subagentModelCatalogV1({
-      assignments: [SECOND, DEFAULT],
+      bindings: [SECOND, DEFAULT],
       defaultBinding: DEFAULT,
       turnType: "automation",
     });
@@ -128,7 +127,7 @@ describe("resolving a `Task` model against the catalog", () => {
     ).toMatchObject({ status: "refused" });
   });
 
-  test("a Bot with no model Assignment is refused rather than defaulted", () => {
+  test("a Bot with no model binding is refused rather than defaulted", () => {
     expect(resolveSubagentModelV1([], undefined)).toMatchObject({
       status: "refused",
     });
@@ -142,7 +141,7 @@ describe("<available_subagent_models>", () => {
   test("renders one element per slug and marks the default", () => {
     const rendered = renderAvailableSubagentModelsPromptV1(
       subagentModelCatalogV1({
-        assignments: [SECOND, DEFAULT],
+        bindings: [SECOND, DEFAULT],
         defaultBinding: DEFAULT,
         turnType: "chat",
       }),
@@ -159,7 +158,7 @@ describe("<available_subagent_models>", () => {
   test("renders exactly one model line on an automation turn", () => {
     const rendered = renderAvailableSubagentModelsPromptV1(
       subagentModelCatalogV1({
-        assignments: [SECOND, DEFAULT],
+        bindings: [SECOND, DEFAULT],
         defaultBinding: DEFAULT,
         turnType: "automation",
       }),

package/src/models.ts

@@ -7,8 +7,8 @@
 // default binding, GrokBot's `sand-automation` — and an omitted `model`
 // inherits the parent's binding rather than picking anything.
 //
-// A slug is `<packageId>/<providerModelId>`. It names an *Assignment*, not a
-// provider: resolution runs against the Bot's enabled model Assignments, so a
+// A slug is `<packageId>/<providerModelId>`. It names an enabled binding, not a
+// provider: resolution runs against the User's enabled model Capabilities, so a
 // slug the Bot invents resolves to nothing and the dispatch is refused.
 
 import type { TurnTypeV1 } from "@frockbot/kernel-contracts";
@@ -22,7 +22,7 @@ import {
 /** Most slugs the prompt section will ever render. A catalog, not a directory. */
 export const SUBAGENT_MODEL_CATALOG_LIMIT_V1 = 32;
 
-/** One offerable model, projected from one enabled model Assignment. */
+/** One offerable model, projected from one enabled model binding. */
 export interface SubagentModelOptionV1 {
   slug: string;
   binding: TaskModelBindingV1;
@@ -41,7 +41,7 @@ export function subagentModelSlugV1(binding: {
  * The turn types that may see more than one slug.
  *
  * An `automation` or `subagent` turn renders exactly one — the Bot's default
- * binding. It is not a permission (the Assignments are the same either way); it
+ * binding. It is not a permission (the enabled set is the same either way); it
  * is that an unattended Turn choosing a model per task is a decision with
  * nobody to answer for it.
  */
@@ -52,12 +52,12 @@ export function subagentModelsAreNarrowedV1(turnType: TurnTypeV1): boolean {
 /**
  * The catalog one Turn is offered.
  *
- * `assignments` are the Bot's enabled model Assignments, already resolved by
+ * `bindings` are the User's enabled model bindings, already resolved by
  * the Shell; `defaultBinding` is the Bot's own durable binding. A duplicate
- * slug is kept once — two Assignments naming one provider model are one choice.
+ * slug is kept once — two bindings naming one provider model are one choice.
  */
 export function subagentModelCatalogV1(input: {
-  assignments: readonly TaskModelBindingV1[];
+  bindings: readonly TaskModelBindingV1[];
   defaultBinding?: TaskModelBindingV1;
   turnType: TurnTypeV1;
 }): SubagentModelOptionV1[] {
@@ -74,10 +74,10 @@ export function subagentModelCatalogV1(input: {
     options.push({ slug, binding, isDefault: slug === defaultSlug });
   };
   // The default first, so the one slug a narrowed turn renders is always the
-  // Bot's own binding and never whichever Assignment happens to sort first.
+  // Bot's own binding and never whichever binding happens to sort first.
   if (input.defaultBinding) consider(input.defaultBinding);
   if (!subagentModelsAreNarrowedV1(input.turnType)) {
-    for (const assignment of input.assignments) consider(assignment);
+    for (const binding of input.bindings) consider(binding);
   }
   return subagentModelsAreNarrowedV1(input.turnType)
     ? options.slice(0, 1)
@@ -106,7 +106,7 @@ export function resolveSubagentModelV1(
       return {
         status: "refused",
         reason:
-          "this Bot has no enabled model Assignment, so a subagent has no model to run on",
+          "this Bot has no enabled model binding, so a subagent has no model to run on",
       };
     }
     return {
@@ -122,7 +122,7 @@ export function resolveSubagentModelV1(
       reason:
         offered.length > 0
           ? `model "${requested}" is not one of this Turn's subagent models (${offered})`
-          : `model "${requested}" is not available: this Bot has no enabled model Assignment`,
+          : `model "${requested}" is not available: this Bot has no enabled model binding`,
     };
   }
   return {

package/src/records.test.ts

@@ -5,6 +5,7 @@ import {
   decodeTaskModelBindingV1,
   decodeTaskOutcomeV1,
   decodeTaskRecordV1,
+  migrateStoredTaskRecordV1,
   taskPromptDigestV1,
   utf8ByteLengthV1,
   TASK_ATTACHMENT_LIMIT_V1,
@@ -18,7 +19,6 @@ import {
 } from "./records.js";
 
 const BINDING = {
-  assignmentId: "asg-1",
   packageId: "provider-ollama-cloud",
   capabilityId: "ollama-cloud-models",
   connectionId: "conn-1",
@@ -74,6 +74,35 @@ describe("the bounds the plan states", () => {
 });
 
 describe("TaskRecordV1 decodes exactly", () => {
+  test("migrates the pre-account-wide model binding and keeps unknown fields strict", () => {
+    // Literal durable shape from ff25b5c84d963d9c25fb3e13aaeb9688fabc10c1.
+    const stored = taskRecord({
+      model: {
+        binding: {
+          assignmentId: "asg-1",
+          ...BINDING,
+        },
+        slug: "provider-ollama-cloud/glm-5.3-flash",
+      },
+    });
+    expect(decodeTaskRecordV1(migrateStoredTaskRecordV1(stored))).toEqual(
+      taskRecord() as TaskRecordV1,
+    );
+
+    const unknown = taskRecord({
+      model: {
+        binding: { assignmentId: "asg-1", ...BINDING, unknown: true },
+        slug: "provider-ollama-cloud/glm-5.3-flash:cloud",
+      },
+    });
+    expect(() =>
+      decodeTaskRecordV1(migrateStoredTaskRecordV1(unknown)),
+    ).toThrow(/unknown field "unknown"/);
+
+    const current = taskRecord();
+    expect(migrateStoredTaskRecordV1(current)).toBe(current);
+  });
+
   test("accepts a queued record and returns it field for field", () => {
     const decoded = decodeTaskRecordV1(taskRecord());
     expect(decoded).toEqual(taskRecord() as TaskRecordV1);

package/src/records.ts

@@ -8,8 +8,8 @@
 // therefore parent state.
 //
 // Every record is versioned and exact-field, decoded at the seam it crosses.
-// There are no migrations: a record the current codec refuses is a visible
-// failure rather than something to reshape.
+// A previous stored shape crosses its explicit forward migration first; an
+// unknown shape remains a visible failure.
 
 /** The five subagent roles GrokBot declares (`docs/research/grokbot-computer.md` l.351–356). */
 export const TASK_TYPES_V1 = [
@@ -196,7 +196,6 @@ function subagentFlag(value: unknown, label: string): boolean {
  * resolves a binding of its own.
  */
 export interface TaskModelBindingV1 {
-  assignmentId: string;
   packageId: string;
   capabilityId: string;
   connectionId: string;
@@ -214,7 +213,6 @@ export function decodeTaskModelBindingV1(
   subagentExactKeys(
     candidate,
     [
-      "assignmentId",
       "packageId",
       "capabilityId",
       "connectionId",
@@ -225,11 +223,6 @@ export function decodeTaskModelBindingV1(
     label,
   );
   return {
-    assignmentId: subagentText(
-      candidate.assignmentId,
-      128,
-      `${label}.assignmentId`,
-    ),
     packageId: subagentText(candidate.packageId, 128, `${label}.packageId`),
     capabilityId: subagentText(
       candidate.capabilityId,
@@ -388,6 +381,68 @@ export interface TaskRecordV1 {
   outcome?: TaskOutcomeV1;
 }
 
+/**
+ * Migrates the raw Task shape stored before account-wide model binding. Commit
+ * 03034e0 removed `assignmentId` from the nested binding along with the
+ * Assignment feature; it is discarded here and never interpreted.
+ */
+export function migrateStoredTaskRecordV1(stored: unknown): unknown {
+  const task = migrationRecordV1(stored);
+  if (!task || migrationDataValueV1(task, "schemaVersion") !== 1) return stored;
+  const model = migrationRecordV1(migrationDataValueV1(task, "model"));
+  if (!model) return stored;
+  const binding = migrationRecordV1(migrationDataValueV1(model, "binding"));
+  if (!binding || !Object.hasOwn(binding, "assignmentId")) return stored;
+  const nextBinding = migrationCloneV1(binding, {}, ["assignmentId"]);
+  const nextModel = migrationCloneV1(model, { binding: nextBinding });
+  return migrationCloneV1(task, { model: nextModel });
+}
+
+function migrationRecordV1(
+  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;
+}
+
+function migrationDataValueV1(
+  value: Record<string, unknown>,
+  key: string,
+): unknown {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+
+function migrationCloneV1(
+  value: Record<string, unknown>,
+  changes: Readonly<Record<string, unknown>>,
+  removed: readonly string[] = [],
+): Record<string, unknown> {
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of removed) delete descriptors[key];
+  for (const [key, next] of Object.entries(changes)) {
+    const descriptor = descriptors[key];
+    descriptors[key] =
+      descriptor && "value" in descriptor
+        ? { ...descriptor, value: next }
+        : {
+            configurable: true,
+            enumerable: true,
+            value: next,
+            writable: true,
+          };
+  }
+  return Object.create(Object.getPrototypeOf(value), descriptors) as Record<
+    string,
+    unknown
+  >;
+}
+
 function decodeTaskAttachmentsV1(value: unknown, label: string): string[] {
   if (!Array.isArray(value)) {
     throw new SubagentDecodeError(`${label} must be an array`);

package/src/store.test.ts

@@ -6,11 +6,10 @@ import {
   TASK_DEADLINE_MS_V1,
   TASK_MESSAGE_QUEUE_LIMIT_V1,
 } from "./records.js";
-import { TASK_DESKTOP_LEASE_KEY } from "./storage-keys.js";
+import { TASK_DESKTOP_LEASE_KEY, taskKeyV1 } from "./storage-keys.js";
 
 const MODEL = {
   binding: {
-    assignmentId: "asg-1",
     packageId: "provider-ollama-cloud",
     capabilityId: "ollama-cloud-models",
     connectionId: "conn-1",
@@ -40,6 +39,45 @@ function request(
 }
 
 describe("admitting a task", () => {
+  test("reads an old model binding purely and writes it forward on lifecycle change", async () => {
+    const storage = createMemorySubagentStorageV1();
+    const store = new TaskStore(storage);
+    await store.admit(request("tk-migrate"));
+    const current = await storage.get<Record<string, unknown>>(
+      taskKeyV1("tk-migrate"),
+    );
+    if (!current) throw new Error("test task was not stored");
+    const currentModel = current.model as {
+      binding: Record<string, unknown>;
+      slug: string;
+    };
+    // `assignmentId` is the literal nested field removed by 03034e0.
+    const historical = {
+      ...current,
+      model: {
+        ...currentModel,
+        binding: { assignmentId: "asg-1", ...currentModel.binding },
+      },
+    };
+    await storage.put(taskKeyV1("tk-migrate"), historical);
+
+    await expect(store.read("tk-migrate")).resolves.toMatchObject({
+      status: "queued",
+      model: { binding: MODEL.binding },
+    });
+    expect(await storage.get<unknown>(taskKeyV1("tk-migrate"))).toEqual(
+      historical,
+    );
+
+    await store.markRunning("tk-migrate");
+    const written = await storage.get<{
+      status: string;
+      model: { binding: object };
+    }>(taskKeyV1("tk-migrate"));
+    expect(written).toMatchObject({ status: "running" });
+    expect(written?.model.binding).not.toHaveProperty("assignmentId");
+  });
+
   test("writes the record, the active key and the index row in one go", async () => {
     const storage = createMemorySubagentStorageV1();
     const store = new TaskStore(storage);

package/src/store.ts

@@ -22,6 +22,7 @@ import {
   decodeTaskRecordV1,
   isTaskIdV1,
   isTerminalTaskStatusV1,
+  migrateStoredTaskRecordV1,
   SubagentDecodeError,
   TASK_CONCURRENCY_PER_BOT_V1,
   TASK_DEADLINE_MS_V1,
@@ -139,7 +140,10 @@ export class TaskStore {
       if (existing !== undefined) {
         // A resumed Turn re-executing the same tool call reads its own task
         // back rather than dispatching a second child.
-        return { status: "replayed", record: decodeTaskRecordV1(existing) };
+        return {
+          status: "replayed",
+          record: decodeStoredTaskRecordV1(existing),
+        };
       }
       const active = await transaction.list<unknown>({
         prefix: TASK_ACTIVE_PREFIX,
@@ -266,7 +270,7 @@ export class TaskStore {
     const holder = await transaction.get<unknown>(taskKeyV1(lease.taskId));
     if (holder === undefined) return undefined;
     try {
-      if (isTerminalTaskStatusV1(decodeTaskRecordV1(holder).status)) {
+      if (isTerminalTaskStatusV1(decodeStoredTaskRecordV1(holder).status)) {
         return undefined;
       }
     } catch {
@@ -596,7 +600,7 @@ export class TaskStore {
     if (!isTaskIdV1(taskId)) throw new TaskNotFoundError(String(taskId));
     const stored = await reads.get<unknown>(taskKeyV1(taskId));
     if (stored === undefined) throw new TaskNotFoundError(taskId);
-    return decodeTaskRecordV1(stored);
+    return decodeStoredTaskRecordV1(stored);
   }
 
   async read(taskId: string): Promise<TaskRecordV1> {
@@ -671,12 +675,16 @@ export class TaskStore {
       // `task:` is a prefix of `task-active:` in neither direction — the
       // separator differs — but list is a byte-range scan, so be exact.
       if (!key.startsWith(TASK_PREFIX)) continue;
-      records.push(decodeTaskRecordV1(value));
+      records.push(decodeStoredTaskRecordV1(value));
     }
     return records;
   }
 }
 
+function decodeStoredTaskRecordV1(stored: unknown): TaskRecordV1 {
+  return decodeTaskRecordV1(migrateStoredTaskRecordV1(stored));
+}
+
 /**
  * The typed refusal a second `computerUse` dispatch reads.
  *