patchwork-os 0.2.0-alpha.3 → 0.2.0-alpha.31

package/scripts/start-all.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
-# Full orchestrator for bridge + claude + remote-control.
-# Manages all three in tmux panes with health monitoring.
+# Full orchestrator for bridge + claude + remote-control + dashboard.
+# Manages all processes in tmux panes with health monitoring.
 #
 # Pane layout:
 #   0 — health monitor (orchestrator)
@@ -8,7 +8,8 @@
 #   2 — claude --ide (Claude Code CLI, connects to bridge for IDE tools)
 #   3 — claude remote-control --spawn=session (exposes the workspace to claude.ai;
 #         spawned sessions auto-discover the bridge via ~/.claude/ide/*.lock)
-#   4 — SSH reverse tunnel to VPS (optional, enabled with --vps <user@host:port>)
+#   4 — Patchwork dashboard (Next.js, http://localhost:3200)
+#   5 — SSH reverse tunnel to VPS (optional, enabled with --vps <user@host:port>)
 #         Forwards VPS_PORT on the remote host back to the local bridge port.
 #         Allows claude.ai integrations to use a static VPS URL instead of a
 #         rotating remote-control session URL.
@@ -20,6 +21,8 @@
 # Options:
 #   --workspace <path>    Directory to open in Claude (default: current directory)
 #   --full                Register all ~95 bridge tools (git, terminal, file ops, HTTP, GitHub).
+#   --no-dashboard        Skip starting the Patchwork dashboard (pane 4).
+#   --dashboard-port <N>  Dashboard port (default: 3200).
 #                         Default is slim mode (27 IDE-exclusive tools). Add --full if your
 #                         workflow requires git/terminal/file tools.
 #   --notify <topic>      Push notifications via ntfy.sh when remote-control connects or
@@ -48,6 +51,8 @@ NTFY_TOPIC=""
 IDE_NAME=""
 VPS=""
 FULL_MODE=""
+NO_DASHBOARD=""
+DASHBOARD_PORT="3200"
 AUTOMATION_POLICY=""
 CLAUDE_DRIVER="subprocess"
 BRIDGE_READY_TIMEOUT="${BRIDGE_READY_TIMEOUT:-30}"
@@ -64,6 +69,8 @@ while [[ $# -gt 0 ]]; do
     --ide)               IDE_NAME="$2"; shift 2 ;;
     --vps)               VPS="$2"; shift 2 ;;
     --full)              FULL_MODE="--full"; shift ;;
+    --no-dashboard)      NO_DASHBOARD=1; shift ;;
+    --dashboard-port)    DASHBOARD_PORT="$2"; shift 2 ;;
     --automation-policy) AUTOMATION_POLICY="$2"; shift 2 ;;
     --claude-driver)     CLAUDE_DRIVER="$2"; shift 2 ;;
     *)                   echo "Unknown option: $1" >&2; exit 1 ;;
@@ -90,23 +97,31 @@ fi
 
 # --- Bridge conflict check ---
 # Detect an already-running bridge instance and abort early with a clear message.
-# Iterates lock files safely (no xargs injection); filters to isBridge:true + live PID.
+# Validates: isBridge:true + live PID + process is actually a bridge (not Windsurf reusing PID)
+# by checking whether the lock file's port has an active listener.
 while IFS= read -r lock; do
   [[ -f "$lock" ]] || continue
