@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/types.ts

@@ -3,6 +3,7 @@
 // reference them emit `$ref`s and SDK generators produce named types.
 
 import { normalizeAssetKey } from "./assets/key";
+import { isSafeBundlePath } from "./extensions/bundle-path";
 import { MAX_PROFILE_FILE_LENGTH } from "./utils/constants";
 import { z } from "./utils/zod-openapi";
 // ─── Asset namespaces ──────────────────────────────────────────────────────
@@ -349,6 +350,9 @@ export const RoutingReasonSchema = z.enum([
 ]);
 export type RoutingReason = z.infer<typeof RoutingReasonSchema>;
 
+export const RoutingSourceSchema = z.enum(["declared", "engine_default"]);
+export type RoutingSource = z.infer<typeof RoutingSourceSchema>;
+
 // ---------------------------------------------------------------------------
 // Harness Provider
 // ---------------------------------------------------------------------------
@@ -514,6 +518,9 @@ export const AgentTaskSchema = z
     status: AgentTaskStatusSchema,
     source: AgentTaskSourceSchema.default("mcp"),
     routingReason: RoutingReasonSchema.optional(),
+    routingSource: RoutingSourceSchema.optional().describe(
+      "Origin of the routing reason: declared by the caller or chosen by the engine. Absent for unknown historical provenance or no reason.",
+    ),
     routingNote: z.string().max(200).optional(),
 
     // Task metadata
@@ -676,6 +683,7 @@ export const CreateTaskOptionsSchema = z.object({
   creatorAgentId: z.string().optional(),
   source: AgentTaskSourceSchema.optional(),
   routingReason: RoutingReasonSchema.optional(),
+  routingSource: RoutingSourceSchema.optional(),
   routingNote: z.string().max(200).optional(),
   taskType: z.string().max(50).optional(),
   tags: z.array(z.string()).optional(),
@@ -941,6 +949,9 @@ export type IdentityEventType = z.infer<typeof IdentityEventTypeSchema>;
 //   - broken_task        — tasks in failed/cancelled status
 //   - to_read            — sessions/tasks marked unread for the user
 //   - to_start_template  — task-templates the user hasn't dismissed
+//   - notification       — dashboard notification-center items (see
+//                           apps/ui/src/lib/notifications/definitions.ts);
+//                           itemId is the notification definition's key
 //
 // Statuses:
 //   - open      — visible in inbox
@@ -953,6 +964,7 @@ export const InboxItemTypeSchema = z.enum([
   "broken_task",
   "to_read",
   "to_start_template",
+  "notification",
 ]);
 export type InboxItemType = z.infer<typeof InboxItemTypeSchema>;
 
@@ -969,6 +981,8 @@ export const InboxItemStateSchema = z
     snoozeUntil: z.string().optional(),
     dismissedAt: z.string().optional(),
     doneAt: z.string().optional(),
+    /** First-viewed timestamp, set once on first panel open. Independent of status. */
+    readAt: z.string().optional(),
     createdAt: z.string(),
     lastUpdatedAt: z.string(),
   })
@@ -2786,6 +2800,136 @@ export const ScriptVersionRecordSchema = z
   .openapi("ScriptVersionRecord");
 export type ScriptVersionRecord = z.infer<typeof ScriptVersionRecordSchema>;
 
