@desplega.ai/agent-swarm 1.85.0 → 1.86.0

package/templates/schedules/daily-compounding-reflection/config.json

@@ -0,0 +1,21 @@
+{
+  "kind": "schedule",
+  "name": "daily-compounding-reflection",
+  "displayName": "Daily Compounding Reflection",
+  "slug": "daily-compounding-reflection",
+  "title": "Daily Compounding Reflection",
+  "description": "Capture lessons from the day into memory, skills, and workflow improvements.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": [
+    "SLACK_CHANNEL_ID",
+    "TIMEZONE"
+  ],
+  "runAllSeedersCandidate": true,
+  "tags": [
+    "memory",
+    "skills",
+    "operations"
+  ],
+  "must": true
+}

package/templates/schedules/daily-compounding-reflection/content.md

@@ -0,0 +1,210 @@
+# Daily Compounding Reflection
+
+Capture lessons from the day into memory, skills, and workflow improvements.
+
+## Schedule
+
+```json
+{
+  "cron": "10 2 * * *",
+  "timezone": "UTC",
+  "agentRole": "lead",
+  "enabled": true
+}
+```
+
+## Scheduled Task
+
+This is the full task prompt the schedule runs on each fire — including the accumulated operational learnings baked into it. Adapt the swarm-specific references (channel IDs, agent names, repo paths) to your environment before enabling.
+
+Task Type: Daily Evolution — "Compounding Engine"
+
+You are Lead. This is the swarm's daily evolution routine. You are a real team working for Desplega Labs (desplega.ai) — the agent swarm, agent-fs, and related products. Your job is to make the team sharper every single day through three concrete folds.
+
+The purpose is NOT to write a nice Slack post. It's to make measurable changes to the swarm's memory, agent context files, and skills. The Slack post is just the receipt.
+
+---
+
+## Phase 0: Gather Context (DO NOT SKIP)
+
+1. **Read today's blocker digest first.** Use `memory-search` with query "daily-blocker-digest" and read the latest entry. The `daily-blocker-digest` schedule runs 5 minutes before this. Any `RESOLVED-STALE` items in its output are direct evidence of our worst failure mode (trusting stale state). Fold 1 MUST write at least one lesson memory per RESOLVED-STALE item.
+2. Use `get-tasks` with status "completed" (limit 25) to see what got done since the last reflection.
+3. Use `get-tasks` with status "failed" (limit 10) to see what went wrong.
+4. Use `memory-search` with query "daily evolution" to find the last reflection and track continuity.
+5. Use `get-swarm` to see the current state of all agents (their profiles, SOUL.md, IDENTITY.md, etc.).
+6. Review the last few days of completed tasks per agent to understand who did what and how well.
+7. Use `skill-list` to see all current skills and their installation status.
+
+---
+
+## Fold 1: Memory Improvement
+
+The swarm's memory is its institutional knowledge. It should grow smarter, not just bigger.
+
+### 1A. Extract New Learnings
+- Review completed tasks from the last 24h. For each non-trivial completion:
+  - Was there a reusable pattern, gotcha, or solution? → Write it as a shared memory
+  - Was there a codebase insight that other agents should know? → Write it as a shared memory
+  - Was there a process learning (what worked, what didn't)? → Write it as a shared memory
+- Review failed tasks: What went wrong? Is there a preventable pattern? → Write a "lesson learned" memory
+- **Blocker-digest input**: For each RESOLVED-STALE item caught by today's blocker digest, write a "how did this stay stale for N days?" post-mortem memory. The root cause is almost always an assumption that wasn't re-verified — codify the trigger that should have caught it.
+
+### 1B. Curate Existing Memories
+- Use `memory-search` with broad queries related to recent work areas to find existing memories
+- Identify stale or outdated memories (e.g., references to files/tools that no longer exist) → Note them for cleanup
+- Identify duplicate or overlapping memories → Consolidate into a single, better version
+- Check if any memories contradict the current state of the codebase → Update or remove them
+
+### 1C. Fill Knowledge Gaps
+- Based on recent task patterns, are there areas where agents keep having to re-discover things?
+- Are there common questions or lookups that should be pre-loaded as memories?
+- Write 1-3 targeted memories that would have saved time in yesterday's work
+
+**Track all memory changes** (created, updated, consolidated, flagged for removal).
+
+---
+
+## Fold 2: Agent Evolution
+
+Each agent has context files that shape how they think and work: SOUL.md (personality, values, core identity), IDENTITY.md (role, expertise, working style), CLAUDE.md (operational rules, project instructions), and TOOLS.md (environment knowledge). These should evolve based on real performance.
+
+### 2A. Performance Review (per agent)
+For each active agent (Lead, Picateclas, Researcher, Reviewer, Tester, Jackknife):
+- How many tasks did they complete in the last 24-48h?
+- Did any tasks fail? What was the failure pattern?
+- Did they need retries or corrections?
+- Did they discover new capabilities or tools?
+- Did any task reveal a gap in their knowledge or instructions?
+
+### 2B. Identify Evolution Actions
+Pick 1-3 agents to evolve today (rotate — don't always pick the same ones). For each:
+
+**SOUL.md changes** — personality and values evolution:
+- Did they demonstrate a new strength? Codify it.
+- Did they show a weakness? Add a hard rule to prevent it.
+- Has their role expanded or narrowed? Reflect it.
+
+**IDENTITY.md changes** — role and expertise evolution:
+- New areas of expertise demonstrated? Add them.
+- Working style insights? Update quirks/preferences.
+- New tools or repos they've mastered? Add to expertise.
+
+**CLAUDE.md changes** — operational rules:
+- New operational patterns discovered? Add as rules.
+- Rules that proved too strict or too loose? Adjust.
+- New project context that affects how they should work? Add it.
+
+**TOOLS.md changes** — environment knowledge:
+- New services, APIs, or tools discovered? Document them.
+- Changed endpoints, ports, or configurations? Update them.
+- Tips and tricks learned? Add them.
+
+### 2C. Execute Evolution
+For each evolution action:
+- Use `update-profile` with the agent's ID and the updated field (soulMd, identityMd, claudeMd, toolsMd)
+- Be surgical — don't rewrite entire files, update the specific section that changed
+- Log exactly what you changed and why
+
+**IMPORTANT**: When updating an agent's profile, you MUST first read their current profile from the `get-swarm` output, then make targeted edits. Do NOT overwrite their entire SOUL.md/IDENTITY.md with a template — that destroys accumulated evolution.
+
+### 2D. Self-Evolution (Lead)
+Don't forget yourself. Review your own performance:
+- Did your task routing work well? Were tasks assigned to the right agents?
+- Did your coordination cause any bottlenecks?
+- Did the blocker digest catch stale-state items you should have caught sooner? → Add a verification rule to your own CLAUDE.md
+- Update your own SOUL.md/IDENTITY.md/CLAUDE.md/TOOLS.md if needed
+
+---
+
+## Fold 3: Skill Evolution
+
+Skills are the swarm's procedural knowledge — tested playbooks for how to do things. They compound by capturing what agents learn into reusable procedures.
+
+### 3A. Identify Skill Candidates
+- Review completed tasks: Was any task done by researching something that should have been a skill?
+- Look for repeated patterns: Has the same type of task been done 3+ times with a stable approach?
+- Check failed tasks: Did an agent waste context on research that a skill could have prevented?
+- Review agent sessions: Did any agent ignore an existing skill and re-derive the same knowledge? (This is a skill discoverability problem.)
+
+### 3B. Create New Skills
+For each candidate:
+1. Draft the skill content (procedure, examples, gotchas)
+2. Use `skill-create` with clear name, description, and `agentAutoTrigger` field
+3. Use `skill-install` to install it for relevant agents
+4. The description and trigger fields are CRITICAL — they determine whether agents find and use the skill
+
+### 3C. Update Existing Skills
+- Use `skill-list` with `includeContent: true` to review current skills
+- Are any skills outdated (e.g., referencing old APIs, wrong procedures)?
+- Are any skills not being used? Check if the description/trigger is too vague
+- Update skills with `skill-update` as needed
+
+### 3D. Verify Skill Adoption
+- Check recent task sessions: Are agents actually invoking skills via the `Skill` tool?
+- If not, investigate why:
+  - Is the skill's description/trigger too vague? → Make it more specific
+  - Is the skill not installed for the right agents? → Install it
+  - Is the agent's prompt not mentioning skills? → Update their TOOLS.md
+
+**Track all skill changes** (created, updated, installed/uninstalled).
+
+---
+
+## Phase 4: Post to Slack (THE RECEIPT)
+
+Use `slack-post` with channelId "C0A4J7GB0UD". Format:
+
+```
+🧬 Daily Evolution — [date]
+
+**Prelude — Blocker Digest:**
+- [X] real blockers still pending humans
+- [Y] RESOLVED-STALE items caught & removed from HEARTBEAT
+- Worst offender: [item that lingered longest]
+
+**Fold 1 — Memory:**
+- [X] new memories written
+- [X] memories curated/consolidated
+- [X] stale memories flagged
+- Key insight: [what the swarm learned today]
+
+**Fold 2 — Agent Evolution:**
+- [Agent Name]: [what was changed in which file and why]
+- [Agent Name]: [what was changed in which file and why]
+(or "All agents performing well — no evolution needed today" — but this should be RARE)
+
+**Fold 3 — Skill Evolution:**
+- [X] new skills created
+- [X] existing skills updated
+- [X] skills installed for agents
+- Key action: [what procedural knowledge was captured or improved]
+(or "No skill changes needed today" — acceptable if skills are current)
+
+**Deferred:** [anything needing user input]
+```
+
+Keep it concise. The proof is in the changes, not the prose.
+
+---
+
+## Phase 5: Verify
+
+Before calling `store-progress`:
+1. Did you read the blocker digest memory? (Phase 0 step 1)
+2. Did you write/update at least 1 memory? (Fold 1)
+3. Did you call `update-profile` for at least 1 agent OR have a documented reason why no evolution was needed? (Fold 2)
+4. Did you review skills and either create/update one OR document why no changes were needed? (Fold 3)
+5. Did you post to Slack?
+
+If you have zero changes across all three folds and zero deferred items, something went wrong — go back and look harder.
+
+## Anti-patterns to avoid:
+- ❌ Posting a Slack summary without making actual changes
+- ❌ Claiming agent evolution without calling `update-profile`
+- ❌ Rewriting an entire SOUL.md from scratch (destroys history)
+- ❌ Only ever evolving 1 agent and ignoring the others
+- ❌ Writing vague memories ("things went well") instead of specific ones
+- ❌ Completing in under 2 minutes (impossible to do this properly that fast)
+- ❌ Skipping Fold 1, Fold 2, or Fold 3 entirely
+- ❌ Ignoring skill adoption problems (agents not using skills that exist)
+- ❌ Ignoring RESOLVED-STALE items from the blocker digest — they're the highest-signal lessons we get each day

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

@@ -0,0 +1,13 @@
+{
+  "kind": "schedule",
+  "name": "daily-hn-briefing",
+  "displayName": "Daily Hacker News Briefing",
+  "slug": "daily-hn-briefing",
+  "title": "Daily Hacker News Briefing",
+  "description": "Demonstrate web research automation by summarizing relevant technology discussion.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": ["SLACK_CHANNEL_ID", "TIMEZONE"],
+  "runAllSeedersCandidate": false,
+  "tags": ["research", "briefing", "browser"]
+}

package/templates/schedules/daily-hn-briefing/content.md

@@ -0,0 +1,97 @@
+# Daily Hacker News Briefing
+
+Demonstrate web research automation by summarizing relevant technology discussion.
+
+## Schedule
+
+```json
+{
+  "cron": "30 2 * * *",
+  "timezone": "UTC",
+  "agentRole": "lead",
+  "enabled": true
+}
+```
+
+## Scheduled Task
+
+This is the full task prompt the schedule runs on each fire — including the accumulated operational learnings baked into it. Adapt the swarm-specific references (channel IDs, agent names, repo paths) to your environment before enabling.
+
+Task Type: General (Browser Automation + Email Report)
+Goal: Daily Hacker News briefing — scrape HN using browser automation, email the report, and archive it
+
+Instructions:
+
+1. Use qa-use browser commands (e.g., `/qa-use:explore`) to scrape the following HN pages **ONE AT A TIME, STRICTLY SEQUENTIAL**.
+
+   **CRITICAL — DO NOT PARALLELIZE.** Do NOT fan out parallel browser sessions, do NOT launch multiple Browser Use SDK flows concurrently, do NOT batch the URLs into a single multi-target call. This template has auto-failed on 2026-05-10 and 2026-05-11 because the worker scraped all 5 URLs in parallel and crossed the heartbeat-stale watchdog threshold before the flows completed. Strict serial execution is required.
+
+   **Workflow:** Scrape URL #1 → call `store-progress` with a one-line update (e.g., "Scraped HN page 1 — N stories found") → scrape URL #2 → `store-progress` → … → URL #5 → `store-progress`. After every individual URL scrape, you MUST call `store-progress` BEFORE starting the next URL. This keeps the session heartbeat fresh and prevents the watchdog from killing the task.
+
+   **Visit each URL one-by-one in this exact order:**
+   - https://news.ycombinator.com (page 1)
+   - https://news.ycombinator.com/?p=2 (page 2)
+   - https://news.ycombinator.com/?p=3 (page 3)
+   - https://news.ycombinator.com/newest
+   - https://news.ycombinator.com/show
+
+   You MUST visit all 5 URLs above. Do not skip any. Do not parallelize. Do not combine into a single browser call.
+
+2. From ALL scraped pages, filter for stories relevant to these topics:
+   - AI / LLMs / foundation models
+   - Agentic coding / AI-powered development
+   - E2E testing / browser automation / QA
+   - Developer tools / DevOps
+   - Startups / SaaS relevant to Desplega's space
+
+3. Format a quick-scan briefing. Organize by source section:
+   - **Front Page** (from pages 1-3)
+   - **New** (from /newest)
+   - **Show HN** (from /show)
+
+   Each item MUST include:
+   - HN title as a link
+   - Post date (e.g., "Feb 24" or "2h ago") — REQUIRED on every item
+   - Direct link to story (or HN comments link)
+   - 1 short line on why it's relevant
+   - Points/comments count if notable
+
+   Example format per item:
+   • Emdash — Open-source agentic dev environment (https://news.ycombinator.com/item?id=12345) · Feb 24 · 65 pts · 30 comments
+     Direct peer to Cursor/Windsurf — agentic-first IDE.
+
+4. If any story is exceptionally relevant to Desplega (E2E testing, browser automation, AI agents), add a "Deep Dive" section with 2-3 sentences.
+
+5. STORE THE REPORT: Save the full briefing as a markdown file at:
+   /workspace/shared/hn-briefings/YYYY-MM-DD.md
+   (using today's date). Create the directory if it doesn't exist. The file should include:
+   - Title: "# HN Briefing — [DATE]"
+   - Stats line: number of stories curated, number scraped, pages checked
+   - The full curated list (organized by section)
+   - Any deep dives
+   This creates a persistent archive we can reference later.
+
+6. SEND EMAIL: Use AgentMail MCP tools to send the report as an email:
+   - From inbox: lead@agent-swarm.dev
+   - To: t@desplega.ai AND e@desplega.ai
+   - Subject: "HN Briefing — [TODAY'S DATE, e.g. Feb 25, 2026]"
+   - Body: Send as HTML email. Format the briefing nicely with:
+     - A header: "HN Briefing — [DATE]"
+     - Stats line (include "Sources: Front Page (3 pages), New, Show HN")
+     - Each section clearly labeled
+     - Each story as a bullet with clickable links
+     - Deep dives in a separate section if applicable
+   - Also include the plain text version in the text field
+
+7. Call `store-progress` when done with the formatted briefing as output.
+
+IMPORTANT:
+- Use qa-use browser automation to browse HN, don't use web search
+- **Scrape URLs SERIALLY (one at a time) and call `store-progress` between every URL** — never parallelize, never fan-out. This prevents heartbeat-stale auto-fails.
+- Only include stories from the last ~24 hours
+- ALWAYS include the post date on each story — this is required
+- Keep it scannable — clickable links, not walls of text
+- Target 5-20 relevant stories (quality over quantity)
+- You MUST scrape all 5 URLs (3 main pages + new + show) — this is required, but ONE AT A TIME
+- The email is sent from lead@agent-swarm.dev using AgentMail MCP `send_message` tool
+- Recipients: t@desplega.ai AND e@desplega.ai

package/templates/schedules/daily-workflow-health-audit/config.json

@@ -0,0 +1,13 @@
+{
+  "kind": "schedule",
+  "name": "daily-workflow-health-audit",
+  "displayName": "Daily Workflow Health Audit",
+  "slug": "daily-workflow-health-audit",
+  "title": "Daily Workflow Health Audit",
+  "description": "Check scheduled jobs and workflows for repeated failures, stale runs, and silent drift.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": ["SLACK_CHANNEL_ID", "TIMEZONE"],
+  "runAllSeedersCandidate": true,
+  "tags": ["workflows", "schedules", "reliability"]
+}

package/templates/schedules/daily-workflow-health-audit/content.md

@@ -0,0 +1,189 @@
+# Daily Workflow Health Audit
+
+Check scheduled jobs and workflows for repeated failures, stale runs, and silent drift.
+
+## Schedule
+
+```json
+{
+  "cron": "0 8 * * *",
+  "timezone": "UTC",
+  "agentRole": "lead",
+  "enabled": true
+}
+```
+
+## Scheduled Task
+
+This is the full task prompt the schedule runs on each fire — including the accumulated operational learnings baked into it. Adapt the swarm-specific references (channel IDs, agent names, repo paths) to your environment before enabling.
+
+Task Type: Daily Workflow + Schedule Health Audit
+
+You are Lead. Run this audit and post a single Slack digest. **Source ask:** Eze in `C0A4J7GB0UD` thread ts `1779264760.065579` (2026-05-20). Cadence: daily at 08:00 UTC. Purpose: surface any workflow run or scheduled-task fire from the last 24h that hard-failed or silently failed (completed but produced nothing useful) so we catch broken cron/workflow plumbing before it ages out.
+
+---
+
+## Phase 1 — Query the six failure modes
+
+Use `db-query` for each.
+
+### 1A. Hard-failed workflow runs (last 24h)
+
+```sql
+SELECT wr.id, w.name AS workflowName, wr.status,
+       wr.finishedAt, wr.lastUpdatedAt,
+       SUBSTR(COALESCE(wr.error, ''), 1, 220) AS errSnippet
+FROM workflow_runs wr
+JOIN workflows w ON w.id = wr.workflowId
+WHERE wr.status = 'failed'
+  AND datetime(COALESCE(wr.finishedAt, wr.lastUpdatedAt, wr.startedAt)) > datetime('now', '-24 hours')
+ORDER BY wr.lastUpdatedAt DESC;
+```
+
+### 1B. Hard-failed schedule-spawned tasks (last 24h)
+
+```sql
+SELECT t.id, s.name AS scheduleName, t.status,
+       SUBSTR(COALESCE(t.failureReason, ''), 1, 220) AS reasonSnippet,
+       SUBSTR(COALESCE(t.output, ''), 1, 220) AS outSnippet,
+       t.lastUpdatedAt
+FROM agent_tasks t
+LEFT JOIN scheduled_tasks s ON s.id = t.scheduleId
+WHERE t.status = 'failed'
+  AND t.scheduleId IS NOT NULL
+  AND datetime(t.lastUpdatedAt) > datetime('now', '-24 hours')
+ORDER BY t.lastUpdatedAt DESC;
+```
+
+### 1C. Halted >24h workflow runs (silent stuck)
+
+```sql
+SELECT wr.id, w.name AS workflowName, wr.status, wr.lastUpdatedAt
+FROM workflow_runs wr
+JOIN workflows w ON w.id = wr.workflowId
+WHERE wr.status IN ('running', 'waiting')
+  AND datetime(wr.lastUpdatedAt) < datetime('now', '-24 hours')
+ORDER BY wr.lastUpdatedAt ASC;
+```
+
+### 1D. Silent: schedule-spawned task completed with empty/sentinel output
+
+```sql
+SELECT t.id, s.name AS scheduleName, t.status,
+       SUBSTR(COALESCE(t.output, ''), 1, 220) AS outSnippet,
+       LENGTH(TRIM(COALESCE(t.output, ''))) AS outLen,
+       t.lastUpdatedAt
+FROM agent_tasks t
+LEFT JOIN scheduled_tasks s ON s.id = t.scheduleId
+WHERE t.status = 'completed'
+  AND t.scheduleId IS NOT NULL
+  AND datetime(t.lastUpdatedAt) > datetime('now', '-24 hours')
+  AND (
+    t.output IS NULL
+    OR TRIM(t.output) = ''
+    OR TRIM(t.output) = '⚡ Running shell command'
+    OR LENGTH(TRIM(t.output)) < 10
+  )
+ORDER BY t.lastUpdatedAt DESC;
+```
+
+### 1E. Cron didn't fire (nextRunAt in the past)
+
+```sql
+SELECT s.id, s.name, s.cronExpression, s.lastRunAt, s.nextRunAt, s.consecutiveErrors,
+       SUBSTR(COALESCE(s.lastErrorMessage, ''), 1, 220) AS lastErrSnippet
+FROM scheduled_tasks s
+WHERE s.enabled = 1
+  AND s.scheduleType = 'recurring'
+  AND s.nextRunAt IS NOT NULL
+  AND datetime(s.nextRunAt) < datetime('now', '-1 hour')
+ORDER BY s.nextRunAt ASC;
+```
+
+### 1F. Schedules with consecutive errors (defensive)
+
+```sql
+SELECT s.id, s.name, s.cronExpression, s.consecutiveErrors, s.lastErrorAt,
+       SUBSTR(COALESCE(s.lastErrorMessage, ''), 1, 220) AS lastErrSnippet
+FROM scheduled_tasks s
+WHERE s.enabled = 1
+  AND s.consecutiveErrors >= 3
+ORDER BY s.consecutiveErrors DESC;
+```
+
+### 1G. Totals (for the "all clear" denominator)
+
+```sql
+SELECT
+  (SELECT COUNT(*) FROM workflow_runs WHERE datetime(lastUpdatedAt) > datetime('now','-24 hours')) AS workflowRuns24h,
+  (SELECT COUNT(*) FROM agent_tasks WHERE scheduleId IS NOT NULL AND datetime(lastUpdatedAt) > datetime('now','-24 hours')) AS scheduledFires24h;
+```
+
+---
+
+## Phase 2 — Render the digest
+
+Each bullet must include a clickable URL.
+
+- Workflow run URL: `https://app.agent-swarm.dev/workflow-runs/<id>` → Slack format: `<https://app.agent-swarm.dev/workflow-runs/<id>|workflow:<workflowName>>`
+- Task URL: `https://app.agent-swarm.dev/tasks/<id>` → Slack format: `<https://app.agent-swarm.dev/tasks/<id>|schedule:<scheduleName>>`
+
+Truncate error/output snippets to 200 chars + `…` if longer. Replace newlines with ` ⏎ `.
+
+### Template
+
+If TOTAL issues across 1A–1F is zero:
+
+```
+:white_check_mark: *Daily Workflow + Schedule Health Audit* — <YYYY-MM-DD>
+
+<@U08NY4B5R2M> All clear — <workflowRuns24h> workflow runs + <scheduledFires24h> scheduled fires in the last 24h, all produced expected output.
+```
+
+Otherwise:
+
+```
+:stethoscope: *Daily Workflow + Schedule Health Audit* — <YYYY-MM-DD>
+
+<@U08NY4B5R2M> Audit window: last 24h. Totals: <workflowRuns24h> workflow runs · <scheduledFires24h> scheduled fires · *<TOTAL_ISSUES> issues*
+
+*Hard failures — workflow runs* (<N1A>)
+• <url|workflow:name> — failed <relative-time>
+  ↳ <errSnippet>
+
+*Hard failures — scheduled tasks* (<N1B>)
+• <url|schedule:name> — failed <relative-time>
+  ↳ <reasonSnippet OR outSnippet OR "(no failureReason set)">
+
+*Silent: halted >24h* (<N1C>)
+• <url|workflow:name> — status=<status>, no progress since <timestamp>
+
+*Silent: empty output* (<N1D>)
+• <url|schedule:name> — completed, output=<"empty" | first-N-chars>
+
+*Cron didn't fire on time* (<N1E>)
+• schedule:<name> (cron `<expr>`) — nextRunAt=<past-timestamp>, lastRunAt=<timestamp or "never">
+
+*Schedules with ≥3 consecutive errors* (<N1F>)
+• schedule:<name> — consecutiveErrors=<n>, last error: <lastErrSnippet>
+```
+
+Omit any section whose count is 0. Cap message at 4000 chars (Slack limit) — if longer, keep top 5 per section and add `…and <K> more` lines.
+
+---
+
+## Phase 3 — Post to Slack and complete
+
+1. Call `slack-post` with `channelId="C0A4J7GB0UD"` and `message=<rendered digest>`. **Do NOT** thread under the design thread `1779264760.065579` — daily fires are top-level so they're easy to scan.
+2. Call `store-progress` with `status: "completed"` and a one-paragraph `output` summary:
+   - `Issues found: hard-fail-wf=<N1A>, hard-fail-task=<N1B>, halted-24h=<N1C>, silent-empty=<N1D>, cron-stuck=<N1E>, consec-err=<N1F>.`
+   - `Totals: workflowRuns24h=<X>, scheduledFires24h=<Y>.`
+   - `Slack message ts: <ts from slack-post response>.`
+
+## Anti-patterns
+
+- ❌ Posting a separate Slack message per failure mode — ONE digest.
+- ❌ Raw IDs without clickable URLs.
+- ❌ Dumping full `error` / `output` content — truncate to 220 chars per item.
+- ❌ Threading the daily digest under the original 1779264760.065579 design thread.
+- ❌ Skipping the "all clear" message when zero issues — the heartbeat itself is the signal that the audit ran.

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

@@ -0,0 +1,13 @@
+{
+  "kind": "schedule",
+  "name": "gtm-weekly-review",
+  "displayName": "Weekly GTM Metrics Review",
+  "slug": "gtm-weekly-review",
+  "title": "Weekly GTM Metrics Review",
+  "description": "Summarize product, marketing, or sales signals into an operator-friendly weekly review.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": ["SLACK_CHANNEL_ID", "TIMEZONE"],
+  "runAllSeedersCandidate": false,
+  "tags": ["gtm", "metrics", "reporting"]
+}

package/templates/schedules/gtm-weekly-review/content.md

@@ -0,0 +1,58 @@
+# Weekly GTM Metrics Review
+
+Summarize product, marketing, or sales signals into an operator-friendly weekly review.
+
+## Schedule
+
+```json
+{
+  "cron": "20 3 * * 1",
+  "timezone": "UTC",
+  "agentRole": "lead",
+  "enabled": true
+}
+```
+
+## Scheduled Task
+
+This is the full task prompt the schedule runs on each fire — including the accumulated operational learnings baked into it. Adapt the swarm-specific references (channel IDs, agent names, repo paths) to your environment before enabling.
+
+Task Type: Research
+Topic: Weekly GTM Metrics Review for agent-swarm
+
+Goal: Check current GitHub stars, traffic, Google Search Console performance, and content metrics for the GTM campaign.
+
+Instructions:
+1. Check GitHub metrics: `gh api repos/desplega-ai/agent-swarm` (stars, forks, issues)
+2. Check traffic: `gh api repos/desplega-ai/agent-swarm/traffic/views` and `/traffic/clones`
+3. Check referrers: `gh api repos/desplega-ai/agent-swarm/traffic/popular/referrers`
+4. Check popular content: `gh api repos/desplega-ai/agent-swarm/traffic/popular/paths`
+
+5. **Pull Google Search Console data** using the `gsc-analytics` skill (already installed on this agent). Do NOT write Python auth code — use the `gsc` CLI at `/workspace/repos/agent-work/gsc/gsc`. The setup script already wires up `GOOGLE_APPLICATION_CREDENTIALS`, so no extra env setup needed.
+
+   Pull the weekly snapshot for each of the 4 Desplega properties:
+   ```bash
+   GSC=/workspace/repos/agent-work/gsc/gsc
+   for site in desplega.ai agent-swarm.dev desplega.sh agent-fs.dev; do
+     echo "=== $site ==="
+     $GSC analytics "sc-domain:$site" --top 20 --json > "/tmp/gsc-$site.json"
+     jq '{current, previous, window, prior,
+          top_queries: [.topQueries[:10][] | {q: .keys[0], c: .clicks, i: .impressions, ctr: .ctr, pos: .position}],
+          top_pages:   [.topPages[:10][]   | {p: .keys[0], c: .clicks, i: .impressions, ctr: .ctr, pos: .position}]
+         }' "/tmp/gsc-$site.json"
+   done
+   ```
+
+   The `analytics` subcommand returns headline KPIs (clicks, impressions, CTR, avg position) PLUS a WoW comparison against the prior 7 days — this is what powers the "this week vs last week" section of the report.
+
+6. Review the GTM plan at /workspace/shared/thoughts/shared/research/gtm-state-assessment.md
+7. Compile a brief report with:
+   - Current star count, weekly change
+   - Top traffic sources
+   - **GSC summary**: total clicks/impressions across all domains, top performing queries, queries with growth potential (high impressions, low CTR or position 5-20)
+   - What's working, what to try next
+   - **SEO opportunities**: queries where we're close to page 1, content gaps to fill
+
+Save report to /workspace/shared/thoughts/shared/research/gtm-weekly-{date}.md
+
+This is part of the GTM: Agent Swarm → 100k GitHub Stars epic.

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

@@ -0,0 +1,13 @@
+{
+  "kind": "schedule",
+  "name": "weekly-dependabot-triage",
+  "displayName": "Weekly Dependency Triage",
+  "slug": "weekly-dependabot-triage",
+  "title": "Weekly Dependency Triage",
+  "description": "Review dependency update PRs, group safe patches, and flag risky upgrades.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": ["SLACK_CHANNEL_ID", "REPO_URL", "TIMEZONE"],
+  "runAllSeedersCandidate": false,
+  "tags": ["github", "dependencies", "maintenance"]
+}