@zibby/workflow-templates 0.10.2 → 0.10.10

package/index.js

@@ -737,6 +737,104 @@ export const TEMPLATES = {
       ],
     },
   },
+
+  // ── chat-ops-bot: per-turn chat assistant over your integrations + memory ─
+  // v0: one inbound message → one graph run → a reply. Externalized per-thread
+  // memory + connected-integration auto-discovery. Live Slack/Lark inbound and
+  // Zibby control-plane operation are NOT wired yet — be honest about scope.
+  'zibby-copilot': {
+    name: 'zibby-copilot',
+    displayName: 'Zibby Copilot',
+    description: 'The official first-party Zibby assistant — chat to operate your whole Zibby workspace through the Zibby control-plane (MCP): run, deploy, and trigger agents, install templates from the marketplace, and act across your connected integrations + memory. (v0 — today you trigger it with a message and it replies; live Slack/Lark inbound + full control-plane operation are rolling out.)',
+    path: join(__dirname, 'zibby-copilot'),
+    defaultSlug: 'zibby-copilot',
+    deps: { zod: '^3.23.0', '@zibby/skills': '^0.1.25' },
+    features: [
+      'One inbound message = one graph run (a single chat turn)',
+      'Externalized per-thread memory (conversation-store), keyed by threadKey — runtime stays stateless',
+      'Auto-discovers your connected integrations each turn and exposes their tools to the model — no redeploy',
+      'Exposes the chat-memory skill for cross-thread recall',
+      'v0 — live Slack/Lark inbound wiring is NOT included; trigger it directly with { message, threadKey }',
+      'v0 — Zibby control-plane operation (create/trigger/deploy agents + apps) is a documented seam, not yet live',
+    ],
+    marketplace: {
+      slug: 'zibby-copilot',
+      // Hosting runtime marker. 'chat' = a Slack/Lark-style chat agent that
+      // runs as a Lambda (one inbound message = one chat turn), NOT a Fargate
+      // workflow. The frontend's isChatRuntime() helper reads this to hide the
+      // Fargate-only controls (CLI/schedule/webhook triggers, warm agent,
+      // Activity tab) and point the Logs tab at the Lambda runtime log group.
+      // Absent ⇒ a normal Fargate workflow (the default, unchanged).
+      runtime: 'chat',
+      tagline: 'The official Zibby copilot — run, deploy, and manage your workspace by just asking. (v0)',
+      iconPrompt: [
+        'Flat geometric vector illustration with subtle clean gradients, in the spirit of Linear / Notion / Stripe iconography — crisp, no painterly textures, reads clearly at 64×64.',
+        'Subject: a single rounded chat speech-bubble as the focal element, with a small friendly robot/ops face suggested inside it via two simple dot eyes and a tiny gear motif on its forehead — signalling a chat bot that operates things. A small cyan spark sits at the bubble\'s tail to hint at a live reply.',
+        'Palette: the bubble in a violet-to-indigo gradient (#7C3AED → #4F46E5), the gear + spark accents in soft cyan (#22D3EE), all on a deep navy (#0B0F1A) rounded square (1024×1024) with a faint radial glow centered behind the bubble.',
+        'Composition: bubble centered and dominant, gear + eyes as small secondary accents, plenty of breathing room. Mood: friendly, helpful, conversational-but-capable.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO trademarked Slack / Lark / Zibby logos.',
+      ].join('\n'),
+      tags: ['Notifications', 'Support'],
+      capabilities: [
+        'Runs one chat turn per inbound message and returns a reply',
+        'Remembers the thread via an externalized conversation-store (no warm session needed)',
+        'Auto-discovers connected integrations and offers their tools to the model each turn',
+        'Exposes the chat-memory skill for cross-thread recall',
+        'v0: trigger it directly with { message, threadKey } — live Slack/Lark inbound + Zibby control-plane operation are coming',
+      ],
+      conversationStarters: [
+        'Ask the bot a question and get a reply with your connected tools',
+        'Continue a thread — it remembers the earlier turns by threadKey',
+        'Have it use a connected integration to answer',
+        'Pick up where we left off in this conversation',
+      ],
+    },
+  },
+
+  // ── flaky-test-fixer: collect flaky tests from CI → stabilize → fix PR ─
+  'flaky-test-fixer': {
+    name: 'flaky-test-fixer',
+    displayName: 'Flaky Test Fixer',
+    description: 'Collects flaky tests from CI (CircleCI Insights in v1), has a coding agent diagnose the root cause of the flakiness (timing/race, test-order/shared-state, randomness, network, time deps, un-awaited async) and make the smallest correct fix behind a test-gate, then opens a fix PR/MR. RSpec / npm / pytest auto-detected. Stops at the PR — a human reviews and merges.',
+    path: join(__dirname, 'flaky-test-fixer'),
+    defaultSlug: 'flaky-test-fixer',
+    deps: { zod: '^3.23.0', axios: '^1.6.0', '@zibby/skills': '^0.1.26' },
+    features: [
+      'Graph: collect_flaky (CircleCI Insights) → has_flaky? → fix (agent + git + test-gate) → open_pr → notify',
+      'Pluggable CI adapter seam (lib/ci-adapters.js) — CircleCI in v1, more providers drop in without graph changes',
+      'Flaky-specific fix prompt: diagnose the root cause class, smallest correct fix, or quarantine + say so (never a fake fix)',
+      'Inline test-gate with ONE retry; RSpec (bundle exec rspec) / npm / pytest auto-detected, or TEST_COMMAND override',
+      'Opens a GitHub PR or GitLab MR — body lists the flaky tests + diagnosis + diff; never auto-merges',
+      'CircleCI token is a SECRET in the ENV tab (CIRCLECI_TOKEN), not an input field',
+      'Self-contained (INLINE) — deploy one agent, no sub-graph dependency',
+    ],
+    marketplace: {
+      slug: 'flaky-test-fixer',
+      tagline: 'Find the flaky tests in CI, stabilize them, open the fix PR.',
+      iconPrompt: [
+        'A premium, hi-fi app icon for "Flaky Test Fixer" — a workflow that finds non-deterministic ("flaky") tests in CI and stabilizes them.',
+        'Visual style: 3D-rendered hero object floating in space, in the style of Apple Vision Pro icons, Linear\'s changelog hero illustrations, or a Stripe product render. Glossy, dimensional, with subtle reflections and a soft rim-light.',
+        'Subject: a glossy 3D green test-tube / vial tilted in three-quarter perspective, its liquid mid-transition from an unstable flickering amber (a couple of jittery bubbles escaping near the top) to a calm, settled emerald-green at the base — visually reading "flaky → stabilized". A small violet healing loop-arrow (#7553FF) curves around the tube, and a tiny green checkmark spark glints where the loop closes, signalling the verified fix.',
+        'Background: a deep midnight-navy gradient (#0F172A at the top, #1E1B4B at the bottom) with a single soft violet glow behind the vial and a scatter of faint star-like specks. Square format, 1024×1024.',
+        'Composition: vial centered and slightly raised, loop-arrow wrapping behind-and-around it, subtle drop shadow on the canvas. Mood: clean, premium, reassuring — "it just settles the chaos".',
+        'NO text, NO letters, NO numbers, NO flat sticker style, NO mascot face, NO magnifying glass, NO bug/insect imagery, NO trademarked CircleCI / GitHub / GitLab logos — this one is DEEP and 3D-rendered.',
+      ].join('\n'),
+      tags: ['Testing', 'Bug Triage', 'Incidents'],
+      capabilities: [
+        'Pulls flaky tests from CircleCI\'s Insights API (pluggable for more CI providers later)',
+        'Caps to maxToFix and filters by minimum flake rate per run',
+        'Coding agent diagnoses the flakiness root cause and makes the smallest correct fix',
+        'Runs the repo\'s tests with one retry; RSpec / npm / pytest auto-detected',
+        'Opens a GitHub PR or GitLab MR with the diagnosis — a human reviews and merges',
+      ],
+      conversationStarters: [
+        'Find the flaky tests in my CircleCI project and open a fix PR',
+        'Stabilize the top 3 flakiest RSpec specs and run the suite before opening the PR',
+        'Only attempt tests that flake more than 20% of the time',
+        'Open a flaky-fix MR on GitLab and ping #eng when it\'s up',
+      ],
+    },
+  },
 };
 
 export class TemplateFactory {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zibby/workflow-templates",
-  "version": "0.10.2",
+  "version": "0.10.10",
   "description": "Built-in workflow templates for Zibby — browser-test-automation, code-analysis, generate-test-cases, notify-slack, notify-lark, notify-notion, sentry-triage.",
   "type": "module",
   "main": "index.js",

package/sentry-triage/README.md

@@ -0,0 +1,118 @@
+# sentry-triage
+
+One deployed agent, **two scenarios**, selected by an entry decision on
+`trigger` (the same entry-branch shape as `github-code-review`):
+
+```
+«route»  (decision on state.trigger)
+├─ 'fix' → fetch_issue → fix → «pr_decision» ─┬─ open_pr → notify → End
+│                                             └─ skip ───→ notify → End
+└─ else  → fetch_issues → «has_issues» ─┬─ classify → dispatch_alerts → End
+                                        └─ no issues ─────────────────→ End
+```
+
+- **`trigger: 'triage'`** (default, scheduled): list new Sentry issues →
+  LLM-classify by severity → post a human-voice digest to Slack/Lark.
+- **`trigger: 'fix'`** (webhook / manual): pull ONE issue → clone the repo, have
+  a coding agent make the smallest correct fix with an **inline test-gate** →
+  open a PR/MR → ping chat with the result.
+
+The fix scenario is **self-contained** — the clone/fix/PR logic is brought IN as
+this template's own nodes (adapted from the `code-fix` template). It does **not**
+dispatch a `code-fix` sub-graph, so deploying *only* this agent works (a
+sub-graph would need the child separately deployed → `SUBGRAPH_NOT_FOUND`).
+
+## TRIAGE scenario (default)
+
+```
+fetch_issues    (deterministic + Sentry) → recent unresolved/unassigned issues
+   ↓
+has_issues      (decision)               → End early if Sentry returned nothing
+   ↓
+classify        (LLM)                    → NOISE … CRITICAL, with reasoning
+   ↓
+dispatch_alerts (LLM + Slack/Lark)       → one batched, deduped digest
+```
+
+Runs on a schedule (hourly is typical). Trigger payload is just the lookback:
+
+```json
+{ "sinceMinutes": 60 }
+```
+
+## FIX scenario
+
+```
+fetch_issue (deterministic + Sentry) → ONE full issue: culprit, error type/value,
+                                       filename, latest-event stacktrace, permalink
+   ↓
+fix         (agent + git + test-gate) → clone the repo, make the SMALLEST correct
+                                        fix, run the repo's tests with ONE retry,
+                                        commit + push zibby/sentry-fix-<id>-<rand>
+   ↓ (only if a branch was pushed)
+open_pr     (deterministic)           → open a GitHub PR or GitLab MR
+   ↓
+notify      (optional chat)           → "🛠 Auto-fixed Sentry <id> → PR <url>"
+                                        or "⚠️ Couldn't auto-fix … needs a human"
+```
+
+### Triggering a fix
+
+Set `trigger: "fix"` and pass the issue id + repo. From a Sentry **issue alert**
+webhook, or manually:
+
+```json
+{
+  "trigger": "fix",
+  "issueId": "1234567890",
+  "repoUrl": "https://github.com/acme/web"
+}
+```
+
+- `issueId` — required when `trigger:"fix"` (numeric id or shortId). Enforced in
+  `fetch_issue` (so a triage run never has to carry it).
+- `repoUrl` — the repo to fix. Falls back to the `REPO_URL` ENV var if omitted.
+
+The git token is **runner-injected** from the project's connected GitHub/GitLab
+integration — it's spliced into the clone/push URL and used to open the PR/MR.
+
+### Test-gate
+
+After the agent's edit, `fix` runs the repo's test command. A non-zero exit
+feeds the captured output back into the prompt for **one** re-edit, then stops.
+No test command detectable → the change isn't gated (a human still reviews the
+PR). There is no in-engine approval gate — the open PR/MR *is* the approval; we
+never auto-merge.
+
+## ENV-tab config
+
+| Var | Scenario | Meaning |
+|---|---|---|
+| `SLACK_CHANNEL` | both | Slack channel id `C012345` or `#name`. Set ONE chat target (triage digest; fix notify). |
+| `LARK_RECEIVE_ID` | both | Lark `oc_…` chat id, `ou_…` open id, or email. |
+| `SEVERITY_THRESHOLD` | triage | `NOISE\|LOW\|MEDIUM\|HIGH\|CRITICAL` (default `MEDIUM`) — digest skip-floor. |
+| `SLACK_MENTIONS` / `LARK_MENTIONS` | triage | JSON array — appended to CRITICAL alerts only. |
+| `DISPATCH_RULES` | triage | Free-form natural-language routing overrides. |
+| `ROUTING_PREFER_AUTHOR` / `ROUTING_HIGH_SEVERITY_GROUP` | triage | Author-DM + escalation-group routing. |
+| `REPO_URL` | fix | Repo to fix (used when the `repoUrl` input is absent). |
+| `TEST_COMMAND` | fix | Override the auto-detected test command (`npm test`, `pytest -q`, …). |
+| `PR_BASE` | fix | Base branch for the PR/MR (default `main`). |
+
+## Required integrations
+
+| Integration | Why |
+|---|---|
+| **Sentry** (required) | both scenarios — list issues (triage) / fetch one issue (fix). |
+| **GitHub OR GitLab** | the fix scenario clones + pushes + opens a PR/MR. Surfaced as an optional connect (the `git` meta-skill clones public repos anonymously), but a token is needed in practice for private repos + to push/open the PR. |
+| **Slack OR Lark** | the triage digest (required OR-group). The fix-scenario ping reuses the same target and degrades gracefully if neither is set. |
+
+## Reused vs new
+
+- **Reused**: the entire TRIAGE scenario (`fetch_issues` / `classify` /
+  `dispatch_alerts`) is unchanged. The fix scenario's clone/edit/test-gate/push
+  mechanics + GitHub PR creation are adapted from the `code-fix` template
+  (`fix-code-node` + `create-pr-node`); the chat-notify helper mirrors
+  `github-code-review/lib/notify.js`.
+- **New**: the entry `route` decision (triage vs fix), the single-issue
+  `fetch_issue` (with latest-event stacktrace hydration), the inline-clone fix
+  node, and **GitLab MR creation** in `open_pr` (code-fix was GitHub-only).