-  bridge_pid=$(python3 -c "
+  lock_info=$(python3 -c "
 import json, sys
 try:
     d = json.load(open(sys.argv[1]))
     if d.get('isBridge') is True:
-        print(d.get('pid', ''))
+        print(d.get('pid', ''), d.get('port', ''))
 except Exception:
     pass
 " "$lock" 2>/dev/null || true)
+  bridge_pid="${lock_info%% *}"
+  bridge_port="${lock_info##* }"
   if [[ -n "$bridge_pid" ]] && kill -0 "$bridge_pid" 2>/dev/null; then
-    echo "Error: bridge already running (PID $bridge_pid, lock: $(basename "$lock"))." >&2
-    echo "       Stop it first: kill $bridge_pid" >&2
-    echo "       Or kill the tmux session: tmux kill-session -t claude-all" >&2
-    exit 1
+    # Cross-check: verify a process is actually listening on the lock's port.
+    # Windsurf may reuse PIDs from stale locks — if nothing listens on that port,
+    # the bridge is not actually running.
+    if [[ -n "$bridge_port" ]] && lsof -i ":${bridge_port}" 2>/dev/null | grep -q LISTEN; then
+      echo "Error: bridge already running (PID $bridge_pid, port $bridge_port, lock: $(basename "$lock"))." >&2
+      echo "       Stop it first: kill $bridge_pid" >&2
+      echo "       Or kill the tmux session: tmux kill-session -t claude-all" >&2
+      exit 1
+    fi
   fi
 done < <(ls ~/.claude/ide/*.lock 2>/dev/null)
 
@@ -141,6 +156,7 @@ echo "=== Claude IDE Bridge Full Orchestrator ==="
 echo "  Ctrl+C in any pane — stops that process"
 echo "  Ctrl+B then D (press Ctrl+B, release, then press D) — detach (keeps running)"
 echo "  tmux kill-session -t $SESSION — stop everything"
+[[ -z "$NO_DASHBOARD" ]] && echo "  Dashboard: http://localhost:${DASHBOARD_PORT}"
 [[ -n "$NTFY_TOPIC" ]] && echo "  Push notifications: ntfy.sh/$NTFY_TOPIC"
 if [[ -z "$FULL_MODE" ]]; then
   echo ""
@@ -276,11 +292,12 @@ while true; do
   sleep \$delay
 done'"
 
-# --- Create additional panes (pane 0 = orchestrator, 1 = bridge, 2 = claude, 3 = remote-control, 4 = ssh tunnel) ---
+# --- Create additional panes (pane 0 = orchestrator, 1 = bridge, 2 = claude, 3 = remote-control, 4 = dashboard, 5 = ssh tunnel) ---
 tmux split-window -v -t "$SESSION"    # pane 1 for bridge
 tmux split-window -v -t "$SESSION"    # pane 2 for claude --ide
 tmux split-window -v -t "$SESSION"    # pane 3 for claude remote-control
-[[ -n "$TUNNEL_CMD" ]] && tmux split-window -v -t "$SESSION"  # pane 4 for ssh tunnel (optional)
+[[ -z "$NO_DASHBOARD" ]] && tmux split-window -v -t "$SESSION"  # pane 4 for dashboard (optional)
+[[ -n "$TUNNEL_CMD" ]] && tmux split-window -v -t "$SESSION"    # pane 5 for ssh tunnel (optional)
 tmux select-layout -t "$SESSION" even-vertical
 
 # --- Helper: wait for a NEW lock file (ignores pre-existing ones) ---
@@ -359,10 +376,20 @@ sleep 3
 # Pane 3: Remote control with auto-restart loop
 tmux send-keys -t "${SESSION}:0.3" "$REMOTE_CMD" Enter
 
-# Pane 4: SSH reverse tunnel (only if --vps was set)
+# Pane 4: Dashboard (only if not --no-dashboard and dashboard dir exists)
+DASHBOARD_DIR="$BRIDGE_DIR/dashboard"
+if [[ -z "$NO_DASHBOARD" ]] && [[ -d "$DASHBOARD_DIR" ]]; then
+  BRIDGE_PORT=$(basename "$LOCK_FILE" .lock)
+  DASHBOARD_CMD="cd $(printf '%q' "$DASHBOARD_DIR") && PATCHWORK_BRIDGE_PORT=${BRIDGE_PORT} npm run dev"
+  notify "Starting dashboard on http://localhost:${DASHBOARD_PORT}"
+  tmux send-keys -t "${SESSION}:0.4" "$DASHBOARD_CMD" Enter
+fi
+
+# Pane 5: SSH reverse tunnel (only if --vps was set)
 if [[ -n "$TUNNEL_CMD" ]]; then
   notify "Starting SSH tunnel to ${VPS}..."
-  tmux send-keys -t "${SESSION}:0.4" "$TUNNEL_CMD" Enter
+  TUNNEL_PANE=$([[ -z "$NO_DASHBOARD" ]] && echo 5 || echo 4)
+  tmux send-keys -t "${SESSION}:0.${TUNNEL_PANE}" "$TUNNEL_CMD" Enter
 fi
 
 # --- Health monitor (runs in pane 0 — the orchestrator pane) ---
@@ -377,10 +404,12 @@ cleanup() {
   tmux send-keys -t "${SESSION}:0.1" C-c 2>/dev/null
   tmux send-keys -t "${SESSION}:0.2" C-c 2>/dev/null
   tmux send-keys -t "${SESSION}:0.3" C-c 2>/dev/null
-  [[ -n "$TUNNEL_CMD" ]] && tmux send-keys -t "${SESSION}:0.4" C-c 2>/dev/null
+  [[ -z "$NO_DASHBOARD" ]] && tmux send-keys -t "${SESSION}:0.4" C-c 2>/dev/null
+  [[ -n "$TUNNEL_CMD" ]] && tmux send-keys -t "${SESSION}:0.${TUNNEL_PANE:-4}" C-c 2>/dev/null
   # Wait up to 5s for panes to exit gracefully, then force-kill
   local panes=(1 2 3)
-  [[ -n "$TUNNEL_CMD" ]] && panes=(1 2 3 4)
+  [[ -z "$NO_DASHBOARD" ]] && panes=(1 2 3 4)
+  [[ -n "$TUNNEL_CMD" ]] && panes=("${panes[@]}" "${TUNNEL_PANE:-4}")
   for _ in $(seq 1 5); do
     sleep 1
     all_idle=true
@@ -396,7 +425,8 @@ cleanup() {
   done
   sleep 1
   local rpanes=(3 2 1)
-  [[ -n "$TUNNEL_CMD" ]] && rpanes=(4 3 2 1)
+  [[ -z "$NO_DASHBOARD" ]] && rpanes=(4 3 2 1)
+  [[ -n "$TUNNEL_CMD" ]] && rpanes=("${TUNNEL_PANE:-4}" "${rpanes[@]}")
   for pane in "${rpanes[@]}"; do
     tmux kill-pane -t "${SESSION}:0.${pane}" 2>/dev/null || true
   done
@@ -413,7 +443,8 @@ while true; do
     tmux send-keys -t "${SESSION}:0.1" C-c
     tmux send-keys -t "${SESSION}:0.2" C-c
     tmux send-keys -t "${SESSION}:0.3" C-c
-    [[ -n "$TUNNEL_CMD" ]] && tmux send-keys -t "${SESSION}:0.4" C-c
+    [[ -z "$NO_DASHBOARD" ]] && tmux send-keys -t "${SESSION}:0.4" C-c
+    [[ -n "$TUNNEL_CMD" ]] && tmux send-keys -t "${SESSION}:0.${TUNNEL_PANE:-4}" C-c
     # Wait for bridge (pane 1) and claude (pane 2) to actually stop
     for _ in $(seq 1 10); do
       pane1_cmd=$(tmux display-message -t "${SESSION}:0.1" -p '#{pane_current_command}' 2>/dev/null || echo "")
@@ -476,9 +507,15 @@ while true; do
     sleep 3
     # Restart remote-control
     tmux send-keys -t "${SESSION}:0.3" "$REMOTE_CMD" Enter
+    # Restart dashboard with updated bridge port
+    if [[ -z "$NO_DASHBOARD" ]] && [[ -d "$DASHBOARD_DIR" ]]; then
+      NEW_BRIDGE_PORT=$(basename "$LOCK_FILE" .lock)
+      DASHBOARD_CMD="cd $(printf '%q' "$DASHBOARD_DIR") && PATCHWORK_BRIDGE_PORT=${NEW_BRIDGE_PORT} npm run dev"
+      tmux send-keys -t "${SESSION}:0.4" "$DASHBOARD_CMD" Enter
+    fi
     # Restart SSH tunnel (port may have changed — tunnel cmd reads lock file dynamically)
     if [[ -n "$TUNNEL_CMD" ]]; then
-      tmux send-keys -t "${SESSION}:0.4" "$TUNNEL_CMD" Enter
+      tmux send-keys -t "${SESSION}:0.${TUNNEL_PANE:-4}" "$TUNNEL_CMD" Enter
     fi
     notify "All processes restarted"
   else

package/templates/automation-policies/recipe-authoring.json

@@ -0,0 +1,25 @@
+{
+  "_comment": "recipe-authoring — runs preflight automatically when a .yaml recipe file is saved. Closes the authoring inner loop: edit → save → instant validation feedback via Claude task.",
+  "_usage": "Copy to automation-policy.json. Requires --automation --automation-policy <path> --claude-driver subprocess",
+
+  "automationSystemPrompt": "Recipe lint bot. ≤10 lines. No preamble. List issues with file:line if available. End with 'Recipe OK' when clean.",
+
+  "onRecipeSave": {
+    "enabled": true,
+    "cooldownMs": 10000
+  },
+
+  "onFileSave": {
+    "enabled": false,
+    "_comment": "Disabled — onRecipeSave handles .yaml files. Enable this for non-recipe YAML if needed.",
+    "patterns": ["**/*.yaml", "**/*.yml"],
+    "cooldownMs": 10000,
+    "prompt": "{{file}} saved. getDiagnostics → report issues ≤5 lines."
+  },
+
+  "onGitCommit": {
+    "enabled": true,
+    "cooldownMs": 15000,
+    "prompt": "Committed recipes on {{branch}}: {{files}}\nFor each modified .yaml file: run preflight and report any issues. If all pass, reply 'All recipes OK'."
+  }
+}

package/templates/automation-policy.example.json

@@ -20,6 +20,12 @@
     "cooldownMs": 10000
   },
 
+  "onRecipeSave": {
+    "enabled": false,
+    "_comment": "Fires when any .yaml/.yml file is saved. No prompt needed — default runs patchwork recipe preflight and reports issues. Enable when authoring recipes.",
+    "cooldownMs": 10000
+  },
+
   "onDiagnosticsError": {
     "enabled": true,
     "minSeverity": "error",

package/templates/co.patchwork-os.bridge.plist

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>co.patchwork-os.bridge</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>__BINARY_PATH__</string>
+    <string>--claude-driver</string>
+    <string>subprocess</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>__HOME__/Library/Logs/patchwork-os/bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>__HOME__/Library/Logs/patchwork-os/bridge.err</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>__HOME__</string>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>__HOME__</string>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+</dict>
+</plist>

package/templates/recipes/ctx-loop-test.yaml

@@ -0,0 +1,75 @@
+name: ctx-loop-test
+description: |
+  End-to-end test of the agent-read loop. An agent writes a decision trace with
+  ctxSaveTrace, then reads it back with ctxQueryTraces, and confirms the trace
+  appears in the result. Output lands in ~/.patchwork/inbox/ for manual inspection.
+  Run this after deploying a new bridge build to confirm the memory moat is live.
+
+  NOTE: requires --claude-driver subprocess and a running bridge with HTTP port
+  so the agent subprocess has MCP access. Running via `patchwork recipe run`
+  (local yamlRunner) will fail at Step 1 — the local claude -p subprocess has
+  no bridge MCP context. Trigger from the dashboard Recipes page instead.
+trigger:
+  type: manual
+steps:
+  - tool: git.log_since
+    since: 1h
+    into: recent_commits
+
+  - agent:
+      prompt: |
+        You are validating the Patchwork cross-session memory loop end-to-end.
+
+        RECENT COMMITS (context only):
+        {{recent_commits}}
+
+        Perform the following steps IN ORDER. Stop immediately if any step fails and
+        report the failure clearly in your output.
+
+        ## Step 1 — Write a trace
+        Call ctxSaveTrace with these exact values:
+          ref: "ctx-loop-test-{{date}}"
+          problem: "Validating that ctxSaveTrace persists traces readable by future sessions"
+          solution: "ctxSaveTrace writes to decision_traces.jsonl; ctxQueryTraces reads it back"
+          tags: ["loop-test", "dogfood"]
+
+        Record the returned `seq` number.
+
+        ## Step 2 — Read it back
+        Call ctxQueryTraces with:
+          traceType: "decision"
+          limit: 5
+
+        Check that the trace you just wrote (ref "ctx-loop-test-{{date}}") appears in
+        the results. If it does, the loop is confirmed closed.
+
+        ## Step 3 — Write your report
+        Output a markdown block in this exact format:
+
+        ```
+        # ctx-loop-test — {{date}} {{time}}
+
+        ## Result: PASS / FAIL
+
+        ### Step 1 — ctxSaveTrace
+        - seq: <returned seq>
+        - ref: ctx-loop-test-{{date}}
+        - Status: OK / ERROR: <message>
+
+        ### Step 2 — ctxQueryTraces
+        - Traces returned: <count>
+        - Test trace found: yes / no
+        - Status: OK / ERROR: <message>
+
+        ### Verdict
+        <one sentence summary>
+        ```
+
+        Output ONLY the markdown block. No preamble.
+      driver: claude-code
+      model: claude-haiku-4-5-20251001
+      into: report
+
+  - tool: file.write
+    path: ~/.patchwork/inbox/ctx-loop-test-{{date}}.md
+    content: "{{report}}\n"

package/templates/recipes/lint-on-save.yaml

@@ -9,5 +9,4 @@ steps:
     into: diags
   - tool: file.append
     path: ~/.patchwork/inbox/lint.md
-    content: "- {{time}}  {{file}} — {{diags.errors}} errors, {{diags.warnings}} warnings\n"
-    when: "{{diags.errors}} > 0 || {{diags.warnings}} > 0"
+    content: "- {{time}}  {{file}} — {{diags}}\n"

package/templates/recipes/morning-brief-slack.yaml

@@ -0,0 +1,57 @@
+name: morning-brief-slack
+description: Daily morning brief combining calendar, GitHub PRs, and Linear issues — posted to Slack.
+trigger:
+  type: cron
+  at: "0 8 * * 1-5"
+steps:
+  - tool: github.list_prs
+    author: "@me"
+    max: 10
+    into: prs
+  - tool: linear.list_issues
+    assignee: "@me"
+    state: "started,unstarted"
+    max: 15
+    into: linear_issues
+  - tool: calendar.list_events
+    days_ahead: 1
+    max: 10
+    into: calendar
+  - agent:
+      prompt: |
+        You are a personal assistant writing a concise morning brief. Use ONLY the data provided below — do not call any tools or fetch additional information.
+
+        OPEN PULL REQUESTS (authored by me):
+        {{prs}}
+
+        LINEAR ISSUES (assigned to me, in progress or unstarted):
+        {{linear_issues}}
+
+        TODAY'S CALENDAR EVENTS:
+        {{calendar}}
+
+        Write a short morning brief for Slack. Rules:
+        - Plain text only. No markdown headers (no # or ## lines). No code blocks.
+        - Use emoji to start each section.
+        - Do NOT include a title or greeting line like "Morning Brief" or "Good morning" — start directly with the first section.
+
+        📅 *Calendar* — list today's meetings with time; write "No meetings today" if empty or error
+        🔀 *Pull Requests* — list open PRs needing attention; omit section entirely if empty
+        📋 *Linear* — list in-progress and unstarted issues by priority; omit section entirely if empty or error
+
+        Keep it under 15 lines. Be direct. Output only the brief, nothing else.
+      driver: claude-code
+      model: claude-haiku-4-5-20251001
+      into: brief
+  - tool: file.write
+    path: ~/.patchwork/inbox/morning-brief-{{date}}.md
+    content: |
+      # Morning brief — {{date}}
+
+      {{brief}}
+  - tool: slack.post_message
+    channel: all-massappealdesigns
+    text: |
+      *Morning Brief — {{date}}*
+
+      {{brief}}

package/templates/recipes/morning-brief.yaml

@@ -1,5 +1,5 @@
 name: morning-brief
-description: Daily morning brief combining unread emails, recent git activity, and open GitHub issues.
+description: Daily morning brief combining unread emails, calendar, recent git activity, and open GitHub issues.
 trigger:
   type: cron
   at: "0 8 * * 1-5"
@@ -24,6 +24,10 @@ steps:
     state: "started,unstarted"
     max: 15
     into: linear_issues
+  - tool: calendar.list_events
+    days_ahead: 1
+    max: 10
+    into: calendar
   - agent:
       prompt: |
         You are a personal assistant writing a concise morning brief. Use ONLY the data provided below — do not call any tools or fetch additional information.
@@ -45,16 +49,20 @@ steps:
         LINEAR ISSUES (assigned to me, in progress or unstarted):
         {{linear_issues}}
 
+        TODAY'S CALENDAR EVENTS:
+        {{calendar}}
+
         Write a morning brief with these sections:
         1. **Email triage** — list emails needing action today (sender, subject, one-line summary)
         2. **FYI emails** — informational only, no action needed
-        3. **Code activity** — summarize the RECENT GIT COMMITS above; if the list is empty write "No commits in the last 24 hours"
-        4. **GitHub** — list open issues and PRs needing attention; omit this section entirely if both lists are empty
-        5. **Linear** — list in-progress and unstarted issues by priority; omit this section entirely if the list is empty or returned an error
+        3. **Calendar** — list today's meetings with time and attendees; omit if calendar returned an error or no events
+        4. **Code activity** — summarize the RECENT GIT COMMITS above; if the list is empty write "No commits in the last 24 hours"
+        5. **GitHub** — list open issues and PRs needing attention; omit this section entirely if both lists are empty
+        6. **Linear** — list in-progress and unstarted issues by priority; omit this section entirely if the list is empty or returned an error
 
         Be concise. Skip newsletters and automated notifications.
-      driver: claude-code
-      model: claude-haiku-4-5-20251001
+      # Use claude (not gemini) — Gemini free tier hits daily quota mid-recipe
+      driver: claude
       into: brief
   - tool: file.write
     path: ~/.patchwork/inbox/morning-brief-{{date}}.md

package/templates/recipes/project-health-check.yaml

@@ -0,0 +1,50 @@
+# yaml-language-server: $schema=https://patchworkos.com/schema/recipe.v1.json
+apiVersion: patchwork.sh/v1
+name: project-health-check
+description: Fetch git activity, open issues, and diagnostics in parallel, then write a health summary.
+trigger:
+  type: manual
+maxConcurrency: 4
+steps:
+  - id: gather
+    parallel:
+      - id: commits
+        tool: git.log_since
+        since: 24h
+      - id: issues
+        tool: github.list_issues
+        assignee: "@me"
+        max: 20
+      - id: prs
+        tool: github.list_prs
+        author: "@me"
+        max: 10
+  - id: summarize
+    agent:
+      prompt: |
+        Write a concise project health summary using ONLY the data below.
+
+        RECENT COMMITS (last 24h):
+        {{commits}}
+
+        OPEN ISSUES (assigned to me):
+        {{issues}}
+
+        OPEN PULL REQUESTS:
+        {{prs}}
+
+        Sections:
+        1. **Activity** — what shipped or changed in the last 24 hours
+        2. **Issues** — issues needing attention today; omit if empty
+        3. **PRs** — PRs waiting on review or action; omit if empty
+        4. **Health** — one-sentence overall assessment (on track / needs attention / blocked)
+      driver: claude
+    awaits: [gather]
+  - id: write
+    tool: file.write
+    path: ~/.patchwork/inbox/health-{{date}}.md
+    content: |
+      # Project health — {{date}}
+
+      {{summarize}}
+    awaits: [summarize]

package/templates/recipes/sentry-to-linear.yaml

@@ -0,0 +1,77 @@
+name: sentry-to-linear
+description: |
+  Fetch a Sentry issue, enrich it with git blame, and create a triage-ready
+  Linear ticket. Requires both Sentry and Linear connectors connected.
+  Run ad-hoc or trigger via webhook / automation policy.
+
+# Example manual trigger:
+#   patchwork-os run-recipe sentry-to-linear --var SENTRY_ISSUE_ID=12345678
+#
+# Example automation trigger (add to ~/.patchwork/automation-policy.json):
+#   "onFileSave": { ... }  — or fire from a Sentry webhook handler
+
+trigger:
+  type: manual
+  vars:
+    - name: SENTRY_ISSUE_ID
+      description: "Sentry issue ID or URL (e.g. '12345678' or 'https://sentry.io/...')"
+      required: true
+    - name: LINEAR_TEAM_KEY
+      description: "Linear team key to create the issue in (e.g. 'ENG'). Defaults to first team."
+      required: false
+    - name: LINEAR_PRIORITY
+      description: "Linear priority: 1=urgent, 2=high, 3=medium, 4=low (default: 2)"
+      required: false
+      default: "2"
+
+steps:
+  - agent:
+      prompt: |
+        You are a triage assistant. Your job is to:
+        1. Fetch the Sentry issue using fetchSentryIssue with issueId "{{SENTRY_ISSUE_ID}}"
+        2. Create a Linear issue using createLinearIssue with the data you received
+
+        For the Linear issue:
+        - title: Use the Sentry issue title verbatim
+        - description: Write a structured Markdown body with these sections:
+            ## Error
+            (one-line error type + message from the Sentry title)
+
+            ## Stack trace
+            (the top 5 frames from the stackTrace field, formatted as a code block)
+
+            ## Suspect commit
+            (if topSuspect is present: sha, author, date, subject — otherwise write "No suspect commit identified")
+
+            ## Confidence
+            (the confidence field value + a one-sentence explanation of what it means)
+
+            ## Sentry link
+            (a link back to the Sentry issue — construct from the issueId: https://sentry.io/issues/{{SENTRY_ISSUE_ID}}/)
+
+        - teamKey: "{{LINEAR_TEAM_KEY}}" (pass as-is; if blank the tool picks the first team)
+        - priority: {{LINEAR_PRIORITY}} (as an integer)
+        - labelNames: ["bug"]
+
+        After creating the ticket, respond with ONLY a JSON object:
+        {
+          "sentryIssueId": "<the issueId from fetchSentryIssue>",
+          "sentryTitle": "<the title>",
+          "linearIdentifier": "<e.g. ENG-101>",
+          "linearUrl": "<the url from createLinearIssue>",
+          "confidence": "<high|medium|low>",
+          "suspectCommit": "<sha or null>"
+        }
+
+        If either tool returns an error (sentryConnected: false or linearConnected: false),
+        respond with the same JSON shape but set linearUrl to "" and add an "error" key
+        explaining which connector is not connected.
+      driver: claude-code
+      model: claude-haiku-4-5-20251001
+      into: result
+  - tool: file.write
+    path: ~/.patchwork/inbox/sentry-to-linear-{{date}}.md
+    content: |
+      # Sentry → Linear triage ({{date}})
+
+      {{result}}