@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/src/tools/slack-leave-thread.ts

@@ -0,0 +1,104 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById, getTaskById } from "@/be/db";
+import { can } from "@/rbac";
+import {
+  isSlackLeaveThreadDisabled,
+  leaveSlackThread,
+  SLACK_LEAVE_THREAD_DISABLE,
+} from "@/slack/left-threads";
+import { parseSlackTs } from "@/slack/message-text";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+
+export const registerSlackLeaveThreadTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-leave-thread",
+    {
+      title: "Leave a Slack thread",
+      description:
+        "Stop following a Slack thread until someone @mentions the bot there again. Messages in the thread that do not @mention the bot are then ignored, with no task and no reply. Posts nothing to Slack. Pass taskId for the thread of your Slack-originated task, or (lead only) channelId and threadTs.",
+      annotations: { openWorldHint: true, idempotentHint: true },
+
+      inputSchema: z.object({
+        taskId: z.uuid().optional().describe("A task whose Slack thread to leave."),
+        channelId: z.string().min(1).optional().describe("The Slack channel ID of the thread."),
+        threadTs: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Timestamp of the thread root (dotted, 'p' deep-link, or full permalink URL)."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        channelId: z.string().optional(),
+        threadTs: z.string().optional(),
+      }),
+    },
+    async ({ taskId, channelId, threadTs }, requestInfo, _meta) => {
+      // Sessions created before the flag was set still list the tool.
+      if (isSlackLeaveThreadDisabled()) {
+        return toolErr(`slack-leave-thread is disabled by ${SLACK_LEAVE_THREAD_DISABLE}.`);
+      }
+
+      if (!requestInfo.agentId) {
+        return toolErr("Agent ID not found.");
+      }
+
+      const agent = await getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return toolErr("Agent not found.");
+      }
+
+      // Any thread is open to leads, like slack-post. Task Slack context and
+      // source can be set by any agent (send-task, POST /api/tasks), so a non-lead
+      // may only leave the thread of a task assigned to it that Slack ingress
+      // created: only the Slack handlers write slackTriggerMessageTs.
+      const mayLeaveAnyThread = can({
+        principal: { kind: "agent", agentId: agent.id, isLead: agent.isLead },
+        verb: "integration.slack.post",
+        resource: { kind: "none" },
+        source: "mcp",
+      }).allow;
+
+      let slackChannelId: string | undefined;
+      let slackThreadTs: string | undefined;
+
+      if (taskId) {
+        if (channelId || threadTs) {
+          return toolErr("Provide either taskId or channelId and threadTs, not both.");
+        }
+        const task = await getTaskById(taskId);
+        if (!task) {
+          return toolErr("Task not found.");
+        }
+        if (
+          !mayLeaveAnyThread &&
+          (task.agentId !== agent.id || task.source !== "slack" || !task.slackTriggerMessageTs)
+        ) {
+          return toolErr(
+            "Only a lead or the agent assigned a Slack-originated task can leave its thread.",
+          );
+        }
+        slackChannelId = task.slackChannelId;
+        slackThreadTs = task.slackThreadTs;
+      } else if (channelId && threadTs) {
+        if (!mayLeaveAnyThread) {
+          return toolErr("Leaving a thread by channelId and threadTs requires lead privileges.");
+        }
+        slackChannelId = channelId;
+        slackThreadTs = parseSlackTs(threadTs);
+      } else {
+        return toolErr("Must provide taskId, or both channelId and threadTs.");
+      }
+
+      if (!slackChannelId || !slackThreadTs) {
+        return toolErr("No Slack thread context available.");
+      }
+
+      await leaveSlackThread(slackChannelId, slackThreadTs, { agentId: agent.id });
+      return toolOk(
+        `Left Slack thread ${slackChannelId}/${slackThreadTs}. Messages there are ignored until someone @mentions the bot.`,
+        { data: { channelId: slackChannelId, threadTs: slackThreadTs } },
+      );
+    },
+  );
+};

package/src/tools/steer-task.ts