package/sentry-triage/graph.mjs

@@ -1,35 +1,50 @@
 /**
- * sentry-triage — parent workflow. Hourly Sentry issue triage.
+ * sentry-triage — MULTI-SCENARIO parent workflow.
  *
- * Agent-driven first. Nodes are LLM agents by default — because nobody
- * hand-edits these in practice, they point an AGENT at the prompt and say
- * "make billing always critical" / "page #oncall after 9pm". A deterministic
- * for-loop can't be told that in English; an agent can. We drop to
- * deterministic ONLY where it genuinely makes sense — a pure mechanical step
- * with zero judgment and nothing a customer would ever want to tune.
+ * ONE deployed agent, TWO scenarios, selected by an entry decision on
+ * state.trigger (mirrors github-code-review's entry `route`):
  *
- *   fetch_issues    (deterministic + SKILLS.SENTRY) → pull recent unresolved/
- *                                                      unassigned issues + suspect
- *                                                      commits. Pure API pull, no
- *                                                      judgment, nothing to tune →
- *                                                      the one place a for-loop
- *                                                      wins (faster, free, no
- *                                                      hallucinated queries).
- *        ↓
- *   classify        (LLM agent)                     → label NOISE…CRITICAL. Stays
- *                                                      an agent BECAUSE the rubric
- *                                                      is customer-tunable, and
- *                                                      they tune it by having an
- *                                                      agent edit this prompt — not
- *                                                      by touching code.
- *        ↓
- *   dispatch_alerts (LLM agent + SKILLS.CHAT_NOTIFY) → one human-voice digest;
- *                                                      routing is the user's
- *                                                      (DISPATCH_RULES) to own.
+ *   «route»  (decision on state.trigger)
+ *   ├─ 'fix' → fetch_issue → fix → «pr_decision» ─┬─ open_pr → notify → End
+ *   │                                             └─ skip ───→ notify → End
+ *   └─ else  → fetch_issues → «has_issues» ─┬─ classify → dispatch_alerts → End
+ *                                           └─ no issues ─────────────────→ End
  *
- * Also: LLM dispatch BATCHES related issues into one message and DE-DUPs —
- * a for-loop can't. outputSchema enforcement → every above-threshold issue
- * gets a "sent" or explicit "skipped/failed" record; no silent drops.
+ * ── TRIAGE scenario (default — UNCHANGED scheduled hourly triage) ──
+ *   fetch_issues    (deterministic + SKILLS.SENTRY) — pull recent unresolved/
+ *                                                     unassigned issues + suspect
+ *                                                     commits.
+ *   has_issues      (decision)                      — short-circuit to End when
+ *                                                     Sentry returned nothing.
+ *   classify        (LLM agent)                     — label NOISE…CRITICAL.
+ *   dispatch_alerts (LLM agent + SKILLS.CHAT_NOTIFY)— one human-voice digest.
+ *
+ * ── FIX scenario (NEW — INLINE, self-contained: NO sub-graph dispatch) ──
+ *   fetch_issue (deterministic + SKILLS.SENTRY) — pull ONE full issue
+ *                                                 (state.issueId): culprit,
+ *                                                 metadata, latest stacktrace.
+ *   fix         (agent + SKILLS.GIT + inline     — clone the repo (repoUrl /
+ *                test-gate)                         REPO_URL), make the smallest
+ *                                                  correct fix, run tests with
+ *                                                  ONE retry, commit + push a
+ *                                                  zibby/sentry-fix-<id>-<rand>
+ *                                                  branch (github OR gitlab).
+ *   pr_decision (decision)                       — open_pr only when a branch was
+ *                                                  pushed; else straight to notify.
+ *   open_pr     (deterministic)                  — open a GitHub PR / GitLab MR.
+ *   notify      (OPTIONAL chat, custom-execute)  — Slack/Lark "auto-fixed → PR"
+ *                                                  or "couldn't fix — needs a
+ *                                                  human". Graceful (never throws).
+ *
+ * WHY INLINE (not a code-fix sub-graph): sub-graph dispatch
+ * ({ workflow:'code-fix' }) requires the child to be SEPARATELY deployed →
+ * SUBGRAPH_NOT_FOUND for a customer who deploys only this agent. The clone/fix/
+ * PR logic is adapted IN from code-fix's nodes so deploying this one agent works.
+ *
+ * Integrations: SENTRY required (both scenarios). The fix scenario's `fix` node
+ * declares SKILLS.GIT → "GitHub OR GitLab" required for that scenario.
+ * chat_notify is required via the triage dispatcher (OR-group Slack/Lark); the
+ * fix-scenario notify keeps its post optional (calls the handler directly).
  */
 
 import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
