@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/src/tests/star-history-refresh.test.ts

@@ -0,0 +1,102 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ScriptContext } from "swarm-sdk";
+import { closeDb, getPageBySlug, initDb } from "../be/db";
+import refresh from "../be/seed-scripts/catalog/star-history-refresh";
+import { renderChart } from "../be/seed-scripts/catalog/star-history-renderer";
+import { registerCreatePageTool } from "../tools/create-page";
+
+const agentId = crypto.randomUUID();
+const server = new McpServer({ name: "star-history-test", version: "1" });
+registerCreatePageTool(server);
+const tool = (server as any)._registeredTools.create_page;
+beforeAll(() => initDb(":memory:"));
+afterAll(() => closeDb());
+
+function fixture() {
+  let cache: unknown;
+  let fail = false;
+  let calls = 0;
+  const ctx = {
+    stdlib: {
+      fetch: async (url: string, init: RequestInit) => {
+        calls++;
+        if (fail) return new Response("", { status: 503 });
+        const page = Number(new URL(url).searchParams.get("page"));
+        if ((init.headers as Record<string, string>)["If-None-Match"]) {
+          return new Response(null, { status: 304 });
+        }
+        return Response.json(
+          Array.from({ length: page === 1 ? 100 : 2 }, (_, i) => ({
+            starred_at: new Date(Date.UTC(2026, 0, 1) + (page * 100 + i) * 86400000).toISOString(),
+          })),
+          { headers: { ETag: `"page-${page}"` } },
+        );
+      },
+    },
+    swarm: {
+      kv_getOrNull: async () => (cache ? { value: cache } : null),
+      kv_set: async ({ value }: { value: unknown }) => {
+        cache = value;
+      },
+      page_create: async (args: unknown) => {
+        const res = await tool.handler(args, {
+          sessionId: "stars",
+          requestInfo: { headers: { "x-agent-id": agentId } },
+        });
+        return res.structuredContent;
+      },
+    },
+  } as unknown as ScriptContext;
+  return {
+    ctx,
+    fail: () => {
+      fail = true;
+    },
+    calls: () => calls,
+  };
+}
+
+test("paginated refresh, ETags, stable MCP page IDs/URLs, and cached fallback", async () => {
+  const f = fixture();
+  const first = await refresh({}, f.ctx);
+  expect(first.stars).toBe(102);
+  expect(f.calls()).toBe(2);
+  expect(first.stale).toBe(false);
+  const second = await refresh({}, f.ctx);
+  expect(second.notModified).toBe(2);
+  expect(second.pages).toEqual(first.pages);
+  for (const page of second.pages) {
+    const stored = await getPageBySlug(agentId, page.slug);
+    expect(stored?.contentType).toBe("image/svg+xml");
+    expect(stored?.authMode).toBe("public");
+    expect(stored?.body).toContain("102 stars");
+    expect(stored?.body).not.toContain("NaN");
+  }
+  f.fail();
+  const fallback = await refresh({}, f.ctx);
+  expect(fallback.stale).toBe(true);
+  expect(fallback.stars).toBe(102);
+  expect(fallback.pages).toEqual(first.pages);
+  expect(fallback.fetchedAt).toBe(second.fetchedAt);
+});
+
+test("a failed first fetch refuses to publish an empty chart", async () => {
+  const f = fixture();
+  f.fail();
+  await expect(refresh({}, f.ctx)).rejects.toThrow("no cached series");
+});
+
+test("dry run renders both themes without publishing", async () => {
+  const f = fixture();
+  const result = await refresh({ dryRun: true, authenticated: false }, f.ctx);
+  expect(result.pages).toHaveLength(2);
+  expect(result.pages.every((page) => "bytes" in page && page.bytes > 1000)).toBe(true);
+});
+
+test("renderer escapes repository text and handles one star", async () => {
+  const svg = renderChart("owner/<repo>", [Date.UTC(2026, 0, 1)], "dark");
+  expect(svg).toContain("owner/&lt;repo&gt;");
+  expect(svg).toContain("1 stars");
+  expect(svg).not.toContain("NaN");
+});

package/src/tests/swarm-config-reserved-keys.test.ts

@@ -134,6 +134,27 @@ describe("swarm-config reserved keys guard", () => {
     await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
   });
 
