@aion0/forge 0.4.3 → 0.4.5

package/hooks/useSidebarResize.ts

@@ -0,0 +1,52 @@
+import { useState, useRef, useCallback } from 'react';
+
+interface UseSidebarResizeOptions {
+  defaultWidth?: number;
+  minWidth?: number;
+  maxWidth?: number;
+}
+
+/**
+ * Provides drag-to-resize behaviour for a vertical split panel sidebar.
+ *
+ * Usage:
+ *   const { sidebarWidth, onSidebarDragStart } = useSidebarResize({ defaultWidth: 224 });
+ *
+ *   <aside style={{ width: sidebarWidth }} className="flex flex-col shrink-0 overflow-hidden">…</aside>
+ *   <div onMouseDown={onSidebarDragStart} className="w-1 cursor-col-resize shrink-0 bg-[var(--border)] hover:bg-[var(--accent)]/50" />
+ *   <main className="flex-1 min-w-0">…</main>
+ */
+export function useSidebarResize({
+  defaultWidth = 224,
+  minWidth = 120,
+  maxWidth = 480,
+}: UseSidebarResizeOptions = {}) {
+  const [sidebarWidth, setSidebarWidth] = useState(defaultWidth);
+  // Track the in-progress drag without causing re-renders in the move handler
+  const dragRef = useRef<{ startX: number; startW: number } | null>(null);
+  // Keep a mutable copy so the stable onSidebarDragStart callback always reads the latest width
+  const widthRef = useRef(defaultWidth);
+
+  const onSidebarDragStart = useCallback((e: React.MouseEvent) => {
+    e.preventDefault();
+    dragRef.current = { startX: e.clientX, startW: widthRef.current };
+
+    const onMove = (ev: MouseEvent) => {
+      if (!dragRef.current) return;
+      const next = Math.max(minWidth, Math.min(maxWidth, dragRef.current.startW + ev.clientX - dragRef.current.startX));
+      widthRef.current = next;
+      setSidebarWidth(next);
+    };
+
+    const onUp = () => {
+      dragRef.current = null;
+      window.removeEventListener('mousemove', onMove);
+      window.removeEventListener('mouseup', onUp);
+    };
+
+    window.addEventListener('mousemove', onMove);
+    window.addEventListener('mouseup', onUp);
+  }, [minWidth, maxWidth]);
+
+  return { sidebarWidth, onSidebarDragStart };
+}

package/lib/help-docs/05-pipelines.md

@@ -50,15 +50,12 @@ nodes:
 
 ## Built-in Workflows
 
-### issue-auto-fix
-Fetches a GitHub issue → fixes code on new branch → creates PR.
+### issue-fix-and-review
+Complete issue resolution pipeline: fetch issue → fix code → create PR → review code → notify.
 
-Input: `issue_id`, `project`, `base_branch` (optional)
+Steps: setup → fetch-issue → fix-code → push-and-pr → review → cleanup
 
-### pr-review
-Fetches PR diff → AI code review → posts result.
-
-Input: `pr_number`, `project`
+Input: `issue_id`, `project`, `base_branch` (optional), `extra_context` (optional)
 
 ## CLI
 