@@ -38,11 +53,35 @@ import { fetchIssuesNode } from './nodes/fetch-issues-node.js';
 import { classifyNode } from './nodes/classify-node.js';
 import { dispatchNode } from './nodes/dispatch-node.js';
 
+import { fetchIssueNode } from './nodes/fetch-issue-node.js';
+import { fixNode } from './nodes/fix-node.js';
+import { openPRNode } from './nodes/open-pr-node.js';
+import { notifyFixNode } from './nodes/notify-fix-node.js';
+
 import {
   sentryTriageInputSchema,
   sentryTriageContextSchema,
 } from './state.js';
 
+// Entry decision — trigger:'fix' routes to the auto-fix branch; everything else
+// (incl. the absent/default 'triage') runs the scheduled triage. Returns the
+// real entry-node id of each branch so the runtime routes directly to it.
+function routeByTrigger(state) {
+  return state?.trigger === 'fix' ? 'fetch_issue' : 'fetch_issues';
+}
+
+// TRIAGE: skip everything when Sentry returned nothing this window.
+function routeHasIssues(state) {
+  return (state?.fetch_issues?.issues || []).length === 0 ? 'END' : 'classify';
+}
+
+// FIX: open a PR/MR only when `fix` actually pushed a branch; otherwise skip
+// straight to notify (which posts the "couldn't fix" message).
+function routeFixToPR(state) {
+  const ok = state?.fix?.success === true && !!state?.fix?.branch;
+  return ok ? 'open_pr' : 'notify';
+}
+
 export class SentryTriageAgent extends WorkflowAgent {
   buildGraph() {
     const graph = new WorkflowGraph();
@@ -50,42 +89,75 @@ export class SentryTriageAgent extends WorkflowAgent {
       .setInputSchema(sentryTriageInputSchema)
       .setContextSchema(sentryTriageContextSchema);
 
-    // Route OUT of the decision: skip everything when Sentry returned nothing
-    // this window, else classify. (Shared by the decision node's condition and
-    // its labeled edges so the logic lives in one place.)
-    const routeHasIssues = (state) =>
-      (state?.fetch_issues?.issues || []).length === 0 ? 'END' : 'classify';
+    // Entry decision — auto-renders as a Condition diamond (ConditionalNode).
+    graph.addConditionalNode('route', { condition: routeByTrigger });
 
-    graph.addNode('fetch_issues',    fetchIssuesNode);
-    // Explicit decision node → renders as a clean Condition diamond. The branch
-    // comes OUT of this, not hung off the fetch_issues work node.
+    // ── TRIAGE branch ────────────────────────────────────────────────
+    graph.addNode('fetch_issues', fetchIssuesNode);
     graph.addConditionalNode('has_issues', { condition: routeHasIssues });
-    graph.addNode('classify',        classifyNode);
+    graph.addNode('classify', classifyNode);
     graph.addNode('dispatch_alerts', dispatchNode);
 
-    graph.setEntryPoint('fetch_issues');
+    // ── FIX branch ───────────────────────────────────────────────────
+    graph.addNode('fetch_issue', fetchIssueNode);
+    graph.addNode('fix', fixNode);
+    graph.addConditionalNode('pr_decision', { condition: routeFixToPR });
+    graph.addNode('open_pr', openPRNode);
+    graph.addNode('notify', notifyFixNode);
+
+    graph.setEntryPoint('route');
+
+    // Entry diamond: fix → fetch_issue …; triage → fetch_issues …
+    graph.addConditionalEdges('route', routeByTrigger, {
+      labels: { fetch_issue: 'fix', fetch_issues: 'triage' },
+    });
+
+    // TRIAGE flow (unchanged).
     graph.addEdge('fetch_issues', 'has_issues');
-    // Short-circuit when Sentry returned nothing for this window. The empty-list
-    // case is the common idle path, and running classify + dispatch on empty
-    // input wastes two Claude calls per run — at hourly cadence across many
-    // tenants that adds up. Routing to END at the graph level (vs short-circuit
-    // inside each prompt) skips the model round-trips entirely.
     graph.addConditionalEdges('has_issues', routeHasIssues, {
       labels: { classify: 'has issues', END: 'no issues' },
     });
-    graph.addEdge('classify',        'dispatch_alerts');
+    graph.addEdge('classify', 'dispatch_alerts');
     graph.addEdge('dispatch_alerts', 'END');
 
+    // FIX flow.
+    graph.addEdge('fetch_issue', 'fix');
+    graph.addConditionalEdges('fix', routeFixToPR, {
+      labels: { open_pr: 'pushed a fix', notify: 'no fix' },
+    });
+    graph.addEdge('open_pr', 'notify');
+    graph.addEdge('notify', 'END');
+
     return graph;
   }
 
   async onComplete(result) {
-    const s = result?.state?.dispatch_alerts?.summary || {};
-    const classifications = result?.state?.classify?.classifications || [];
+    const state = result?.state || {};
+
+    // FIX scenario: log the fix outcome.
+    if (state.trigger === 'fix') {
+      const issue = state.fetch_issue?.issue || {};
+      const fix = state.fix || {};
+      const pr = state.open_pr || {};
+      const notify = state.notify_fix || {};
+      console.log(
+        `[sentry-triage] complete — mode=fix ` +
+        `issue=${issue.shortId || issue.id || 'n/a'} ` +
+        `branch=${fix.branch || '(none)'} ` +
+        `tested=${fix.tested === true} testsPassed=${fix.testsPassed === true} ` +
+        `pr_url=${pr.pr_url || '(none)'} ` +
+        `notify=${notify.sent ? notify.target : (notify.skipped ? 'skipped' : 'no')}`,
+      );
+      return;
+    }
+
+    // TRIAGE scenario (unchanged).
+    const s = state.dispatch_alerts?.summary || {};
+    const classifications = state.classify?.classifications || [];
     const noise = classifications.filter((c) => c.severity === 'NOISE').length;
-    const fetched = result?.state?.fetch_issues?.issues?.length || 0;
+    const fetched = state.fetch_issues?.issues?.length || 0;
     console.log(
-      `[sentry-triage] complete — fetched=${fetched}, noise=${noise}, ` +
+      `[sentry-triage] complete — mode=triage fetched=${fetched}, noise=${noise}, ` +
       `sent=${s.sent || 0}, skipped=${s.skipped || 0}, failed=${s.failed || 0}`,
     );
   }

package/sentry-triage/lib/notify.js

@@ -0,0 +1,67 @@
+/**
+ * Optional chat notification — provider-agnostic, best-effort, NEVER throws.
+ *
+ * Used by the FIX scenario's `notify` node to post a one-line "auto-fixed /
+ * couldn't fix" ping. Identical in spirit to github-code-review/lib/notify.js
+ * (templates can't import across dirs, so each ships its own copy): it calls the
+ * chat_notify meta-skill's tool handler DIRECTLY rather than declaring
+ * SKILLS.CHAT_NOTIFY on the node, so this particular post stays graceful — a
+ * missing/unconnected chat integration just yields { sent:false }, and the fix
+ * (PR already opened) is unaffected.
+ *
+ * Slack is preferred when both targets are set. The string literals
+ * 'slack'/'lark' ALSO double as the signal the workflow executor's usage-scan
+ * keys off to inject SLACK_BOT_TOKEN / LARK_APP_ID|SECRET into the task env.
+ */
+
+function parseToolResult(raw) {
+  if (raw == null) return null;
+  if (typeof raw === 'object') return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { error: 'non-JSON tool result' };
+  }
+}
+
+/**
+ * Post to Slack (slackChannel) or Lark (larkReceiveId). Returns
+ * { sent, target?, detail? } and never throws.
+ *
+ * @param {{ slackChannel?: string, larkReceiveId?: string, text: string }} args
+ * @returns {Promise<{ sent: boolean, target?: string, detail?: string }>}
+ */
+export async function postChatNotification({ slackChannel, larkReceiveId, text } = {}) {
+  const channel = slackChannel && String(slackChannel).trim();
+  const receiveId = larkReceiveId && String(larkReceiveId).trim();
+  if (!channel && !receiveId) return { sent: false, detail: 'no notify target' };
+  if (!text || !String(text).trim()) return { sent: false, detail: 'empty message' };
+
+  if (channel) {
+    try {
+      const { chatNotifySkill } = await import('@zibby/skills');
+      const data = parseToolResult(
+        await chatNotifySkill.handleToolCall('slack_post_message', { channel, text }),
+      );
+      if (data && !data.error && (data.ok || data.ts)) {
+        return { sent: true, target: `slack:${channel}` };
+      }
+      return { sent: false, target: `slack:${channel}`, detail: (data && data.error) || 'slack post failed' };
+    } catch (e) {
+      return { sent: false, target: `slack:${channel}`, detail: `slack post error (non-fatal): ${e?.message || e}` };
+    }
+  }
+
+  try {
+    const { chatNotifySkill } = await import('@zibby/skills');
+    const data = parseToolResult(
+      await chatNotifySkill.handleToolCall('lark_send_message', { receive_id: receiveId, text }),
+    );
+    if (data && !data.error && (data.ok || data.message_id || data.data)) {
+      return { sent: true, target: `lark:${receiveId}` };
+    }
+    return { sent: false, target: `lark:${receiveId}`, detail: (data && data.error) || 'lark send failed' };
+  } catch (e) {
+    return { sent: false, target: `lark:${receiveId}`, detail: `lark send error (non-fatal): ${e?.message || e}` };
+  }
+}

package/sentry-triage/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.7","results":[[":nodes/__tests__/dispatch.test.js",{"duration":8.644457999999986,"failed":false}],[":__tests__/graph.integration.test.js",{"duration":8.647458000000029,"failed":false}],[":nodes/__tests__/open-pr.test.js",{"duration":10.167542000000026,"failed":false}],[":nodes/__tests__/fix.test.js",{"duration":12.375999999999976,"failed":false}],[":nodes/__tests__/notify-fix.test.js",{"duration":6.512499999999989,"failed":false}]]}