@frockbot/plugin-subagents 0.1.4 → 0.2.1

package/package.json

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

package/src/records.test.ts

@@ -5,6 +5,7 @@ import {
   decodeTaskModelBindingV1,
   decodeTaskOutcomeV1,
   decodeTaskRecordV1,
+  migrateStoredTaskRecordV1,
   taskPromptDigestV1,
   utf8ByteLengthV1,
   TASK_ATTACHMENT_LIMIT_V1,
@@ -73,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 = [
@@ -381,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,7 +6,7 @@ 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: {
@@ -39,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.
  *