@@ -67,6 +64,24 @@ forge flows              # list available workflows
 forge run my-workflow    # execute a workflow
 ```
 
+## Import a Workflow
+
+1. In Pipelines tab, click **Import**
+2. Paste YAML workflow content
+3. Click **Save Workflow**
+
+Or save YAML directly to `~/.forge/data/flows/<name>.yaml`.
+
+To create a workflow via Help AI: ask "Create a pipeline that does X" — the AI will generate the YAML for you to import.
+
+## Creating Workflows via API
+
+```bash
+curl -X POST http://localhost:3000/api/pipelines \
+  -H 'Content-Type: application/json' \
+  -d '{"action": "save-workflow", "yaml": "name: my-flow\nnodes:\n  step1:\n    project: my-project\n    prompt: do something"}'
+```
+
 ## Storage
 
 - Workflow YAML: `~/.forge/data/flows/`

package/lib/help-docs/09-issue-autofix.md

@@ -28,7 +28,7 @@ Scan → Fetch Issue → Fix Code (new branch) → Push → Create PR → Auto R
 1. **Scan**: `gh issue list` finds open issues matching labels
 2. **Fix**: Claude Code analyzes issue and fixes code on `fix/<id>-<description>` branch
 3. **PR**: Pushes branch and creates Pull Request
-4. **Review**: Automatically triggers `pr-review` pipeline
+4. **Review**: AI reviews the code changes in the same pipeline
 5. **Notify**: Results sent via Telegram (if configured)
 
 ## Manual Trigger

package/lib/init.ts

@@ -95,7 +95,13 @@ export function ensureInitialized() {
   // Session watcher is safe (file-based, idempotent)
   startWatcherLoop();
 
-  // Issue scanner — auto-scan GitHub issues for configured projects
+  // Pipeline scheduler — periodic execution for project-bound workflows
+  try {
+    const { startScheduler } = require('./pipeline-scheduler');
+    startScheduler();
+  } catch {}
+
+  // Legacy issue scanner (still used if issue_autofix_config has entries)
   try {
     const { startScanner } = require('./issue-scanner');
     startScanner();

package/lib/issue-scanner.ts

@@ -1,6 +1,6 @@
 /**
  * Issue Scanner — periodically scans GitHub issues for configured projects
- * and triggers issue-auto-fix pipeline for new issues.
+ * and triggers issue-fix-and-review pipeline for new issues.
  *
  * Per-project config stored in DB:
  *   - enabled: boolean
@@ -196,7 +196,7 @@ export function scanAndTrigger(config: IssueAutofixConfig): { triggered: number;
     if (isProcessed(config.projectPath, issue.number)) continue;
 
     try {
-      const pipeline = startPipeline('issue-auto-fix', {
+      const pipeline = startPipeline('issue-fix-and-review', {
         issue_id: String(issue.number),
         project: config.projectName,
         base_branch: config.baseBranch || 'auto-detect',

package/lib/pipeline-scheduler.ts

@@ -0,0 +1,239 @@
+/**
+ * Pipeline Scheduler — manages project-pipeline bindings and scheduled execution.
+ * Replaces issue-scanner with a generic approach.
+ *
+ * Each project can bind multiple workflows. Each binding has:
+ * - config: JSON with workflow-specific settings (e.g. interval, labels for issue pipelines)
+ * - enabled: on/off toggle
+ * - scheduled execution via config.interval (minutes, 0 = manual only)
+ */
+
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import { startPipeline, getPipeline } from './pipeline';
+import { randomUUID } from 'node:crypto';
+
+function db() { return getDb(getDbPath()); }
+
+export interface ProjectPipelineBinding {
+  id: number;
+  projectPath: string;
+  projectName: string;
+  workflowName: string;
+  enabled: boolean;
+  config: Record<string, any>; // interval (minutes), labels, baseBranch, etc.
+  lastRunAt: string | null;
+  createdAt: string;
+}
+
+export interface PipelineRun {
+  id: string;
+  projectPath: string;
+  workflowName: string;
+  pipelineId: string;
+  status: string;
+  summary: string;
+  createdAt: string;
+}
+
+// ─── Bindings CRUD ───────────────────────────────────────
+
+export function getBindings(projectPath: string): ProjectPipelineBinding[] {
+  return (db().prepare('SELECT * FROM project_pipelines WHERE project_path = ? ORDER BY created_at ASC')
+    .all(projectPath) as any[]).map(r => ({
+      id: r.id,
+      projectPath: r.project_path,
+      projectName: r.project_name,
+      workflowName: r.workflow_name,
+      enabled: !!r.enabled,
+      config: JSON.parse(r.config || '{}'),
+      lastRunAt: r.last_run_at || null,
+      createdAt: r.created_at,
+    }));
+}
+
+export function getAllScheduledBindings(): ProjectPipelineBinding[] {
+  return (db().prepare('SELECT * FROM project_pipelines WHERE enabled = 1')
+    .all() as any[]).map(r => ({
+      id: r.id,
+      projectPath: r.project_path,
+      projectName: r.project_name,
+      workflowName: r.workflow_name,
+      enabled: true,
+      config: JSON.parse(r.config || '{}'),
+      lastRunAt: r.last_run_at || null,
+      createdAt: r.created_at,
+    })).filter(b => b.config.interval && b.config.interval > 0);
+}
+
+export function addBinding(projectPath: string, projectName: string, workflowName: string, config?: Record<string, any>): void {
+  db().prepare(`
+    INSERT OR REPLACE INTO project_pipelines (project_path, project_name, workflow_name, config)
+    VALUES (?, ?, ?, ?)
+  `).run(projectPath, projectName, workflowName, JSON.stringify(config || {}));
+}
+
+export function removeBinding(projectPath: string, workflowName: string): void {
+  db().prepare('DELETE FROM project_pipelines WHERE project_path = ? AND workflow_name = ?')
+    .run(projectPath, workflowName);
+}
+
+export function updateBinding(projectPath: string, workflowName: string, updates: { enabled?: boolean; config?: Record<string, any> }): void {
+  if (updates.enabled !== undefined) {
+    db().prepare('UPDATE project_pipelines SET enabled = ? WHERE project_path = ? AND workflow_name = ?')
+      .run(updates.enabled ? 1 : 0, projectPath, workflowName);
+  }
+  if (updates.config) {
+    db().prepare('UPDATE project_pipelines SET config = ? WHERE project_path = ? AND workflow_name = ?')
+      .run(JSON.stringify(updates.config), projectPath, workflowName);
+  }
+}
+
+function updateLastRunAt(projectPath: string, workflowName: string): void {
+  db().prepare('UPDATE project_pipelines SET last_run_at = ? WHERE project_path = ? AND workflow_name = ?')
+    .run(new Date().toISOString(), projectPath, workflowName);
+}
+
+// ─── Runs ────────────────────────────────────────────────
+
+export function recordRun(projectPath: string, workflowName: string, pipelineId: string): string {
+  const id = randomUUID().slice(0, 8);
+  db().prepare(`
+    INSERT INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status)
+    VALUES (?, ?, ?, ?, 'running')
+  `).run(id, projectPath, workflowName, pipelineId);
+  return id;
+}
+
+export function updateRun(pipelineId: string, status: string, summary?: string): void {
+  if (summary) {
+    db().prepare('UPDATE pipeline_runs SET status = ?, summary = ? WHERE pipeline_id = ?')
+      .run(status, summary, pipelineId);
+  } else {
+    db().prepare('UPDATE pipeline_runs SET status = ? WHERE pipeline_id = ?')
+      .run(status, pipelineId);
+  }
+}
+
+export function getRuns(projectPath: string, workflowName?: string, limit = 20): PipelineRun[] {
+  const query = workflowName
+    ? 'SELECT * FROM pipeline_runs WHERE project_path = ? AND workflow_name = ? ORDER BY created_at DESC LIMIT ?'
+    : 'SELECT * FROM pipeline_runs WHERE project_path = ? ORDER BY created_at DESC LIMIT ?';
+  const params = workflowName ? [projectPath, workflowName, limit] : [projectPath, limit];
+  return (db().prepare(query).all(...params) as any[]).map(r => ({
+    id: r.id,
+    projectPath: r.project_path,
+    workflowName: r.workflow_name,
+    pipelineId: r.pipeline_id,
+    status: r.status,
+    summary: r.summary || '',
+    createdAt: r.created_at,
+  }));
+}
+
+export function deleteRun(id: string): void {
+  db().prepare('DELETE FROM pipeline_runs WHERE id = ?').run(id);
+}
+
+// ─── Trigger ─────────────────────────────────────────────
+
+export function triggerPipeline(projectPath: string, projectName: string, workflowName: string, extraInput?: Record<string, any>): { pipelineId: string; runId: string } {
+  const input: Record<string, string> = {
+    project: projectName,
+    ...extraInput,
+  };
+
+  const pipeline = startPipeline(workflowName, input);
+  const runId = recordRun(projectPath, workflowName, pipeline.id);
+  updateLastRunAt(projectPath, workflowName);
+  console.log(`[pipeline-scheduler] Triggered ${workflowName} for ${projectName} (pipeline: ${pipeline.id})`);
+  return { pipelineId: pipeline.id, runId };
+}
+
+// ─── Status sync (called from pipeline completion) ───────
+
+export function syncRunStatus(pipelineId: string): void {
+  const pipeline = getPipeline(pipelineId);
+  if (!pipeline) return;
+
+  // Build summary from outputs
+  let summary = '';
+  for (const [nodeId, node] of Object.entries(pipeline.nodes)) {
+    if (node.outputs && Object.keys(node.outputs).length > 0) {
+      for (const [key, val] of Object.entries(node.outputs)) {
+        if (val && typeof val === 'string' && val.length < 500) {
+          summary += `${nodeId}.${key}: ${val.slice(0, 200)}\n`;
+        }
+      }
+    }
+  }
+
+  updateRun(pipelineId, pipeline.status, summary.trim());
+}
+
+// ─── Periodic Scheduler ─────────────────────────────────
+
+const schedulerKey = Symbol.for('forge-pipeline-scheduler');
+const gAny = globalThis as any;
+if (!gAny[schedulerKey]) gAny[schedulerKey] = { started: false, timer: null as NodeJS.Timeout | null };
+const schedulerState = gAny[schedulerKey] as { started: boolean; timer: NodeJS.Timeout | null };
+
+const CHECK_INTERVAL_MS = 60 * 1000; // check every 60s
+
+export function startScheduler(): void {
+  if (schedulerState.started) return;
+  schedulerState.started = true;
+
+  // Check on startup after a short delay
+  setTimeout(() => tickScheduler(), 5000);
+
+  // Then check periodically
+  schedulerState.timer = setInterval(() => tickScheduler(), CHECK_INTERVAL_MS);
+  console.log('[pipeline-scheduler] Scheduler started (checking every 60s)');
+}
+
+export function stopScheduler(): void {
+  if (schedulerState.timer) {
+    clearInterval(schedulerState.timer);
+    schedulerState.timer = null;
+  }
+  schedulerState.started = false;
+}
+
+function tickScheduler(): void {
+  try {
+    const bindings = getAllScheduledBindings();
+    const now = Date.now();
+
+    for (const binding of bindings) {
+      const intervalMs = binding.config.interval * 60 * 1000;
+      const lastRun = binding.lastRunAt ? new Date(binding.lastRunAt).getTime() : 0;
+      const elapsed = now - lastRun;
+
+      if (elapsed >= intervalMs) {
+        // Check if there's already a running pipeline for this binding
+        const recentRuns = getRuns(binding.projectPath, binding.workflowName, 1);
+        if (recentRuns.length > 0 && recentRuns[0].status === 'running') {
+          continue; // skip if still running
+        }
+
+        try {
+          console.log(`[pipeline-scheduler] Scheduled trigger: ${binding.workflowName} for ${binding.projectName}`);
+          triggerPipeline(binding.projectPath, binding.projectName, binding.workflowName, binding.config.input);
+        } catch (e: any) {
+          console.error(`[pipeline-scheduler] Scheduled trigger failed for ${binding.workflowName}:`, e.message);
+        }
+      }
+    }
+  } catch (e: any) {
+    console.error('[pipeline-scheduler] Tick error:', e.message);
+  }
+}
+
+/** Get next scheduled run time for a binding */
+export function getNextRunTime(binding: ProjectPipelineBinding): string | null {
+  if (!binding.enabled || !binding.config.interval || binding.config.interval <= 0) return null;
+  const intervalMs = binding.config.interval * 60 * 1000;
+  const lastRun = binding.lastRunAt ? new Date(binding.lastRunAt).getTime() : new Date(binding.createdAt).getTime();
+  return new Date(lastRun + intervalMs).toISOString();
+}

package/lib/pipeline.ts

@@ -75,9 +75,9 @@ export interface Pipeline {
 // ─── Built-in workflows ──────────────────────────────────
 
 export const BUILTIN_WORKFLOWS: Record<string, string> = {
-  'issue-auto-fix': `
-name: issue-auto-fix
-description: "Fetch a GitHub issue → fix code on a new branch → create PR"
+  'issue-fix-and-review': `
+name: issue-fix-and-review
+description: "Fetch GitHub issue → fix code → create PR → review PR → notify"
 input:
   issue_id: "GitHub issue number"
   project: "Project name"
@@ -107,8 +107,10 @@ nodes:
     project: "{{input.project}}"
     depends_on: [setup]
     prompt: |
+      ISSUE_ID="{{input.issue_id}}" && \
+      if [ -z "$ISSUE_ID" ]; then echo "__SKIP__ No issue_id provided" && exit 0; fi && \
       REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
-      gh issue view {{input.issue_id}} --json title,body,labels,number -R "$REPO"
+      gh issue view "$ISSUE_ID" --json title,body,labels,number -R "$REPO"
     outputs:
       - name: issue_json
         extract: stdout
@@ -148,72 +150,43 @@ nodes:
     outputs:
       - name: pr_url
         extract: stdout
-  notify:
-    mode: shell
-    project: "{{input.project}}"
-    depends_on: [push-and-pr]
-    prompt: |
-      ORIG=$(echo '{{nodes.setup.outputs.info}}' | grep ORIG_BRANCH= | cut -d= -f2) && \
-      if [ -n "$(git status --porcelain)" ]; then
-        echo "PR created for issue #{{input.issue_id}}: {{nodes.push-and-pr.outputs.pr_url}} (staying on $(git branch --show-current) - uncommitted changes)"
-      else
-        git checkout "$ORIG" 2>/dev/null || true
-        echo "PR created for issue #{{input.issue_id}}: {{nodes.push-and-pr.outputs.pr_url}} (switched back to $ORIG)"
-      fi
-`,
-  'pr-review': `
-name: pr-review
-description: "Review a PR → approve or request changes → notify"
-input:
-  pr_number: "Pull request number"
-  project: "Project name"
-nodes:
-  setup:
-    mode: shell
-    project: "{{input.project}}"
-    prompt: |
-      REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || git remote get-url origin | sed 's/.*github.com[:/]//;s/.git$//') && \
-      echo "REPO=$REPO"
-    outputs:
-      - name: info
-        extract: stdout
-  fetch-pr:
-    mode: shell
-    project: "{{input.project}}"
-    depends_on: [setup]
-    prompt: |
-      REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
-      gh pr diff {{input.pr_number}} -R "$REPO"
-    outputs:
-      - name: diff
-        extract: stdout
   review:
     project: "{{input.project}}"
-    depends_on: [fetch-pr]
+    depends_on: [push-and-pr]
     prompt: |
-      Review the following pull request diff carefully. Check for:
+      Review the code changes for issue #{{input.issue_id}}.
+
+      Fix summary: {{nodes.fix-code.outputs.summary}}
+
+      Git diff:
+      {{nodes.fix-code.outputs.diff}}
+
+      Check for:
       - Bugs and logic errors
       - Security vulnerabilities
       - Performance issues
-      - Code style and best practices
-
-      PR #{{input.pr_number}} diff:
-      {{nodes.fetch-pr.outputs.diff}}
+      - Whether the fix actually addresses the issue
 
       Respond with:
       1. APPROVED or CHANGES_REQUESTED
-      2. Detailed list of specific issues found with file paths and line numbers
-      3. Suggestions for improvement
+      2. Specific issues found with file paths and line numbers
     outputs:
       - name: review_result
         extract: result
-  post-review:
+  cleanup:
     mode: shell
     project: "{{input.project}}"
     depends_on: [review]
-    prompt: "echo 'Review complete for PR #{{input.pr_number}}'"
+    prompt: |
+      ORIG=$(echo '{{nodes.setup.outputs.info}}' | grep ORIG_BRANCH= | cut -d= -f2) && \
+      if [ -n "$(git status --porcelain)" ]; then
+        echo "Issue #{{input.issue_id}} — PR: {{nodes.push-and-pr.outputs.pr_url}} | Review: {{nodes.review.outputs.review_result}} (staying on $(git branch --show-current))"
+      else
+        git checkout "$ORIG" 2>/dev/null || true
+        echo "Issue #{{input.issue_id}} — PR: {{nodes.push-and-pr.outputs.pr_url}} | Review: {{nodes.review.outputs.review_result}} (switched back to $ORIG)"
+      fi
     outputs:
-      - name: status
+      - name: result
         extract: stdout
 `,
 };