+// ============================================================================
+// Extension Types
+// ============================================================================
+
+const ExtensionNameSchema = z
+  .string()
+  .min(1)
+  .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be a lowercase slug");
+
+const SemverSchema = z
+  .string()
+  .regex(
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/,
+    "must be a semantic version",
+  );
+
+export const ExtensionManifestSchema = z
+  .object({
+    name: ExtensionNameSchema,
+    description: z.string(),
+    version: SemverSchema,
+    runtime: z.enum(["api", "worker"]),
+    assets: z
+      .object({
+        hooks: z
+          .string()
+          .min(1)
+          .refine(
+            isSafeBundlePath,
+            "Must be a relative POSIX file path without empty, dot, or parent segments, at most 256 characters",
+          ),
+        skills: z.array(z.string()).optional(),
+        workflows: z.array(z.string()).optional(),
+        schedules: z.array(z.string()).optional(),
+      })
+      .strict(),
+    homepage: z.string().url().optional(),
+    author: z.string().min(1).optional(),
+  })
+  .strict()
+  .openapi("ExtensionManifest");
+const _manifestShapeGuard: import("./extensions/contract").ExtensionManifest = {} as z.infer<
+  typeof ExtensionManifestSchema
+>;
+const _manifestSchemaGuard: z.infer<typeof ExtensionManifestSchema> =
+  {} as import("./extensions/contract").ExtensionManifest;
+void _manifestShapeGuard;
+void _manifestSchemaGuard;
+export type ExtensionManifest = z.infer<typeof ExtensionManifestSchema>;
+
+export const ExtensionStatusSchema = z.enum(["disabled", "enabled", "error", "auto-disabled"]);
+export type ExtensionStatus = z.infer<typeof ExtensionStatusSchema>;
+
+export const ExtensionSchema = z
+  .object({
+    id: z.string(),
+    name: ExtensionNameSchema,
+    description: z.string(),
+    runtime: z.enum(["api", "worker"]),
+    manifestJson: z.string(),
+    contentHash: z.string(),
+    version: z.number().int().min(1),
+    activeVersion: z.number().int().min(1),
+    enabled: z.boolean(),
+    priority: z.number().int(),
+    configJson: z.string(),
+    status: ExtensionStatusSchema,
+    consecutiveFailures: z.number().int().min(0),
+    lastError: z.string().nullable(),
+    agentId: z.string().nullable(),
+    createdByAgentId: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+  })
+  .openapi("Extension");
+export type Extension = z.infer<typeof ExtensionSchema>;
+
+export const ExtensionFileSchema = z
+  .object({
+    id: z.string(),
+    extensionId: z.string(),
+    path: z.string(),
+    content: z.string(),
+    contentHash: z.string(),
+  })
+  .openapi("ExtensionFile");
+export type ExtensionFile = z.infer<typeof ExtensionFileSchema>;
+
+export const ExtensionVersionSchema = z
+  .object({
+    id: z.string(),
+    extensionId: z.string(),
+    version: z.number().int().min(1),
+    manifestJson: z.string(),
+    filesJson: z.string(),
+    contentHash: z.string(),
+    changedByAgentId: z.string().nullable(),
+    changedAt: z.string(),
+    changeReason: z.string().nullable(),
+  })
+  .openapi("ExtensionVersion");
+export type ExtensionVersion = z.infer<typeof ExtensionVersionSchema>;
+
+export const ExtensionRunSchema = z
+  .object({
+    id: z.string(),
+    extensionId: z.string(),
+    version: z.number().int().min(1),
+    event: z.string(),
+    action: z.enum(["continue", "modify", "block", "error", "timeout", "load-error"]),
+    durationMs: z.number().int().nullable(),
+    message: z.string().nullable(),
+    agentId: z.string().nullable(),
+    subject: z.string().nullable(),
+    createdAt: z.string(),
+  })
+  .openapi("ExtensionRun");
+export type ExtensionRun = z.infer<typeof ExtensionRunSchema>;
+
+export const ExtensionInstallBodySchema = z
+  .object({
+    manifest: ExtensionManifestSchema,
+    files: z.record(z.string(), z.string()),
+    priority: z.number().int().optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+  })
+  .strict()
+  .openapi("ExtensionInstallBody");
+export type ExtensionInstallBody = z.infer<typeof ExtensionInstallBodySchema>;
+
 /** Lean projection served by `GET /api/scripts` — omits `source` (payload size) and raw JSON blobs. */
 export type ScriptListItem = Omit<
   ScriptRecord,

package/src/utils/constants.ts