+  for (const key of ["CORS_ALLOW_ANY_ORIGIN", "cors_allow_any_origin"]) {
+    test(`rejects deployment-only ${key} through DB, HTTP, and MCP`, async () => {
+      const config = { scope: "global" as const, key, value: "true" };
+      await expect(upsertSwarmConfig(config)).rejects.toThrow(EXPECTED_MESSAGE(key));
+      const res = await fetch(`${baseUrl}/api/config`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(config),
+      });
+      expect(res.status).toBe(400);
+      expect(await res.json()).toMatchObject({ error: EXPECTED_MESSAGE(key) });
+      const handler = mcpServer.handlers.get("set-config")!;
+      const result = (await handler(config, makeRequestInfo())) as {
+        structuredContent: { success: boolean; message: string };
+      };
+      expect(result.structuredContent.success).toBe(false);
+      expect(result.structuredContent.message).toBe(EXPECTED_MESSAGE(key));
+      expect(await getSwarmConfigs({ key })).toHaveLength(0);
+    });
+  }
+
   // ─── Helper predicate ─────────────────────────────────────────────────────
   describe("isReservedConfigKey helper", () => {
     test("recognizes API_KEY", () => {

package/src/tests/swarm-repos.test.ts

@@ -11,6 +11,11 @@ import {
   initDb,
   updateSwarmRepo,
 } from "../be/db";
+import {
+  REPO_GUIDELINES_MAX_ENTRIES,
+  RepoGuidelinesInputSchema,
+  RepoGuidelinesSchema,
+} from "../types";
 
 const TEST_DB_PATH = "./test-swarm-repos.sqlite";
 
@@ -255,6 +260,21 @@ describe("Swarm Repos", () => {
       expect(updated?.guidelines).toBeNull();
     });
 
+    test("write schema caps each guideline list; read schema stays unbounded", () => {
+      const atCap = Array.from({ length: REPO_GUIDELINES_MAX_ENTRIES }, (_, i) => `check ${i}`);
+      const overCap = [...atCap, "one more"];
+      const base = { prChecks: [], mergeChecks: [], allowMerge: false, review: [] };
+
+      expect(RepoGuidelinesInputSchema.safeParse({ ...base, prChecks: atCap }).success).toBe(true);
+      for (const key of ["prChecks", "mergeChecks", "review"] as const) {
+        expect(RepoGuidelinesInputSchema.safeParse({ ...base, [key]: overCap }).success).toBe(
+          false,
+        );
+        // A stored row above the cap must still read back.
+        expect(RepoGuidelinesSchema.safeParse({ ...base, [key]: overCap }).success).toBe(true);
+      }
+    });
+
     test("should round-trip null vs configured distinction", async () => {
       const withGuidelines = await getSwarmRepoByName("guidelines-repo");
       const withoutGuidelines = await getSwarmRepoByName("no-guidelines-repo");

package/src/tests/tool-annotations.test.ts

@@ -199,8 +199,8 @@ describe("Tool Annotations & Classification", () => {
     expect(overlap).toEqual([]);
   });
 
-  test("CORE_TOOLS contains exactly 25 tools", () => {
-    expect(CORE_TOOLS.size).toBe(25);
+  test("CORE_TOOLS contains exactly 26 tools", () => {
+    expect(CORE_TOOLS.size).toBe(26);
   });
 
   test("ALL_TOOLS equals CORE_TOOLS union DEFERRED_TOOLS", () => {
@@ -251,6 +251,7 @@ describe("Tool Annotations & Classification", () => {
       "task-action",
       "send-task",
       "get-tasks",
+      "defer-task",
     ];
     for (const tool of lifecycleTools) {
       expect(CORE_TOOLS.has(tool)).toBe(true);
@@ -377,7 +378,7 @@ describe("Tool Annotations & Classification", () => {
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(140);
+    expect(count).toBeLessThanOrEqual(141);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/ui-logs-parser.test.ts

@@ -786,6 +786,182 @@ describe("ui logs parser", () => {
     ]);
   });
 
+  test("surfaces originalType and a value summary for codex item.type unknown", () => {
+    const messages = parseSessionLogs([
+      log("sleep", "codex", 1, {
+        type: "item.completed",
+        item: {
+          id: "call-1",
+          type: "unknown",
+          originalType: "sleep",
+          value: { durationMs: 30000 },
+        },
+      }),
+      log("image", "codex", 2, {
+        type: "item.completed",
+        item: {
+          id: "exec-1",
+          type: "unknown",
+          originalType: "imageView",
+          value: { path: "/workspace/personal/meme/spongebob.jpg" },
+        },
+      }),
+      log("subagent", "codex", 3, {
+        type: "item.completed",
+        item: {
+          id: "subagent-1",
+          type: "unknown",
+          originalType: "subAgentActivity",
+          value: { kind: "completed", agentPath: "/root/standards_review" },
+        },
+      }),
+      log("collab", "codex", 4, {
+        type: "item.completed",
+        item: {
+          id: "collab-1",
+          type: "unknown",
+          originalType: "collabAgentToolCall",
+          value: { tool: "wait", status: "completed" },
+        },
+      }),
+    ]);
+
+    expect(messages.map((message) => message.content[0])).toEqual([
+      expect.objectContaining({
+        kind: "unknown",
+        data: expect.objectContaining({
+          type: "item.completed · sleep",
+          itemType: "sleep",
+          detail: "sleep 30s",
+        }),
+      }),
+      expect.objectContaining({
+        kind: "unknown",
+        data: expect.objectContaining({
+          type: "item.completed · imageView",
+          itemType: "imageView",
+          detail: "spongebob.jpg",
+        }),
+      }),
+      expect.objectContaining({
+        kind: "unknown",
+        data: expect.objectContaining({
+          type: "item.completed · subAgentActivity",
+          itemType: "subAgentActivity",
+          detail: "completed · /root/standards_review",
+        }),
+      }),
+      expect.objectContaining({
+        kind: "unknown",
+        data: expect.objectContaining({
+          type: "item.completed · collabAgentToolCall",
+          itemType: "collabAgentToolCall",
+          detail: "wait · completed",
+        }),
+      }),
+    ]);
+  });
+
+  test("groups a codex unknown item's started and completed events into one row", () => {
+    const items = normalizeSessionLogs([
+      log(
+        "sleep-start",
+        "codex",
+        1,
+        {
+          type: "item.started",
+          item: {
+            id: "sleep-1",
+            type: "unknown",
+            originalType: "sleep",
+            value: { durationMs: 45000 },
+          },
+        },
+        "2026-06-01T09:32:48.000Z",
+      ),
+      log(
+        "sleep-done",
+        "codex",
+        2,
+        {
+          type: "item.completed",
+          item: {
+            id: "sleep-1",
+            type: "unknown",
+            originalType: "sleep",
+            value: { durationMs: 45000 },
+          },
+        },
+        "2026-06-01T09:33:33.000Z",
+      ),
+    ]).items;
+
+    expect(items.filter((item) => item.kind === "unknown")).toHaveLength(1);
+    expect(items[0]).toEqual(
+      expect.objectContaining({ kind: "unknown", status: "completed", durationMs: 45000 }),
+    );
+  });
+
+  test("shows a codex unknown item as running before its terminal event arrives", () => {
+    const items = normalizeSessionLogs([
+      log("collab-start", "codex", 1, {
+        type: "item.started",
+        item: {
+          id: "collab-1",
+          type: "unknown",
+          originalType: "collabAgentToolCall",
+          value: { tool: "wait", status: "pending" },
+        },
+      }),
+    ]).items;
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toEqual(expect.objectContaining({ kind: "unknown", status: "running" }));
+    expect(items[0].durationMs).toBeUndefined();
+  });
+
+  test("marks a codex unknown item failed when its completed event carries a failure signal", () => {
+    const items = normalizeSessionLogs([
+      log("collab-start", "codex", 1, {
+        type: "item.started",
+        item: {
+          id: "collab-1",
+          type: "unknown",
+          originalType: "collabAgentToolCall",
+          value: { tool: "wait", status: "pending" },
+        },
+      }),
+      log("collab-done", "codex", 2, {
+        type: "item.completed",
+        item: {
+          id: "collab-1",
+          type: "unknown",
+          originalType: "collabAgentToolCall",
+          status: "failed",
+          value: { tool: "wait", status: "failed" },
+        },
+      }),
+    ]).items;
+
+    expect(items).toHaveLength(1);
+    expect(items[0]).toEqual(expect.objectContaining({ kind: "unknown", status: "failed" }));
+  });
+
+  test("keeps id-less codex unknown items as separate one-off rows", () => {
+    const items = normalizeSessionLogs([
+      log("no-id-start", "codex", 1, {
+        type: "item.started",
+        item: { type: "unknown", originalType: "sleep", value: { durationMs: 1000 } },
+      }),
+      log("no-id-done", "codex", 2, {
+        type: "item.completed",
+        item: { type: "unknown", originalType: "sleep", value: { durationMs: 1000 } },
+      }),
+    ]).items;
+
+    expect(items.filter((item) => item.kind === "unknown")).toHaveLength(2);
+  });
+
   test("normalizes claude-managed raw SSE events without unknown noise", () => {
     const result = normalizeSessionLogs([
       log("status", "claude-managed", 1, {

package/src/tools/create-page.ts

@@ -83,9 +83,11 @@ export const registerCreatePageTool = (server: McpServer) => {
         body: z
           .string()
           .min(1)
-          .describe("Full page body (HTML document or JSON-render spec, per contentType)."),
+          .describe(
+            "Full page body (HTML document, SVG image, or JSON-render spec, per contentType).",
+          ),
         contentType: PageContentTypeSchema.describe(
-          "'text/html' renders directly at /p/:id; 'application/json' is rendered by the SPA.",
+          "'text/html' and 'image/svg+xml' render directly at /p/:id; 'application/json' is rendered by the SPA.",
         ),
         authMode: PageAuthModeSchema.default("authed").describe(
           "'authed' — requires page-session cookie (default); 'public' — no gate and must be explicit; 'password' — requires key.",

package/src/tools/defer-task.ts

@@ -0,0 +1,239 @@
+import { ensure } from "@desplega.ai/business-use";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { resolveTaskAuditUserId } from "@/be/audit-user";
+import {
+  completeTask,
+  createScheduledTask,
+  getAgentById,
+  getDbClient,
+  getTaskById,
+  updateAgentStatusFromCapacity,
+} from "@/be/db";
+import { runTaskTerminalEffects } from "@/tasks/task-terminal-effects";
+import { getTaskOutputValidationError } from "@/tasks/terminal-result-guard";
+import { assertOwnsTask, ownerCtx } from "@/tools/task-tool-ctx";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+import { isTerminalTaskStatus } from "@/types";
+
+/** Thrown inside the transaction to abort and roll back the schedule INSERT. */
+class DeferAbortedError extends Error {}
+
+/** Render `note` + optional `checks` as the plain-text tail both texts share. */
+function renderChecks(checks?: string[]): string {
+  if (!checks || checks.length === 0) return "";
+  return `\n\nChecks:\n${checks.map((c) => `- ${c}`).join("\n")}`;
+}
+
+export const registerDeferTaskTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "defer-task",
+    {
+      title: "Defer Task",
+      annotations: { destructiveHint: false, idempotentHint: false },
+      description:
+        "Completes this task now with status `completed` and books a wake-up for you. Use when the result needs time: a build, a deploy, a reply. The task reaches its final state on this call; the lead sees your summary as its output. A one-off schedule wakes you up later with a child task that carries this task as its parent. Provide delayMs or runAt, a summary of what you did, and a note that says what is pending and what to check.",
+      inputSchema: z.object({
+        taskId: z.string().describe("The ID of the task you are working on."),
+        delayMs: z
+          .number()
+          .int()
+          .positive()
+          .optional()
+          .describe("Wake up after this many milliseconds (e.g. 1800000 for 30 min)."),
+        runAt: z
+          .string()
+          .datetime()
+          .optional()
+          .describe("Wake up at this ISO datetime (e.g. '2026-03-06T15:00:00Z'). Must be future."),
+        summary: z
+          .string()
+          .min(1)
+          .max(4000)
+          .describe(
+            "What you did so far and where things stand. This becomes the task's output; the lead and your wake-up run both read it.",
+          ),
+        note: z
+          .string()
+          .min(1)
+          .max(2000)
+          .describe("What is pending, and what to check on wake-up."),
+        checks: z
+          .array(z.string().min(1))
+          .max(20)
+          .optional()
+          .describe("Concrete things to verify on wake-up, one per entry."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        yourAgentId: z.string().optional(),
+        taskId: z.string().optional(),
+        scheduleId: z.string().optional(),
+        nextRunAt: z.string().optional(),
+      }),
+    },
+    async ({ taskId, delayMs, runAt, summary, note, checks }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
+      }
+      const agent = await getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return toolErr(`Agent not found: ${requestInfo.agentId}`);
+      }
+
+      const task = await getTaskById(taskId);
+      if (!task) {
+        return toolErr(`Task with ID "${taskId}" not found.`);
+      }
+
+      const forbidden = assertOwnsTask(ownerCtx(requestInfo), task);
+      if (forbidden) return forbidden;
+
+      // A deferral completes the task and books a wake-up for the CALLER, so
+      // only the assignee may defer. `assertOwnsTask` above is the RBAC
+      // chokepoint; it does not (today) constrain agent-to-agent access.
+      if (task.agentId !== requestInfo.agentId) {
+        return toolErr(`Task "${taskId}" is not assigned to you.`);
+      }
+
+      if (isTerminalTaskStatus(task.status)) {
+        return toolErr(`Task ${taskId} is already ${task.status}; nothing to defer.`);
+      }
+
+      // A workflow step's completion drives `src/workflows/resume.ts` to advance
+      // `next` nodes immediately using this call's output. The scheduled wake-up
+      // task runs outside that workflow run and has no way to feed its eventual
+      // result back into the step, so the workflow would advance on a deferral
+      // note instead of the real result. Not supported: fail the step normally
+      // (or use a workflow-native wait) instead of deferring it.
+      if (task.workflowRunId) {
+        return toolErr(
+          `Task ${taskId} is owned by workflow run ${task.workflowRunId}; workflow-owned tasks cannot be deferred.`,
+        );
+      }
+
+      if (!delayMs && !runAt) {
+        return toolErr("Provide either delayMs or runAt.");
+      }
+      if (delayMs && runAt) {
+        return toolErr("Provide either delayMs or runAt, not both.");
+      }
+      if (runAt && new Date(runAt).getTime() <= Date.now()) {
+        return toolErr("runAt must be in the future.");
+      }
+      const nextRunAt = delayMs ? new Date(Date.now() + delayMs).toISOString() : runAt!;
+
+      const checksBlock = renderChecks(checks);
+      const taskTemplate = `Resume task ${taskId}: ${note}${checksBlock}`;
+      const createdBy =
+        (await resolveTaskAuditUserId(requestInfo.sourceTaskId, requestInfo.agentId)) ?? undefined;
+
+      // The deferral note is written as the task's FINAL output — a task with
+      // an outputSchema must satisfy it on completion (store-progress enforces
+      // the same rule). Validate before creating anything: the real schedule
+      // id isn't known yet, but it never changes whether this prose is valid
+      // JSON against the schema, so a placeholder stands in for it here.
+      const previewOutput = `${summary}\n\nDeferred until ${nextRunAt} (schedule pending). Pending: ${note}${checksBlock}`;
+      const outputValidationError = getTaskOutputValidationError(task.outputSchema, previewOutput);
+      if (outputValidationError) {
+        return toolErr(
+          `Task ${taskId} has an outputSchema; its terminal output must satisfy it, but a deferral note cannot. ${outputValidationError}`,
+        );
+      }
+
+      try {
+        const committed = await getDbClient().transaction(async () => {
+          const schedule = await createScheduledTask({
+            // Unique name (`getScheduledTaskByName` is a unique lookup). The UUID
+            // prevents concurrent deferrals of the same task from colliding.
+            name: `deferred-${taskId.slice(0, 8)}-${Date.now()}-${crypto.randomUUID()}`,
+            description: note,
+            taskTemplate,
+            targetType: "agent-task",
+            scheduleType: "one_time",
+            nextRunAt,
+            targetAgentId: requestInfo.agentId,
+            createdByAgentId: requestInfo.agentId,
+            taskType: "deferred",
+            tags: ["deferred"],
+            priority: task.priority,
+            // No `model`: a concrete provider model pinned now can be
+            // incompatible with the assignee/provider at wake-up, especially
+            // after a delay. Only the portable modelTier travels — mirrors
+            // the non-inheriting continuation path in `src/be/db.ts`.
+            modelTier: task.modelTier,
+            parentTaskId: taskId,
+            createdBy,
+          });
+
+          const output = `${summary}\n\nDeferred until ${nextRunAt} (schedule ${schedule.id}). Pending: ${note}${checksBlock}`;
+
+          // Deliberately NOT running `getTaskOutputValidationError` again here:
+          // already validated above against a placeholder id; re-run would be
+          // redundant since the id never affects JSON-shape validity.
+          const completed = await completeTask(taskId, output);
+          if (!completed) {
+            // Another writer terminally completed/failed/cancelled this task
+            // between our early check and this transaction's write. Abort:
+            // rolling back here discards the schedule INSERT so no orphan
+            // wake-up is committed, and no terminal effects fire for a
+            // completion that didn't happen on this call.
+            throw new DeferAbortedError(
+              `Task ${taskId} reached a terminal state before this deferral committed.`,
+            );
+          }
+
+          // afterCommit: the transaction can still roll back; business-use must
+          // not be told the task completed for a write that never landed.
+          getDbClient().afterCommit(() => {
+            ensure({
+              id: "completed",
+              flow: "task",
+              runId: taskId,
+              depIds: task.wasPaused ? ["started", "resumed"] : ["started"],
+              data: {
+                taskId,
+                agentId: task.agentId,
+                previousStatus: task.status,
+                hasOutput: true,
+              },
+              validator: (data) => data.previousStatus === "in_progress",
+              // biome-ignore lint/correctness/noEmptyPattern: data unused, ctx needed
+              filter: ({}, ctx) => ctx.deps.length > 0,
+              conditions: [{ timeout_ms: 3_600_000 }], // 1 hour
+            });
+          });
+
+          if (task.agentId) {
+            await updateAgentStatusFromCapacity(task.agentId);
+          }
+
+          return { scheduleId: schedule.id, output, completed };
+        });
+
+        await runTaskTerminalEffects({
+          task: committed.completed,
+          status: "completed",
+          output: committed.output,
+          agentId: requestInfo.agentId,
+        });
+
+        return toolOk(
+          `Task ${taskId} completed and deferred. Wake-up at ${nextRunAt} (schedule ${committed.scheduleId}). This task is final; the wake-up task continues the work.`,
+          {
+            data: {
+              yourAgentId: requestInfo.agentId,
+              taskId,
+              scheduleId: committed.scheduleId,
+              nextRunAt,
+            },
+          },
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return toolErr(`Failed to defer task: ${message}`, {
+          data: { yourAgentId: requestInfo.agentId, taskId },
+        });
+      }
+    },
+  );
+};

package/src/tools/repos/update-repo.ts

@@ -2,7 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { updateSwarmRepo } from "@/be/db";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
-import { RepoGuidelinesSchema, RepoHooksSchema } from "@/types";
+import { RepoGuidelinesInputSchema, RepoHooksSchema } from "@/types";
 
 const swarmRepoOutputShape = z.looseObject({
   id: z.string().optional(),
@@ -46,7 +46,7 @@ export const registerUpdateRepoTool = (server: McpServer) => {
           .describe(
             "Repository hook install config. Set { enabled: true } to opt into best-effort worker hook installation, or null to disable.",
           ),
-        guidelines: RepoGuidelinesSchema.nullable()
+        guidelines: RepoGuidelinesInputSchema.nullable()
           .optional()
           .describe(
             "Repository guidelines: prChecks (commands before PR), mergeChecks (conditions before merge), allowMerge (default false), review (guidance for reviewers). Pass null to clear.",

package/src/tools/schedules/create-schedule.ts

@@ -120,6 +120,7 @@ const scheduleDataShape = {
   lastRunAt: z.string().optional(),
   nextRunAt: z.string().optional(),
   createdByAgentId: z.string().optional(),
+  parentTaskId: z.string().optional(),
   timezone: z.string().optional(),
   model: z.string().optional(),
   modelTier: ModelTierSchema.optional(),

package/src/tools/schedules/list-schedules.ts

@@ -22,6 +22,7 @@ const scheduleRowShape = {
   lastRunAt: z.string().optional(),
   nextRunAt: z.string().optional(),
   createdByAgentId: z.string().optional(),
+  parentTaskId: z.string().optional(),
   timezone: z.string().optional(),
   consecutiveErrors: z.number().optional(),
   lastErrorAt: z.string().optional(),

package/src/tools/schedules/patch-schedule.ts

@@ -89,6 +89,7 @@ const scheduleDataShape = {
   lastRunAt: z.string().optional(),
   nextRunAt: z.string().optional(),
   createdByAgentId: z.string().optional(),
+  parentTaskId: z.string().optional(),
   timezone: z.string().optional(),
   model: z.string().optional(),
   modelTier: ModelTierSchema.optional(),