@@ -607,39 +580,11 @@ function checkPipelineCompletion(pipeline: Pipeline) {
     savePipeline(pipeline);
     notifyPipelineComplete(pipeline);
 
-    // Update issue_autofix_processed status
-    if (pipeline.workflowName === 'issue-auto-fix') {
-      try {
-        const { updateProcessedStatus } = require('./issue-scanner');
-        const issueId = parseInt(pipeline.input.issue_id);
-        const projectInfo = getProjectInfo(pipeline.input.project);
-        if (projectInfo && issueId) {
-          const prOutput = pipeline.nodes['push-and-pr']?.outputs?.pr_url || '';
-          const prMatch = prOutput.match(/\/pull\/(\d+)/);
-          const prNumber = prMatch ? parseInt(prMatch[1]) : undefined;
-          updateProcessedStatus(projectInfo.path, issueId, pipeline.status, prNumber);
-        }
-      } catch {}
-    }
-
-    // Auto-chain: issue-auto-fix → pr-review
-    if (pipeline.workflowName === 'issue-auto-fix' && pipeline.status === 'done') {
-      try {
-        // Extract PR number from push-and-pr output
-        const prOutput = pipeline.nodes['push-and-pr']?.outputs?.pr_url || '';
-        const prMatch = prOutput.match(/\/pull\/(\d+)/);
-        if (prMatch) {
-          const prNumber = prMatch[1];
-          console.log(`[pipeline] Auto-triggering pr-review for PR #${prNumber}`);
-          startPipeline('pr-review', {
-            pr_number: prNumber,
-            project: pipeline.input.project || '',
-          });
-        }
-      } catch (e) {
-        console.error('[pipeline] Failed to auto-trigger pr-review:', e);
-      }
-    }
+    // Sync run status to project pipeline runs
+    try {
+      const { syncRunStatus } = require('./pipeline-scheduler');
+      syncRunStatus(pipeline.id);
+    } catch {}
 
     // Release project lock
     const workflow = getWorkflow(pipeline.workflowName);
@@ -695,6 +640,17 @@ function setupTaskListener(pipelineId: string) {
         }
       }
 