@@ -99,7 +99,8 @@ export async function steerTaskHandler(
       message,
       mode,
       onUnsupported,
-      source: "mcp",
+      source:
+        ctx.kind === "owner" && ctx.requestInfo?.callOrigin === "script-sdk" ? "script" : "mcp",
       createdByKind: ctx.kind === "owner" ? "agent" : "user",
       createdByAgentId: ctx.kind === "owner" ? ctx.agentId : undefined,
       createdByUserId: ctx.kind === "user" ? ctx.userId : undefined,
@@ -126,7 +127,7 @@ export const registerSteerTaskTool = (server: McpServer) => {
     {
       title: "Steer Task",
       description:
-        'Send a message to a task that is already running. `mode:"steer"` is honored on pi, claude-managed, codex and cursor; claude, devin, opencode and amp support queue only (amp delivery lands at the next tool result). Pass `onUnsupported:"fail"` to get an error instead of a downgrade.',
+        'Send a message to a task that is already running. `mode:"steer"` is honored on pi, claude-managed, codex, cursor and fx (fx supports steer only); claude, devin, opencode and amp support queue only (amp delivery lands at the next tool result). Pass `onUnsupported:"fail"` to get an error instead of a downgrade.',
       annotations: { destructiveHint: true },
       inputSchema: steerTaskInputSchema,
       outputSchema: steerTaskOutputSchema,

package/src/tools/task-dedup.ts

@@ -34,11 +34,53 @@ const HIGH_SIMILARITY_THRESHOLD = 0.8;
 /** Lower threshold used when the tasks also target the same agent */
 const SAME_AGENT_SIMILARITY_THRESHOLD = 0.6;
 
+/**
+ * Rows one duplicate check scans. The JS similarity match needs more than the
+ * query's default 50 (an older duplicate can sit behind newer unrelated tasks),
+ * but the scan must stay bounded: send-task runs it twice per call, once inside
+ * the write transaction.
+ */
+export const DEDUP_SCAN_LIMIT = 500;
+
 export interface DedupMatch {
   task: AgentTask;
   reason: string;
 }
 
+/**
+ * The description-similarity rules shared by the duplicate check and the
+ * follow-up re-delegation guard: a very similar description matches any
+ * target, a moderately similar one matches only the same target agent.
+ */
+export function matchSimilarTask(
+  existing: AgentTask,
+  opts: { taskDescription: string; targetAgentId?: string },
+): DedupMatch | null {
+  const similarity = jaccardSimilarity(existing.task, opts.taskDescription);
+
+  // Very similar task description: likely duplicate regardless of target
+  if (similarity > HIGH_SIMILARITY_THRESHOLD) {
+    return {
+      task: existing,
+      reason: `similar task description (${(similarity * 100).toFixed(0)}% match)`,
+    };
+  }
+
+  // Same target agent + moderately similar task: lower threshold
+  if (
+    opts.targetAgentId &&
+    existing.agentId === opts.targetAgentId &&
+    similarity > SAME_AGENT_SIMILARITY_THRESHOLD
+  ) {
+    return {
+      task: existing,
+      reason: `similar task to same agent (${(similarity * 100).toFixed(0)}% match)`,
+    };
+  }
+
+  return null;
+}
+
 /**
  * Check for duplicate tasks created recently.
  * Returns the first matching duplicate, or null if none found.
@@ -54,6 +96,7 @@ export async function findDuplicateTask(opts: {
   const recentTasks = await findRecentSimilarTasks({
     creatorAgentId: opts.creatorAgentId,
     windowMinutes: opts.windowMinutes ?? 10,
+    limit: DEDUP_SCAN_LIMIT,
   });
 
   for (const existing of recentTasks) {
@@ -70,27 +113,8 @@ export async function findDuplicateTask(opts: {
       };
     }
 
-    const similarity = jaccardSimilarity(existing.task, opts.taskDescription);
-
-    // 2. Very similar task description — likely duplicate regardless of target
-    if (similarity > HIGH_SIMILARITY_THRESHOLD) {
-      return {
-        task: existing,
-        reason: `similar task description (${(similarity * 100).toFixed(0)}% match)`,
-      };
-    }
-
-    // 3. Same target agent + moderately similar task — lower threshold
-    if (
-      opts.targetAgentId &&
-      existing.agentId === opts.targetAgentId &&
-      similarity > SAME_AGENT_SIMILARITY_THRESHOLD
-    ) {
-      return {
-        task: existing,
-        reason: `similar task to same agent (${(similarity * 100).toFixed(0)}% match)`,
-      };
-    }
+    const match = matchSimilarTask(existing, opts);
+    if (match) return match;
   }
 
   return null;

package/src/tools/tool-config.ts

@@ -96,7 +96,7 @@ export const DEFERRED_TOOLS = new Set([
   "read-messages",
   "post-message",
 
-  // Slack (12): task-context gated; keep out of CORE_TOOLS
+  // Slack (13): task-context gated; keep out of CORE_TOOLS
   "slack-reply",
   "slack-read",
   "slack-upload-file",
@@ -109,6 +109,7 @@ export const DEFERRED_TOOLS = new Set([
   "slack-archive-channel",
   "slack-delete",
   "slack-update",
+  "slack-leave-thread",
 
   // Channel management (2)
   "create-channel",

package/src/types.ts

@@ -185,6 +185,14 @@ export const DEFAULT_MODEL_TIER_MAP: Record<ProviderName, Record<ModelTier, stri
     smart: "grok-4.6",
     ultra: "grok-4.7",
   },
+  // fx runs these on its `openrouter` custom connection (OPENROUTER_API_KEY),
+  // pi's tested OpenRouter set; each ran under fx 0.0.15 (2026-10-29 probe).
+  fx: {
+    smol: "openrouter/deepseek/deepseek-v4.1-flash",
+    regular: "openrouter/deepseek/deepseek-v4.1-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+    ultra: "openrouter/anthropic/claude-opus-5.5",
+  },
   // ACP has no portable tier-to-model mapping. Operators may set an explicit
   // MODEL_OVERRIDE, which the adapter applies through an advertised `model`
   // config option with a target-specific startup fallback.
@@ -436,6 +444,7 @@ export const ProviderNameSchema = z.enum([
   "amp",
   "cursor",
   "grok",
+  "fx",
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
@@ -596,6 +605,10 @@ export const PROVIDER_STEER_CAPABILITIES: Record<ProviderName, SteerMode[]> = {
   // Grok runs on the ACP client: one `session/prompt` turn, interrupted only
   // by `session/cancel`. No Grok surface (ACP or headless) exposes a steer.
   grok: [],
+  // `fx acp` steers natively: a `session/prompt` with `_meta.fx.steer` during a
+  // running turn lands at the next tool boundary without cancelling it (fx
+  // 0.0.15 probe, 2026-10-29). Queue is not measured, so it is not advertised.
+  fx: ["steer"],
 };
 
 export type DevinProviderMeta = {
@@ -619,6 +632,7 @@ export type ProviderMetaMap = {
   amp: NoProviderMeta;
   cursor: NoProviderMeta;
   grok: NoProviderMeta;
+  fx: NoProviderMeta;
 };
 
 export const FollowUpConfigSchema = z
@@ -2198,6 +2212,39 @@ export const RuntimeControllerSchema = RuntimeControllerCreateSchema.omit({ secr
   .openapi("RuntimeController");
 export type RuntimeController = z.infer<typeof RuntimeControllerSchema>;
 
+export const RuntimePoolCacheSchema = z
+  .object({
+    mountPath: z
+      .string()
+      .min(2)
+      .refine((path) => {
+        const parts = path.split("/").filter(Boolean);
+        const normalized = `/${parts.join("/")}`;
+        const protectedPaths = [
+          "/workspace/personal",
+          "/workspace/shared",
+          ...["/home/worker", "/root"].flatMap((home) =>
+            [".ssh", ".codex", ".claude", ".claude.json", ".pi", ".config", ".local"].map(
+              (directory) => `${home}/${directory}`,
+            ),
+          ),
+        ];
+        return (
+          path.startsWith("/") &&
+          parts.length > 0 &&
+          !path.includes("\0") &&
+          !parts.some((part) => part === "." || part === "..") &&
+          !protectedPaths.some(
+            (protectedPath) =>
+              protectedPath === normalized ||
+              protectedPath.startsWith(`${normalized}/`) ||
+              normalized.startsWith(`${protectedPath}/`),
+          )
+        );
+      }, "Cache mountPath must be absolute, without . or .., and must not cover worker homes, workspaces or credential directories"),
+  })
+  .strict();
+
 export const RuntimePoolCreateSchema = z
   .object({
     name: z.string().min(1).max(200),
@@ -2212,6 +2259,7 @@ export const RuntimePoolCreateSchema = z
     delivery: DeliveryModeSchema.nullable().default(null),
     env: z.record(z.string(), z.string()).default({}),
     resources: RuntimeResourcesSchema.nullable().default(null),
+    cache: RuntimePoolCacheSchema.nullable().default(null),
     ttlSec: z.number().int().positive().nullable().default(null),
     enabled: z.boolean().default(true),
   })
@@ -2225,6 +2273,7 @@ export const RuntimePoolUpdateSchema = RuntimePoolCreateSchema.partial().extend(
   delivery: DeliveryModeSchema.nullable().optional(),
   env: z.record(z.string(), z.string()).optional(),
   resources: RuntimeResourcesSchema.nullable().optional(),
+  cache: RuntimePoolCacheSchema.nullable().optional(),
   ttlSec: z.number().int().positive().nullable().optional(),
   enabled: z.boolean().optional(),
 });
@@ -2606,6 +2655,10 @@ export const CooldownConfigSchema = z
     hours: z.number().min(0).optional(),
     minutes: z.number().min(0).optional(),
     seconds: z.number().min(0).optional(),
+    // "finish" (default): also wait out the window after the last successful
+    // run finished. "start": count only from run starts, so a long run never
+    // pushes the next fixed-time trigger out.
+    from: z.enum(["finish", "start"]).optional(),
   })
   .refine((v) => v.hours !== undefined || v.minutes !== undefined || v.seconds !== undefined, {
     message: "At least one of hours, minutes, or seconds is required",
@@ -3096,6 +3149,8 @@ export const ScriptRunSchema = z
     lastHeartbeatAt: z.string().optional(),
     idempotencyKey: z.string().optional(),
     requestedByUserId: z.string().optional(),
+    /** Task whose session launched the run; the follow-up re-delegation guard reads it. */
+    sourceTaskId: z.string().optional(),
   })
   .openapi("ScriptRun");
 export type ScriptRun = z.infer<typeof ScriptRunSchema>;
@@ -3104,6 +3159,7 @@ export const ScriptRunListItemSchema = ScriptRunSchema.omit({
   source: true,
   args: true,
   output: true,
+  sourceTaskId: true,
 });
 export type ScriptRunListItem = z.infer<typeof ScriptRunListItemSchema>;
 
@@ -3838,6 +3894,7 @@ export const PricingProviderSchema = z.enum([
   "amp",
   "cursor",
   "grok",
+  "fx",
 ]);
 export type PricingProvider = z.infer<typeof PricingProviderSchema>;
 

package/src/utils/codex-auth-failure.ts

@@ -32,3 +32,33 @@ export function isCodexAuthFailureReason(failureReason: string | undefined | nul
   const lower = failureReason.toLowerCase();
   return !TRANSIENT_AUTH_ERROR_MARKERS.some((m) => lower.includes(m));
 }
+
+/**
+ * Turn-level texts of a rejected ChatGPT/Codex credential: a bad API key, or
+ * a pool login revoked while its access token is unexpired. That death mode
+ * never enters `getValidCodexOAuth` (the token looks fresh), so this error is
+ * its only artifact. The adapters tag a match `[auth-error]`.
+ */
+const REJECTED_ACCESS_PATTERNS = [
+  "unauthorized",
+  "http 401",
+  " 401 ",
+  "invalid api key",
+  "invalid_api_key",
+  "missing api key",
+  "no api key",
+  "authentication failed",
+  "failed to refresh token",
+  "invalid 'refresh_token'",
+  // ChatGPT backend 401 bodies (pi on the subscription surfaces them as-is).
+  "token_invalidated",
+  "authentication token has been invalidated",
+  "authentication token is expired",
+  "refresh token was revoked",
+  "could not parse your authentication token",
+];
+
+export function isCodexRejectedAccessError(text: string): boolean {
+  const lower = text.toLowerCase();
+  return REJECTED_ACCESS_PATTERNS.some((p) => lower.includes(p));
+}

package/src/utils/context-window.ts

@@ -20,7 +20,7 @@
  *     deprecated; new code should use `computeContextUsedUnified`.
  */
 
-import { buildClaudeShortnameMap } from "@desplega/model-catalog";
+import { buildClaudeShortnameMap, chatgptSubscriptionModelId } from "@desplega/model-catalog";
 import { runtimeCatalogModel, runtimeCatalogSection } from "./runtime-model-catalog";
 
 /**
@@ -73,6 +73,9 @@ export function getContextWindowSize(model: string): number {
 /** {@link getContextWindowSize} without the fallback: undefined when the catalog has no window. */
 export function getKnownContextWindowSize(model: string | undefined): number | undefined {
   if (!model) return undefined;
+  // `openai-codex/<id>` (pi on the ChatGPT subscription) is the OpenAI `<id>`.
+  const subscriptionId = chatgptSubscriptionModelId(model);
+  if (subscriptionId) return catalogContext("openai", subscriptionId);
   const slash = model.indexOf("/");
   if (slash > 0) {
     const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));

package/src/utils/credentials.ts

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import {
+  fxModelRoute,
   openAICompatibleProviders,
   providerForKeyVar,
   providerForModel,
@@ -61,6 +62,7 @@ export const PROVIDER_CREDENTIAL_VARS: Record<string, readonly string[]> = {
   amp: ["AMP_API_KEY"],
   cursor: ["CURSOR_API_KEY"],
   grok: ["XAI_API_KEY", "OPENROUTER_API_KEY"],
+  fx: ["OPENROUTER_API_KEY", "OPENAI_API_KEY", "AI_GATEWAY_API_KEY"],
   opencode: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
 };
 
@@ -100,6 +102,11 @@ export function getModelAwareCredentialVars(provider: string, model?: string): r
   if (provider === "grok" && model) {
     return model.startsWith("openrouter/") ? ["OPENROUTER_API_KEY"] : ["XAI_API_KEY"];
   }
+  // fx routes by namespace (`src/utils/fx-models.ts`); each route reads one key.
+  if (provider === "fx" && model) {
+    const route = fxModelRoute(model);
+    return "error" in route ? base : [route.keyVar];
+  }
   if (!SLASH_MODEL_PROVIDERS.has(provider) || !model) return base;
   // OpenAI-compatible registry providers own their key: `nan/<id>` and
   // `helmcode/<id>` never pool an OpenRouter or Anthropic key.

package/src/utils/fx-models.ts

@@ -0,0 +1,43 @@
+/**
+ * Model routing for the `fx` harness. Pure, so the API server can validate a
+ * model and the worker can route it without importing the adapter.
+ *
+ * | Swarm model string           | fx provider (`FX_PROVIDER`)       | `fx acp --model` | Key                  |
+ * |------------------------------|-----------------------------------|------------------|----------------------|
+ * | `openrouter/<vendor>/<id>`   | `openrouter` (custom connection)  | `<vendor>/<id>`  | `OPENROUTER_API_KEY` |
+ * | `vercel/<vendor>/<id>`       | `gateway` (built in)              | `<vendor>/<id>`  | `AI_GATEWAY_API_KEY` |
+ * | bare `<id>` (no slash)       | `openai` (custom connection)      | `<id>`           | `OPENAI_API_KEY`     |
+ *
+ * Anything else (`nan/…`, `helmcode/…`, `anthropic/…`) is rejected with a reason.
+ */
+import { type FxRoute, fxModelRoute } from "@desplega/model-catalog";
+import { DEFAULT_MODEL_TIER_MAP } from "../types";
+
+export type { FxRoute };
+
+/** An fx route plus the swarm model string it came from. */
+export type ResolvedFxRoute = FxRoute & { model: string };
+
+/** Every key an fx route can read, in route-table order. */
+export const FX_ROUTE_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "OPENAI_API_KEY",
+  "AI_GATEWAY_API_KEY",
+] as const;
+
+/**
+ * The fx route for a swarm model string, or the reason it has none. An empty
+ * model means the regular tier default.
+ */
+export function resolveFxRoute(model: string | undefined): ResolvedFxRoute | { error: string } {
+  const value = model?.trim() || DEFAULT_MODEL_TIER_MAP.fx.regular;
+  const route = fxModelRoute(value);
+  return "error" in route ? route : { ...route, model: value };
+}
+
+/** {@link resolveFxRoute}, throwing the rejection reason. */
+export function requireFxRoute(model: string | undefined): ResolvedFxRoute {
+  const route = resolveFxRoute(model);
+  if ("error" in route) throw new Error(route.error);
+  return route;
+}

package/src/workflows/cooldown.ts

@@ -15,7 +15,8 @@ function cooldownToMs(cooldown: CooldownConfig): number {
 /**
  * Check if a workflow should be skipped due to cooldown.
  * Returns true if:
- * - the last successful run finished within the cooldown window, OR
+ * - the last successful run finished within the cooldown window (skipped for
+ *   `from: "start"`), OR
  * - any run (including failed ones) started within the cooldown window.
  *
  * The second condition prevents runaway re-triggering when all runs fail
@@ -30,7 +31,7 @@ export async function shouldSkipCooldown(
   const now = Date.now();
 
   // Skip if last successful run finished within the cooldown window
-  const lastSuccess = await getLastSuccessfulRun(workflowId);
+  const lastSuccess = cooldown.from === "start" ? null : await getLastSuccessfulRun(workflowId);
   if (lastSuccess?.finishedAt) {
     const lastFinished = new Date(lastSuccess.finishedAt).getTime();
     if (now - lastFinished < cooldownMs) return true;

package/src/workflows/engine.ts

@@ -192,7 +192,7 @@ export async function startWorkflowExecution(
   const newRunId = crypto.randomUUID();
   const release = holdWorkflowRun(newRunId);
   try {
-    const { runId, created, preflightAlert } = await createRunWithInitialState(
+    const { runId, created, preflightAlert, status } = await createRunWithInitialState(
       workflow,
       triggerData,
       options,
@@ -204,7 +204,7 @@ export async function startWorkflowExecution(
       if (preflightAlert) await notifyAutomationPreflightFailure(preflight);
       return runId;
     }
-    if (initial.status === "skipped") return runId;
+    if (status === "skipped") return runId;
     telemetry.workflow("started", {
       workflowId: workflow.id,
       nodeCount: workflow.definition.nodes.length,
@@ -317,7 +317,12 @@ async function createRunWithInitialState(
   options: WorkflowExecutionOptions,
   initial: InitialRunState,
   runId: string,
-): Promise<{ runId: string; created: boolean; preflightAlert?: boolean }> {
+): Promise<{
+  runId: string;
+  created: boolean;
+  preflightAlert?: boolean;
+  status?: InitialRunState["status"];
+}> {
   return getDbClient().transaction(async () => {
     const { parentStepId } = options;
     const attempt = options.parentStepAttempt ?? 0;
@@ -328,6 +333,16 @@ async function createRunWithInitialState(
       const existingId = await getChildWorkflowRunId(parentStepId, attempt);
       if (existingId) return { runId: existingId, created: false };
     }
+    // The cooldown check before this transaction is only a fast path: two
+    // triggers can both pass it before either run exists. The write lock is
+    // held from BEGIN, across processes too, so this recheck sees every run
+    // committed before it and the losing trigger records a skipped run.
+    const state: InitialRunState =
+      !initial.status &&
+      workflow.cooldown &&
+      (await shouldSkipCooldown(workflow.id, workflow.cooldown))
+        ? { status: "skipped", error: "cooldown", finishedAt: new Date().toISOString() }
+        : initial;
     await createWorkflowRun({
       id: runId,
       workflowId: workflow.id,
@@ -340,16 +355,16 @@ async function createRunWithInitialState(
     });
     await updateWorkflowRun(
       runId,
-      initial.status
-        ? { status: initial.status, error: initial.error, finishedAt: initial.finishedAt }
-        : { context: initial.context },
+      state.status
+        ? { status: state.status, error: state.error, finishedAt: state.finishedAt }
+        : { context: state.context },
     );
     const preflightAlert =
-      initial.status === "failed" && initial.preflight
+      state.status === "failed" && state.preflight
         ? await isFirstWorkflowPreflightFailureToday(workflow.id, runId)
         : undefined;
-    await options.accept?.({ runId, skipped: initial.status === "skipped" });
-    return { runId, created: true, preflightAlert };
+    await options.accept?.({ runId, skipped: state.status === "skipped" });
+    return { runId, created: true, preflightAlert, status: state.status };
   });
 }
 

package/templates/schedules/dreaming-daily/config.json

@@ -4,7 +4,7 @@
   "displayName": "Dreaming",
   "slug": "dreaming-daily",
   "title": "Dreaming Daily Trigger",
-  "description": "Trigger the dreaming workflow once a day, unless a dreaming run already started in the last 20 hours.",
+  "description": "Start the dreaming workflow once a day, directly as a workflow schedule. The workflow's 20-hour cooldown skips a second run.",
   "version": "1.0.0",
   "category": "schedules",
   "placeholders": [],

package/templates/schedules/dreaming-daily/content.md

@@ -2,7 +2,9 @@
 
 Trigger the `dreaming` workflow once a day. It replaces the Daily Evolution schedule (`daily-compounding-reflection`), which now seeds disabled.
 
-A seeded schedule cannot target a workflow directly, so this schedule creates one small pool task, and the worker that claims it triggers the workflow. It runs after the Daily Blocker Digest (02:05 UTC), whose digest the workflow reads.
+This is a workflow schedule: each fire starts a `dreaming` run directly, with no agent task in between. A seeded schedule has no creator, so the run acts as the swarm's lead, resolved when it fires; with no lead the fire fails. It runs after the Daily Blocker Digest (02:05 UTC), whose digest the workflow reads.
+
+The `dreaming` workflow carries the double-run guard as a 20-hour cooldown: a run that would start within 20 hours of another `dreaming` run start (any status, manual runs included) is recorded as skipped. Dreaming runs share KV state, so they must never run twice in a day.
 
 ## Schedule
 
@@ -10,18 +12,8 @@ A seeded schedule cannot target a workflow directly, so this schedule creates on
 {
   "cron": "30 3 * * *",
   "timezone": "UTC",
-  "enabled": true
+  "enabled": true,
+  "targetType": "workflow",
+  "workflow": "dreaming"
 }
 ```
-
-## Scheduled Task
-
-Task Type: Dreaming trigger
-
-Trigger today's run of the `dreaming` workflow. Do nothing else: no report, no memory, no Slack.
-
-1. Double-run guard. Run `db-query` with exactly this SQL:
-   `SELECT w.name, r.id, r.status, r.startedAt FROM workflow_runs r JOIN workflows w ON w.id = r.workflowId WHERE w.name LIKE 'dreaming%' AND julianday(r.startedAt) >= julianday('now', '-20 hours') ORDER BY r.startedAt DESC LIMIT 5`
-   If it returns any row, complete this task without triggering, with the output `skipped: workflow <name> run <id> started at <startedAt>, within 20 hours`. Dreaming workflows share KV state, so they must never run twice in a day. If the query fails, complete without triggering and give the error.
-2. Find the workflow named exactly `dreaming` with `list-workflows`. If it is missing or disabled, complete with that reason and trigger nothing.
-3. Call `trigger-workflow` with its id and no `triggerData`. Complete with the run id it returns.

package/templates/skills/composio-google-docs/content.md

@@ -80,6 +80,16 @@ Google Drive export, then preserve or reconstruct the structure explicitly.
 There is no `GET_DOCUMENT_MARKDOWN` tool; markdown exists on create/update, not
 on read.
 
+## Comments
+
+Doc comments are a Drive feature, not a Docs one: there is no `GOOGLEDOCS_*`
+comment slug. List them with `GOOGLEDRIVE_LIST_COMMENTS` (replies:
+`GOOGLEDRIVE_LIST_REPLIES`) from the `googledrive` toolkit, so resolve the
+user's `googledrive` connected account instead of their `googledocs` one.
+Listing only works when the Drive read scopes are authorized on that account.
+`GOOGLEDRIVE_CREATE_COMMENT` and the update/delete tools are write actions,
+only on explicit request.
+
 ## Gotchas
 
 - Search returns Drive metadata, not document content — do a second