patchwork-os 0.2.0-alpha.0 → 0.2.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchwork-os",
-  "version": "0.2.0-alpha.0",
+  "version": "0.2.0-alpha.10",
   "description": "Patchwork OS — proactive, multi-model AI teammate built on the Claude IDE Bridge. One agent, any model, works while you're away.",
   "type": "module",
   "main": "dist/index.js",

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/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/gmail-health-check.yaml

@@ -0,0 +1,19 @@
+name: gmail-health-check
+description: Verify Gmail connector is working and report inbox stats.
+trigger:
+  type: manual
+steps:
+  - tool: gmail.fetch_unread
+    since: 7d
+    max: 5
+    into: recent
+  - tool: gmail.search
+    query: "is:unread"
+    max: 1
+    into: unread_check
+  - tool: file.write
+    path: ~/.patchwork/inbox/gmail-health-{{date}}.md
+    content: |
+      # Gmail health check — {{date}} {{time}}
+      Unread (last 7d): {{recent.count}}
+      Total unread check: {{unread_check.count}}

package/templates/recipes/inbox-triage.yaml

@@ -0,0 +1,15 @@
+name: inbox-triage
+description: Fetch unread emails from last 24h and write a prioritised triage summary.
+trigger:
+  type: cron
+  at: "0 8 * * 1-5"
+steps:
+  - tool: gmail.fetch_unread
+    since: 24h
+    max: 50
+    into: messages
+  - tool: file.write
+    path: ~/.patchwork/inbox/triage-{{date}}.md
+    content: |
+      # Inbox triage — {{date}} {{time}}
+      Unread messages: {{messages.count}}

package/templates/recipes/morning-brief.yaml

@@ -0,0 +1,72 @@
+name: morning-brief
+description: Daily morning brief combining unread emails, calendar, recent git activity, and open GitHub issues.
+trigger:
+  type: cron
+  at: "0 8 * * 1-5"
+steps:
+  - tool: gmail.fetch_unread
+    since: 24h
+    max: 30
+    into: messages
+  - tool: git.log_since
+    since: 24h
+    into: commits
+  - tool: github.list_issues
+    assignee: "@me"
+    max: 10
+    into: issues
+  - 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.
+
+        UNREAD EMAILS ({{messages.count}} total):
+        <untrusted_data>
+        {{messages.json}}
+        </untrusted_data>
+
+        RECENT GIT COMMITS (last 24h):
+        {{commits}}
+
+        OPEN GITHUB ISSUES (assigned to me):
+        {{issues}}
+
+        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 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. **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
+      into: brief
+  - tool: file.write
+    path: ~/.patchwork/inbox/morning-brief-{{date}}.md
+    content: |
+      # Morning brief — {{date}}
+
+      {{brief}}

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}}

package/templates/scheduled-tasks/morning-brief/SKILL.md

@@ -0,0 +1,37 @@
+## Installation
+
+Copy this template to your Claude Desktop scheduled-tasks directory:
+
+```bash
+mkdir -p ~/.claude/scheduled-tasks/morning-brief
+cp /path/to/patchwork-os/templates/scheduled-tasks/morning-brief/SKILL.md \
+   ~/.claude/scheduled-tasks/morning-brief/SKILL.md
+```
+
+Then restart Claude Desktop. Configure the schedule (recommended: weekdays 8am) in Claude Desktop settings under "Scheduled Tasks".
+
+> Patchwork OS must be installed: `npm install -g patchwork-os`
+> Gmail must be connected via the dashboard Connections page before this fires.
+
+---
+---
+name: morning-brief
+description: Run the Patchwork OS morning-brief recipe — fetches unread Gmail, recent git commits, and writes a brief to the Inbox.
+schedule: "0 8 * * 1-5"
+---
+
+# Morning Brief
+
+Run the morning-brief recipe and deliver results to the Patchwork OS Inbox.
+
+## Steps
+
+1. Run `Bash` with command: `patchwork-os recipe run morning-brief`
+2. Confirm the output file was written to `~/.patchwork/inbox/`
+3. Report the file path and a one-line summary of what was written
+
+## Guidelines
+
+- If Gmail returns 0 emails, still write the brief with the git activity section
+- If the recipe fails, report the error clearly — do not retry automatically
+- Keep the confirmation message under 3 lines