+      // Convention: if stdout contains __SKIP__, mark node as skipped (downstream nodes will also skip)
+      const outputStr = task.resultSummary || '';
+      if (outputStr.includes('__SKIP__')) {
+        nodeState.status = 'skipped';
+        nodeState.completedAt = new Date().toISOString();
+        savePipeline(pipeline);
+        scheduleReadyNodes(pipeline, workflow);
+        checkPipelineCompletion(pipeline);
+        return;
+      }
+
       // Check routes for conditional next step
       if (nodeDef.routes.length > 0) {
         const nextNode = evaluateRoutes(nodeDef.routes, nodeState.outputs, pipeline);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/src/core/db/database.ts

@@ -34,6 +34,7 @@ function initSchema(db: Database.Database) {
   migrate("ALTER TABLE skills ADD COLUMN installed_version TEXT NOT NULL DEFAULT ''");
   migrate('ALTER TABLE skills ADD COLUMN rating REAL DEFAULT 0');
   migrate('ALTER TABLE skills ADD COLUMN deleted_remotely INTEGER NOT NULL DEFAULT 0');
+  migrate('ALTER TABLE project_pipelines ADD COLUMN last_run_at TEXT');
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS sessions (
@@ -155,6 +156,29 @@ function initSchema(db: Database.Database) {
       data TEXT NOT NULL DEFAULT '{}'
     );
 
+    -- Project pipeline bindings (which workflows are attached to which projects)
+    CREATE TABLE IF NOT EXISTS project_pipelines (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_path TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      workflow_name TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      config TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(project_path, workflow_name)
+    );
+
+    -- Pipeline execution log (per project, replaces issue_autofix_processed)
+    CREATE TABLE IF NOT EXISTS pipeline_runs (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      workflow_name TEXT NOT NULL,
+      pipeline_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      summary TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
     -- Project favorites
     CREATE TABLE IF NOT EXISTS project_favorites (
       project_path TEXT PRIMARY KEY,