@@ -130,5 +130,11 @@ export function buildAgentFsLiveUrl(opts: {
   if (!orgId || !driveId) return null;
   const host = getAgentFsLiveUrl();
   const normalizedPath = path.replace(/^\/+/, "");
-  return `${host}/file/~/${orgId}/${driveId}/${normalizedPath}`;
+  // Never double-encode an already-encoded segment: preserve existing %HH
+  // escapes byte-for-byte, including in segments that also contain raw text.
+  const encodedPath = normalizedPath
+    .split("/")
+    .map((segment) => encodeURIComponent(segment).replace(/%25([0-9a-f]{2})/gi, "%$1"))
+    .join("/");
+  return `${host}/file/~/${orgId}/${driveId}/${encodedPath}`;
 }

package/src/utils/credentials.test.ts

@@ -63,30 +63,30 @@ describe("selectRandomCredential", () => {
 describe("resolveCredentialPools", () => {
   it("resolves comma-separated CLAUDE_CODE_OAUTH_TOKEN", async () => {
     const env: Record<string, string | undefined> = {
-      CLAUDE_CODE_OAUTH_TOKEN: "token1,token2",
+      CLAUDE_CODE_OAUTH_TOKEN: "example-token1,example-token2",
       OTHER_VAR: "unchanged",
     };
     await resolveCredentialPools(env);
-    expect(["token1", "token2"]).toContain(env.CLAUDE_CODE_OAUTH_TOKEN!);
+    expect(["example-token1", "example-token2"]).toContain(env.CLAUDE_CODE_OAUTH_TOKEN!);
     expect(env.OTHER_VAR).toBe("unchanged");
   });
 
   it("resolves comma-separated ANTHROPIC_API_KEY", async () => {
     const env: Record<string, string | undefined> = {
-      ANTHROPIC_API_KEY: "key1,key2,key3",
+      ANTHROPIC_API_KEY: "example-key1,example-key2,example-key3",
     };
     await resolveCredentialPools(env);
-    expect(["key1", "key2", "key3"]).toContain(env.ANTHROPIC_API_KEY!);
+    expect(["example-key1", "example-key2", "example-key3"]).toContain(env.ANTHROPIC_API_KEY!);
   });
 
   it("leaves single values unchanged", async () => {
     const env: Record<string, string | undefined> = {
-      CLAUDE_CODE_OAUTH_TOKEN: "single-token",
-      ANTHROPIC_API_KEY: "single-key",
+      CLAUDE_CODE_OAUTH_TOKEN: "example-single-token",
+      ANTHROPIC_API_KEY: "example-single-key",
     };
     await resolveCredentialPools(env);
-    expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBe("single-token");
-    expect(env.ANTHROPIC_API_KEY).toBe("single-key");
+    expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBe("example-single-token");
+    expect(env.ANTHROPIC_API_KEY).toBe("example-single-key");
   });
 
   it("handles undefined credential vars", async () => {
@@ -116,30 +116,30 @@ describe("resolveCredentialPools", () => {
 
   it("resolves both credential vars independently", async () => {
     const env: Record<string, string | undefined> = {
-      CLAUDE_CODE_OAUTH_TOKEN: "oauth1,oauth2",
-      ANTHROPIC_API_KEY: "apikey1,apikey2",
+      CLAUDE_CODE_OAUTH_TOKEN: "example-oauth1,example-oauth2",
+      ANTHROPIC_API_KEY: "example-apikey1,example-apikey2",
     };
     await resolveCredentialPools(env);
-    expect(["oauth1", "oauth2"]).toContain(env.CLAUDE_CODE_OAUTH_TOKEN!);
-    expect(["apikey1", "apikey2"]).toContain(env.ANTHROPIC_API_KEY!);
+    expect(["example-oauth1", "example-oauth2"]).toContain(env.CLAUDE_CODE_OAUTH_TOKEN!);
+    expect(["example-apikey1", "example-apikey2"]).toContain(env.ANTHROPIC_API_KEY!);
   });
 });
 
 describe("validateClaudeCredentials", () => {
   it("returns 'oauth' when CLAUDE_CODE_OAUTH_TOKEN is set", () => {
-    const env = { CLAUDE_CODE_OAUTH_TOKEN: "some-oauth-token" };
+    const env = { CLAUDE_CODE_OAUTH_TOKEN: "example-some-oauth-token" };
     expect(validateClaudeCredentials(env)).toBe("oauth");
   });
 
   it("returns 'api_key' when only ANTHROPIC_API_KEY is set", () => {
-    const env = { ANTHROPIC_API_KEY: "sk-ant-123" };
+    const env = { ANTHROPIC_API_KEY: "example-sk-ant-123" };
     expect(validateClaudeCredentials(env)).toBe("api_key");
   });
 
   it("returns 'oauth' when both are set (oauth takes priority)", () => {
     const env = {
-      CLAUDE_CODE_OAUTH_TOKEN: "some-oauth-token",
-      ANTHROPIC_API_KEY: "sk-ant-123",
+      CLAUDE_CODE_OAUTH_TOKEN: "example-some-oauth-token",
+      ANTHROPIC_API_KEY: "example-sk-ant-123",
     };
     expect(validateClaudeCredentials(env)).toBe("oauth");
   });

package/src/utils/multi-runtime.ts

@@ -1,12 +1,12 @@
 import { parseEnvFlag } from "./env-flag";
 
 /**
- * Opt-in, default off: allows one logical agent to be served by several
+ * Enabled by default: allows one logical agent to be served by several
  * worker processes. Lives outside `src/be` so worker-side code can import it
  * without crossing the DB boundary.
  */
 export function isMultiRuntimeEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-  return parseEnvFlag(env.MULTI_RUNTIME_ENABLED, false);
+  return parseEnvFlag(env.MULTI_RUNTIME_ENABLED, true);
 }
 
 /**

package/src/utils/steering-enabled.ts

@@ -1,12 +1,12 @@
 import { parseEnvFlag } from "./env-flag";
 
 /**
- * Worker-safe steering opt-in reader. Keep this outside `src/be` so
+ * Worker-safe steering flag reader. Keep this outside `src/be` so
  * commands, tools, and providers can use it without crossing the DB boundary.
  *
- * Steering is DISABLED by default: it only turns on when the operator sets
- * `STEERING_ENABLED=true|1`.
+ * Steering is enabled by default. Operators can opt out with
+ * `STEERING_ENABLED=false|0`.
  */
 export function isSteeringEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-  return parseEnvFlag(env.STEERING_ENABLED, false);
+  return parseEnvFlag(env.STEERING_ENABLED, true);
 }

package/src/workflows/executors/agent-task.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
+import { applyPreTaskCreate } from "../../extensions/apply-task-create";
 import { workflowContextKey } from "../../tasks/context-key";
+import { TaskCreationBlockedError } from "../../tasks/errors";
 import { withSiblingAwareness } from "../../tasks/sibling-awareness";
 import type { ExecutorMeta } from "../../types";
 import {
@@ -96,14 +98,19 @@ export class AgentTaskExecutor extends BaseExecutor<
     }
 
     // 3. Create the task (config is already deep-interpolated by the engine)
-    const { description: taskDescription, options: taskOptions } = await withSiblingAwareness(
-      config.template,
-      {
+    const preCreate = await applyPreTaskCreate({
+      description: config.template,
+      options: {
         key: effectiveKey,
         agentId: config.agentId ?? null,
         // A configured workflow target is an author pin, including existing definitions.
         routingReason: config.routingReason ?? (config.agentId ? "human_pinned" : undefined),
         routingNote: config.routingNote,
+        routingSource: config.routingReason
+          ? "declared"
+          : config.agentId
+            ? "engine_default"
+            : undefined,
         source: "workflow",
         tags: config.tags,
         priority: config.priority,
@@ -120,6 +127,14 @@ export class AgentTaskExecutor extends BaseExecutor<
         followUpConfig: config.followUpConfig,
         contextKey: workflowContextKey({ workflowRunId: meta.runId }),
       },
+      origin: "workflow",
+    });
+    if (preCreate.kind === "blocked") {
+      throw new TaskCreationBlockedError(preCreate.reason, preCreate.extension);
+    }
+    const { description: taskDescription, options: taskOptions } = await withSiblingAwareness(
+      preCreate.description,
+      preCreate.options,
     );
     const task = await db.createTaskExtended(taskDescription, taskOptions);
 

package/templates/ai-toolbox.manifest.json

@@ -17,7 +17,7 @@
     "templates/skills/comms/files/references/visual-shapes.md": "5e07e9250ad4cdc877af2281525185f0de89c01f90a077463a2c77c8a7b998e8",
     "templates/skills/delegate-work/config.json": "5b1542eb0be359bb8a17117fcf87917e0607d1b939ae3266ddffacdc14efb281",
     "templates/skills/delegate-work/content.md": "c9562bd17846d3595d40172ecfdc6f85bb99eaf23597eb9d5aa9635d5c14d079",
-    "templates/skills/delegate-work/files/scripts/codex-exec.sh": "c2222986c46ac608403f28f201230cb34c7d7ac41a2262dc2c8dbd99c8645dbb",
+    "templates/skills/delegate-work/files/scripts/codex-exec.sh": "be9b33ba111afc8b38c20a4190eae19099025474d4ed3278d944ee0e6b6621af",
     "templates/skills/design-docs/config.json": "b78141763541486d67a105e8fa23873c9ffee6a682832c4b7266b8320d55ead7",
     "templates/skills/design-docs/content.md": "fc860031defbd192c1b8e1c024b46509d78dcf10dbf1b8c93cc4d62396153a52",
     "templates/skills/design-docs/files/template.md": "72d2cdcf8713c08d525d69892c5fed536107594522e3e799ae44f51df7015a36",
@@ -103,6 +103,12 @@
   ],
   "source": "https://github.com/desplega-ai/ai-toolbox.git",
   "transforms": {
+    "bundledCommentRewrites": [
+      {
+        "path": "scripts/codex-exec.sh",
+        "skill": "delegate-work"
+      }
+    ],
     "executableBitsDowngraded": [
       {
         "path": "scripts/codex-exec.sh",

package/templates/extensions/README.md

@@ -0,0 +1,17 @@
+# Extension templates
+
+Ready-to-install extension bundles. Each folder holds `manifest.json`, `hooks.ts`, and a README with its config.
+
+| Name | Event | What it does |
+|---|---|---|
+| `require-ticket-ref` | `pre.task.create` | Blocks REST, MCP, and Slack tasks that do not name a ticket |
+| `notify-on-complete` | `post.task.completed`, `post.task.failed` | Posts a summary to a Slack channel |
+| `require-verification-note` | `pre.tool.call` | Refuses completion without a `Verified:` line in the output |
+
+Install one with the REST route or the `extension-install` MCP tool, then enable it from Settings, Extensions:
+
+```bash
+bun scripts/extensions/install-template.ts require-ticket-ref --config '{"pattern":"\\bDES-\\d+\\b"}'
+```
+
+The hook contract is served at `GET /api/extensions/type-defs`. The `swarm-extensions` seeded skill teaches agents the same flow.

package/templates/extensions/notify-on-complete/README.md

@@ -0,0 +1,11 @@
+# notify-on-complete
+
+Posts one Slack message per finished task to a channel of your choice. Uses `ctx.swarm.slack_post`, so the message is sent by the swarm bot on behalf of the `ext:notify-on-complete` identity.
+
+Config:
+
+```json
+{ "channelId": "C0123456789", "includeFailed": true, "maxOutputChars": 400 }
+```
+
+Post hooks run after the task change is committed and cannot block or modify anything. A Slack failure counts as a handler failure; five in a row auto-disable the extension.

package/templates/extensions/notify-on-complete/hooks.ts

@@ -0,0 +1,61 @@
+import type { CtxFor, SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({
+  channelId: z.string().min(1),
+  includeFailed: z.boolean().default(true),
+  maxOutputChars: z.number().int().min(40).max(2000).default(400),
+});
+
+const manifest = {
+  name: "notify-on-complete",
+  description: "Posts a short summary to a Slack channel when a task completes or fails",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+type SdkResult = { success?: boolean; status?: number; data?: unknown };
+
+// SDK calls resolve with { success, status, data } and do not throw on a tool error.
+// Throwing here makes the failure visible in the run log and counts toward auto-disable.
+async function post(ctx: CtxFor<typeof manifest>, message: string): Promise<void> {
+  const result = (await ctx.swarm.slack_post({
+    channelId: ctx.config.channelId,
+    message,
+  })) as SdkResult;
+  if (!result?.success) {
+    throw new Error(
+      `slack_post failed (${result?.status ?? "no status"}): ${JSON.stringify(result?.data ?? null).slice(0, 200)}`,
+    );
+  }
+}
+
+function clip(text: string, max: number): string {
+  const single = text.replace(/\s+/g, " ").trim();
+  return single.length > max ? `${single.slice(0, max - 1)}…` : single;
+}
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("post.task.completed", async (event, ctx) => {
+    const title = event.task.title ?? clip(event.task.task, 80);
+    await post(
+      ctx,
+      `:white_check_mark: *${title}* completed (task \`${event.task.id.slice(0, 8)}\`)\n${clip(event.output, ctx.config.maxOutputChars)}`,
+    );
+    await ctx.state.incr("notified:completed");
+  });
+
+  api.on("post.task.failed", async (event, ctx) => {
+    if (!ctx.config.includeFailed) return;
+    const title = event.task.title ?? clip(event.task.task, 80);
+    await post(
+      ctx,
+      `:x: *${title}* failed (task \`${event.task.id.slice(0, 8)}\`)\n${clip(event.failureReason, ctx.config.maxOutputChars)}`,
+    );
+    await ctx.state.incr("notified:failed");
+  });
+};
+
+export default extension;

package/templates/extensions/notify-on-complete/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "notify-on-complete",
+  "description": "Posts a short summary to a Slack channel when a task completes or fails",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": { "hooks": "hooks.ts" }
+}

package/templates/extensions/require-ticket-ref/README.md

@@ -0,0 +1,11 @@
+# require-ticket-ref
+
+Blocks new tasks that do not name a ticket. Applies to the origins listed in `config.origins` (default `rest`, `mcp`, `slack`), so schedules, workflows, webhooks, and follow-ups keep working.
+
+Config:
+
+```json
+{ "pattern": "\\bDES-\\d+\\b", "origins": ["rest", "mcp", "slack"] }
+```
+
+Effect: REST returns `422` with the reason, `send-task` returns an error result, and Slack replies with the reason in the thread. The extension state keeps a `blocked:<origin>` counter.

package/templates/extensions/require-ticket-ref/hooks.ts

@@ -0,0 +1,30 @@
+import { block, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+// Config: which origins to police and what a ticket reference looks like.
+export const config = z.object({
+  pattern: z.string().default("\\b[A-Z]{2,10}-\\d+\\b"),
+  origins: z.array(z.string()).default(["rest", "mcp", "slack"]),
+});
+
+const manifest = {
+  name: "require-ticket-ref",
+  description: "Blocks new tasks from selected origins unless the description names a ticket",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.task.create", async (event, ctx) => {
+    if (!ctx.config.origins.includes(event.origin)) return;
+    if (new RegExp(ctx.config.pattern).test(event.description)) return;
+    await ctx.state.incr(`blocked:${event.origin}`);
+    return block(
+      `Task must reference a ticket (pattern ${ctx.config.pattern}). Add the ticket id to the description and retry.`,
+    );
+  });
+};
+
+export default extension;

package/templates/extensions/require-ticket-ref/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "require-ticket-ref",
+  "description": "Blocks new tasks from selected origins unless the description names a ticket",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": { "hooks": "hooks.ts" }
+}

package/templates/extensions/require-verification-note/README.md

@@ -0,0 +1,11 @@
+# require-verification-note
+
+Guards `store-progress` with `status: "completed"`. The call is refused until the `output` contains the configured marker (default `Verified:`). The agent sees the reason as a tool error and can retry with a corrected output.
+
+Config:
+
+```json
+{ "marker": "Verified:" }
+```
+
+The guard covers agent MCP calls only. REST and dashboard completions are not tool calls and pass through.

package/templates/extensions/require-verification-note/hooks.ts

@@ -0,0 +1,32 @@
+import { block, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({
+  marker: z.string().min(1).default("Verified:"),
+});
+
+const manifest = {
+  name: "require-verification-note",
+  description: "Refuses task completion unless the output contains a verification line",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+type StoreProgressArgs = { status?: unknown; output?: unknown };
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.tool.call", (event, ctx) => {
+    if (event.tool !== "store-progress") return;
+    if (!event.args || typeof event.args !== "object") return;
+    const { status, output } = event.args as StoreProgressArgs;
+    if (status !== "completed") return;
+    if (typeof output === "string" && output.includes(ctx.config.marker)) return;
+    return block(
+      `Completion output must contain a "${ctx.config.marker}" line that says how the result was checked. Add it and call store-progress again.`,
+    );
+  });
+};
+
+export default extension;

package/templates/extensions/require-verification-note/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "require-verification-note",
+  "description": "Refuses task completion unless the output contains a verification line",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": { "hooks": "hooks.ts" }
+}

package/templates/schedules/daily-hn-briefing/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPORT_EMAIL"],
   "requires": ["agentmail"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["research", "briefing", "browser"]
 }

package/templates/schedules/gtm-weekly-review/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPO_URL", "GSC_PROPERTY"],
   "requires": ["github", "gsc"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["gtm", "metrics", "reporting"]
 }

package/templates/schedules/weekly-code-health-reports/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPO_URL", "BRANCH", "SCOPE_PATH", "REPORT_NAME", "PAGE_ID"],
   "requires": ["github"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["code-quality", "maintenance", "reporting", "community-template"]
 }

package/templates/schedules/weekly-dependabot-triage/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPO_URL", "SLACK_CHANNEL_ID", "TIMEZONE"],
   "requires": ["github", "slack"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["github", "dependencies", "maintenance"]
 }

package/templates/schedules/weekly-dora-metrics/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPO_URL", "BRANCH", "TAG_PATTERN", "REPORT_NAME", "PAGE_ID"],
   "requires": ["github"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["dora", "metrics", "engineering-productivity", "reporting", "community-template"]
 }

package/templates/schedules/weekly-harness-upgrade-check/config.json

@@ -9,6 +9,6 @@
   "category": "schedules",
   "placeholders": ["REPO_URL", "PR_REVIEWER"],
   "requires": ["github"],
-  "runAllSeedersCandidate": false,
+  "runAllSeedersCandidate": true,
   "tags": ["harness", "upgrade", "maintenance"]
 }