@aion0/forge 0.4.5 → 0.4.7

package/RELEASE_NOTES.md

@@ -1,11 +1,16 @@
-# Forge v0.4.5
+# Forge v0.4.7
 
-Released: 2026-03-21
+Released: 2026-03-22
 
-## Changes since v0.4.4
+## Changes since v0.4.6
 
 ### Bug Fixes
-- fix: add drag-to-resize for left sidebars across all split-panel pages (#14)
+- fix: serial issue scanning, shell ANSI-C escaping, pipeline navigation
+- fix: prevent concurrent startTunnel calls from killing each other (#16)
 
+### Other
+- improve pipeline
+- fix(#17): normalize SQLite datetime strings to ISO 8601 UTC
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.4...v0.4.5
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.6...v0.4.7

package/app/api/project-pipelines/route.ts

@@ -8,6 +8,8 @@ import {
   deleteRun,
   triggerPipeline,
   getNextRunTime,
+  scanAndTriggerIssues,
+  resetDedup,
 } from '@/lib/pipeline-scheduler';
 import { listWorkflows } from '@/lib/pipeline';
 
@@ -64,5 +66,26 @@ export async function POST(req: Request) {
     return NextResponse.json({ ok: true });
   }
 
+  if (body.action === 'scan-now') {
+    const { projectPath, projectName, workflowName } = body;
+    if (!projectPath || !workflowName) return NextResponse.json({ error: 'projectPath and workflowName required' }, { status: 400 });
+    const bindings = getBindings(projectPath);
+    const binding = bindings.find(b => b.workflowName === workflowName);
+    if (!binding) return NextResponse.json({ error: 'Binding not found' }, { status: 404 });
+    try {
+      const result = scanAndTriggerIssues(binding);
+      return NextResponse.json({ ok: true, ...result });
+    } catch (e: any) {
+      return NextResponse.json({ ok: false, error: e.message }, { status: 500 });
+    }
+  }
+
+  if (body.action === 'reset-dedup') {
+    const { projectPath, workflowName, dedupKey } = body;
+    if (!projectPath || !workflowName || !dedupKey) return NextResponse.json({ error: 'projectPath, workflowName, dedupKey required' }, { status: 400 });
+    resetDedup(projectPath, workflowName, dedupKey);
+    return NextResponse.json({ ok: true });
+  }
+
   return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
 }

package/components/Dashboard.tsx

@@ -101,6 +101,18 @@ export default function Dashboard({ user }: { user: any }) {
     return () => window.removeEventListener('forge:open-terminal', handler);
   }, []);
 
+  // Listen for navigation events (e.g. from ProjectDetail → Pipelines)
+  const [pendingPipelineId, setPendingPipelineId] = useState<string | null>(null);
+  useEffect(() => {
+    const handler = (e: Event) => {
+      const { view, pipelineId } = (e as CustomEvent).detail;
+      if (view) setViewMode(view);
+      if (pipelineId) setPendingPipelineId(pipelineId);
+    };
+    window.addEventListener('forge:navigate', handler);
+    return () => window.removeEventListener('forge:navigate', handler);
+  }, []);
+
   // Version check (on mount + every 10 min)
   useEffect(() => {
     const check = () => fetch('/api/version').then(r => r.json()).then(setVersionInfo).catch(() => {});
@@ -561,7 +573,11 @@ export default function Dashboard({ user }: { user: any }) {
         {/* Pipelines */}
         {viewMode === 'pipelines' && (
           <Suspense fallback={<div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">Loading...</div>}>
-            <PipelineView onViewTask={(taskId) => { setViewMode('tasks'); setActiveTaskId(taskId); }} />
+            <PipelineView
+              onViewTask={(taskId) => { setViewMode('tasks'); setActiveTaskId(taskId); }}
+              focusPipelineId={pendingPipelineId}
+              onFocusHandled={() => setPendingPipelineId(null)}
+            />
           </Suspense>
         )}
 

package/components/PipelineView.tsx

@@ -64,7 +64,7 @@ const STATUS_COLOR: Record<string, string> = {
   skipped: 'text-gray-500',
 };
 
-export default function PipelineView({ onViewTask }: { onViewTask?: (taskId: string) => void }) {
+export default function PipelineView({ onViewTask, focusPipelineId, onFocusHandled }: { onViewTask?: (taskId: string) => void; focusPipelineId?: string | null; onFocusHandled?: () => void }) {
   const { sidebarWidth, onSidebarDragStart } = useSidebarResize({ defaultWidth: 256, minWidth: 140, maxWidth: 480 });
   const [pipelines, setPipelines] = useState<Pipeline[]>([]);
   const [workflows, setWorkflows] = useState<Workflow[]>([]);
@@ -100,6 +100,17 @@ export default function PipelineView({ onViewTask }: { onViewTask?: (taskId: str
     return () => clearInterval(timer);
   }, [fetchData]);
 
+  // Focus on a specific pipeline (from external navigation)
+  useEffect(() => {
+    if (!focusPipelineId || pipelines.length === 0) return;
+    const target = pipelines.find(p => p.id === focusPipelineId);
+    if (target) {
+      setSelectedPipeline(target);
+      setShowEditor(false);
+      onFocusHandled?.();
+    }
+  }, [focusPipelineId, pipelines, onFocusHandled]);
+
   // Refresh selected pipeline
   useEffect(() => {
     if (!selectedPipeline || selectedPipeline.status !== 'running') return;

package/components/ProjectDetail.tsx

@@ -69,10 +69,12 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
   const [projectTab, setProjectTab] = useState<'code' | 'skills' | 'claudemd' | 'pipelines'>('code');
   // Pipeline bindings state
   const [pipelineBindings, setPipelineBindings] = useState<{ id: number; workflowName: string; enabled: boolean; config: any; lastRunAt: string | null; nextRunAt: string | null }[]>([]);
-  const [pipelineRuns, setPipelineRuns] = useState<{ id: string; workflowName: string; pipelineId: string; status: string; summary: string; createdAt: string }[]>([]);
+  const [pipelineRuns, setPipelineRuns] = useState<{ id: string; workflowName: string; pipelineId: string; status: string; summary: string; dedupKey: string | null; createdAt: string }[]>([]);
   const [availableWorkflows, setAvailableWorkflows] = useState<{ name: string; description?: string; builtin?: boolean }[]>([]);
   const [showAddPipeline, setShowAddPipeline] = useState(false);
   const [triggerInput, setTriggerInput] = useState<Record<string, string>>({});
+  const [runMenu, setRunMenu] = useState<string | null>(null); // workflowName of open run menu
+  const [issueInput, setIssueInput] = useState('');
   const [claudeMdContent, setClaudeMdContent] = useState('');
   const [claudeMdExists, setClaudeMdExists] = useState(false);
   const [claudeTemplates, setClaudeTemplates] = useState<{ id: string; name: string; description: string; tags: string[]; builtin: boolean; content: string }[]>([]);
@@ -846,10 +848,74 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
                       }} className="accent-[var(--accent)]" />
                       Enabled
                     </label>
-                    <button
-                      onClick={() => triggerProjectPipeline(b.workflowName, triggerInput)}
-                      className="text-[9px] px-2 py-0.5 border border-[var(--accent)] text-[var(--accent)] rounded hover:bg-[var(--accent)] hover:text-white"
-                    >Run</button>
+                    <div className="relative">
+                      <button
+                        onClick={() => {
+                          const isIssueWf = b.workflowName === 'issue-auto-fix' || b.workflowName === 'issue-fix-and-review';
+                          if (!isIssueWf) {
+                            triggerProjectPipeline(b.workflowName, triggerInput);
+                          } else {
+                            setRunMenu(runMenu === b.workflowName ? null : b.workflowName);
+                            setIssueInput('');
+                          }
+                        }}
+                        className="text-[9px] px-2 py-0.5 border border-[var(--accent)] text-[var(--accent)] rounded hover:bg-[var(--accent)] hover:text-white"
+                      >Run</button>
+                      {runMenu === b.workflowName && (
+                        <div className="absolute top-full right-0 mt-1 z-20 bg-[var(--bg-secondary)] border border-[var(--border)] rounded shadow-lg p-2 space-y-2 w-[200px]">
+                          <button
+                            onClick={async () => {
+                              setRunMenu(null);
+                              try {
+                                const res = await fetch('/api/project-pipelines', {
+                                  method: 'POST',
+                                  headers: { 'Content-Type': 'application/json' },
+                                  body: JSON.stringify({ action: 'scan-now', projectPath, projectName, workflowName: b.workflowName }),
+                                });
+                                const data = await res.json();
+                                if (data.error) alert(`Scan error: ${data.error}`);
+                                else alert(`Scanned ${data.total} issues, triggered ${data.triggered} fix${data.pending > 0 ? ` (${data.pending} more pending)` : ''}`);
+                                fetchPipelineBindings();
+                              } catch { alert('Scan failed'); }
+                            }}
+                            className="w-full text-[9px] px-2 py-1.5 rounded border border-green-500/50 text-green-400 hover:bg-green-500/10 font-medium"
+                          >Auto Scan — fix all new issues</button>
+                          <div className="border-t border-[var(--border)]/50 my-1" />
+                          <div className="flex items-center gap-1">
+                            <input
+                              type="text"
+                              value={issueInput}
+                              onChange={e => setIssueInput(e.target.value)}
+                              placeholder="Issue #"
+                              className="flex-1 bg-[var(--bg-tertiary)] border border-[var(--border)] rounded px-2 py-1 text-[9px] text-[var(--text-primary)]"
+                              onKeyDown={e => {
+                                if (e.key === 'Enter' && issueInput.trim()) {
+                                  setRunMenu(null);
+                                  triggerProjectPipeline(b.workflowName, {
+                                    ...triggerInput,
+                                    issue_id: issueInput.trim(),
+                                    base_branch: b.config.baseBranch || 'auto-detect',
+                                  });
+                                }
+                              }}
+                              autoFocus
+                            />
+                            <button
+                              onClick={() => {
+                                if (!issueInput.trim()) return;
+                                setRunMenu(null);
+                                triggerProjectPipeline(b.workflowName, {
+                                  ...triggerInput,
+                                  issue_id: issueInput.trim(),
+                                  base_branch: b.config.baseBranch || 'auto-detect',
+                                });
+                              }}
+                              className="text-[9px] px-2 py-1 bg-[var(--accent)] text-white rounded hover:opacity-80"
+                            >Fix</button>
+                          </div>
+                        </div>
+                      )}
+                    </div>
                     <button
                       onClick={async () => {
                         if (!confirm(`Remove "${b.workflowName}" from this project?`)) return;
@@ -900,6 +966,51 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
                       </span>
                     )}
                   </div>
+                  {/* Issue scan config (for issue-fix-and-review workflow) */}
+                  {(b.workflowName === 'issue-auto-fix' || b.workflowName === 'issue-fix-and-review') && (
+                    <div className="space-y-1.5 pt-1 border-t border-[var(--border)]/30">
+                      {b.config.interval > 0 && (
+                        <div className="text-[8px] text-[var(--text-secondary)]">
+                          Scheduled mode: auto-scans GitHub issues and fixes new ones
+                        </div>
+                      )}
+                      <div className="flex items-center gap-2 text-[9px]">
+                          <label className="text-[var(--text-secondary)]">Labels:</label>
+                          <input
+                            type="text"
+                            defaultValue={(b.config.labels || []).join(', ')}
+                            placeholder="bug, autofix (empty = all)"
+                            onBlur={async (e) => {
+                              const labels = e.target.value.split(',').map((s: string) => s.trim()).filter(Boolean);
+                              const newConfig = { ...b.config, labels };
+                              await fetch('/api/project-pipelines', {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ action: 'update', projectPath, workflowName: b.workflowName, config: newConfig }),
+                              });
+                              fetchPipelineBindings();
+                            }}
+                            className="flex-1 bg-[var(--bg-secondary)] border border-[var(--border)] rounded px-1.5 py-0.5 text-[9px] text-[var(--text-primary)]"
+                          />
+                          <label className="text-[var(--text-secondary)]">Base:</label>
+                          <input
+                            type="text"
+                            defaultValue={b.config.baseBranch || ''}
+                            placeholder="auto-detect"
+                            onBlur={async (e) => {
+                              const newConfig = { ...b.config, baseBranch: e.target.value.trim() || undefined };
+                              await fetch('/api/project-pipelines', {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ action: 'update', projectPath, workflowName: b.workflowName, config: newConfig }),
+                              });
+                              fetchPipelineBindings();
+                            }}
+                            className="w-20 bg-[var(--bg-secondary)] border border-[var(--border)] rounded px-1.5 py-0.5 text-[9px] text-[var(--text-primary)]"
+                          />
+                        </div>
+                    </div>
+                  )}
                 </div>
               ))
             )}
@@ -913,30 +1024,58 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
                 {pipelineRuns.map(run => (
                   <div key={run.id} className="flex items-start gap-2 px-3 py-2 border-b border-[var(--border)]/30 last:border-b-0 text-[10px]">
                     <span className={`shrink-0 ${
-                      run.status === 'done' ? 'text-green-400' : run.status === 'failed' ? 'text-red-400' : 'text-yellow-400'
+                      run.status === 'done' ? 'text-green-400' : run.status === 'failed' ? 'text-red-400' : run.status === 'skipped' ? 'text-gray-400' : 'text-yellow-400'
                     }`}>●</span>
                     <div className="flex-1 min-w-0">
                       <div className="flex items-center gap-2">
                         <span className="text-[var(--text-primary)] font-medium">{run.workflowName}</span>
-                        <span className="text-[8px] text-[var(--text-secondary)] font-mono">{run.pipelineId.slice(0, 8)}</span>
+                        {run.dedupKey && (
+                          <span className="text-[8px] text-[var(--accent)] font-mono">{run.dedupKey.replace('issue:', '#')}</span>
+                        )}
+                        <button
+                          onClick={() => window.dispatchEvent(new CustomEvent('forge:navigate', { detail: { view: 'pipelines', pipelineId: run.pipelineId } }))}
+                          className="text-[8px] text-[var(--accent)] font-mono hover:underline"
+                          title="View in Pipelines"
+                        >{run.pipelineId.slice(0, 8)}</button>
                         <span className="text-[8px] text-[var(--text-secondary)] ml-auto">{new Date(run.createdAt).toLocaleString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })}</span>
                       </div>
                       {run.summary && (
                         <pre className="text-[9px] text-[var(--text-secondary)] mt-1 whitespace-pre-wrap break-words line-clamp-3">{run.summary}</pre>
                       )}
                     </div>
-                    <button
-                      onClick={async () => {
-                        if (!confirm('Delete this run?')) return;
-                        await fetch('/api/project-pipelines', {
-                          method: 'POST',
-                          headers: { 'Content-Type': 'application/json' },
-                          body: JSON.stringify({ action: 'delete-run', id: run.id }),
-                        });
-                        fetchPipelineBindings();
-                      }}
-                      className="text-[8px] text-[var(--text-secondary)] hover:text-[var(--red)] shrink-0"
-                    >×</button>
+                    <div className="flex items-center gap-1 shrink-0">
+                      {run.status === 'failed' && run.dedupKey && (
+                        <button
+                          onClick={async () => {
+                            await fetch('/api/project-pipelines', {
+                              method: 'POST',
+                              headers: { 'Content-Type': 'application/json' },
+                              body: JSON.stringify({ action: 'reset-dedup', projectPath, workflowName: run.workflowName, dedupKey: run.dedupKey }),
+                            });
+                            // Delete the failed run then re-scan
+                            await fetch('/api/project-pipelines', {
+                              method: 'POST',
+                              headers: { 'Content-Type': 'application/json' },
+                              body: JSON.stringify({ action: 'delete-run', id: run.id }),
+                            });
+                            fetchPipelineBindings();
+                          }}
+                          className="text-[8px] text-[var(--accent)] hover:underline"
+                        >Retry</button>
+                      )}
+                      <button
+                        onClick={async () => {
+                          if (!confirm('Delete this run?')) return;
+                          await fetch('/api/project-pipelines', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ action: 'delete-run', id: run.id }),
+                          });
+                          fetchPipelineBindings();
+                        }}
+                        className="text-[8px] text-[var(--text-secondary)] hover:text-[var(--red)]"
+                      >×</button>
+                    </div>
                   </div>
                 ))}
               </div>

package/lib/cloudflared.ts

@@ -171,8 +171,9 @@ function pushLog(line: string) {
 
 export async function startTunnel(localPort: number = parseInt(process.env.PORT || '3000')): Promise<{ url?: string; error?: string }> {
   console.log(`[tunnel] Starting tunnel on port ${localPort}...`);
-  // Check if this worker already has a process
-  if (state.process) {
+  // Prevent concurrent starts: state.process is already spawned, or another call is
+  // mid-flight between the guard and spawn (the async download window).
+  if (state.process || state.status === 'starting') {
     return state.url ? { url: state.url } : { error: 'Tunnel is starting...' };
   }
 
@@ -182,6 +183,13 @@ export async function startTunnel(localPort: number = parseInt(process.env.PORT
     try { process.kill(saved.pid, 0); return { url: saved.url }; } catch {}
   }
 
+  // Claim 'starting' before any async work so concurrent callers are blocked
+  // from this point onward (pgrep kill + download can take seconds).
+  state.status = 'starting';
+  state.url = null;
+  state.error = null;
+  state.log = [];
+
   // Kill ALL existing cloudflared processes to prevent duplicates
   try {
     const { execSync } = require('node:child_process');
@@ -191,11 +199,6 @@ export async function startTunnel(localPort: number = parseInt(process.env.PORT
     }
   } catch {}
 
-  state.status = 'starting';
-  state.url = null;
-  state.error = null;
-  state.log = [];
-
   // Generate new session code for remote login 2FA
   try {
     const { rotateSessionCode } = require('./password');

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

@@ -2,7 +2,7 @@
 
 ## What Are Pipelines?
 
-Pipelines chain multiple tasks into a DAG (directed acyclic graph). Each step can depend on previous steps, pass outputs forward, and run in parallel.
+Pipelines chain multiple tasks into a DAG (directed acyclic graph). Each step can depend on previous steps, pass outputs forward, and run in parallel. Pipelines are defined as YAML workflow files.
 
 ## YAML Workflow Format
 
@@ -10,9 +10,10 @@ Pipelines chain multiple tasks into a DAG (directed acyclic graph). Each step ca
 name: my-workflow
 description: "What this workflow does"
 input:
-  feature: "Feature description"
+  feature: "Feature description"      # required input fields
+  priority: "Priority level (optional)"
 vars:
-  project: my-app
+  project: my-app                     # default variables
 nodes:
   design:
     project: "{{vars.project}}"
@@ -23,7 +24,10 @@ nodes:
   implement:
     project: "{{vars.project}}"
     depends_on: [design]
-    prompt: "Implement: {{nodes.design.outputs.spec}}"
+    prompt: "Implement based on: {{nodes.design.outputs.spec}}"
+    outputs:
+      - name: diff
+        extract: git_diff
   review:
     project: "{{vars.project}}"
     depends_on: [implement]
@@ -32,30 +36,252 @@ nodes:
 
 ## Node Options
 
-| Field | Description |
-|-------|-------------|
-| `project` | Project name (supports `{{vars.xxx}}` templates) |
-| `prompt` | Claude Code prompt or shell command |
-| `mode` | `claude` (default) or `shell` |
-| `branch` | Auto-checkout branch before running |
-| `depends_on` | List of node IDs that must complete first |
-| `outputs` | Extract results: `result`, `git_diff`, or `stdout` |
-| `routes` | Conditional routing to next nodes |
+| Field | Description | Default |
+|-------|-------------|---------|
+| `project` | Project name (supports templates) | required |
+| `prompt` | Claude Code prompt or shell command | required |
+| `mode` | `claude` (AI agent) or `shell` (raw command) | `claude` |
+| `branch` | Auto-checkout branch before running (supports templates) | none |
+| `depends_on` | List of node IDs that must complete first | `[]` |
+| `outputs` | Extract results (see Output Extraction) | `[]` |
+| `routes` | Conditional routing to next nodes (see Routing) | `[]` |
+| `max_iterations` | Max loop iterations for routed nodes | `3` |
+
+## Node Modes
+
+### `claude` (default)
+Runs the prompt via Claude Code (`claude -p`). The AI agent reads the codebase, makes changes, and returns a result.
+
+### `shell`
+Runs the prompt as a raw shell command (`bash -c "..."`). Useful for git operations, CLI tools, API calls, etc.
+
+```yaml
+nodes:
+  setup:
+    mode: shell
+    project: my-app
+    prompt: |
+      git checkout main && git pull && echo "READY"
+    outputs:
+      - name: info
+        extract: stdout
+```
+
+**Shell escaping**: Template values in shell mode are automatically escaped (single quotes `'` → `'\''`) to prevent injection.
 
 ## Template Variables
 
-- `{{input.xxx}}` — pipeline input values
-- `{{vars.xxx}}` — workflow variables
-- `{{nodes.xxx.outputs.yyy}}` — outputs from previous nodes
+Templates use `{{...}}` syntax and are resolved before execution:
+
+- `{{input.xxx}}` — pipeline input values provided at trigger time
+- `{{vars.xxx}}` — workflow-level variables defined in YAML
+- `{{nodes.<node_id>.outputs.<output_name>}}` — outputs from completed nodes
+
+Node IDs can contain hyphens (e.g., `{{nodes.fetch-issue.outputs.data}}`).
+
+### Examples
+
+```yaml
+prompt: "Fix issue #{{input.issue_id}} in {{input.project}}"
+prompt: "Based on: {{nodes.design.outputs.spec}}"
+prompt: |
+  REPO={{nodes.setup.outputs.repo}} && \
+  gh pr create --title "Fix #{{input.issue_id}}" -R "$REPO"
+```
+
+## Output Extraction
+
+Each node can extract outputs for downstream nodes:
+
+| Extract Type | Description |
+|-------------|-------------|
+| `result` | Claude's final response text |
+| `stdout` | Shell command stdout (same as result for shell mode) |
+| `git_diff` | Git diff of changes made during the task |
+
+```yaml
+outputs:
+  - name: summary
+    extract: result
+  - name: changes
+    extract: git_diff
+```
+
+## Skip Convention (`__SKIP__`)
+
+If a shell node outputs `__SKIP__` in its stdout and exits with code 0, the node is marked as `skipped` instead of `done`. All downstream dependent nodes are also skipped. The pipeline completes successfully (not failed).
+
+```yaml
+nodes:
+  check:
+    mode: shell
+    project: my-app
+    prompt: |
+      if [ -z "{{input.issue_id}}" ]; then
+        echo "__SKIP__ No issue_id provided"
+        exit 0
+      fi
+      echo "Processing issue {{input.issue_id}}"
+```
+
+Use this for optional steps that should gracefully skip when preconditions aren't met.
+
+## Conditional Routing
+
+Nodes can route to different next steps based on output content:
+
+```yaml
+nodes:
+  analyze:
+    project: my-app
+    prompt: "Analyze the issue. Reply SIMPLE or COMPLEX."
+    outputs:
+      - name: complexity
+        extract: result
+    routes:
+      - condition: "{{outputs.complexity contains 'SIMPLE'}}"
+        next: quick-fix
+      - condition: default
+        next: deep-fix
+  quick-fix:
+    depends_on: [analyze]
+    project: my-app
+    prompt: "Apply a quick fix"
+  deep-fix:
+    depends_on: [analyze]
+    project: my-app
+    prompt: "Do a thorough analysis and fix"
+```
+
+### Route Conditions
+
+- `{{outputs.<name> contains '<keyword>'}}` — check if output contains a keyword
+- `default` — fallback route (always matches)
+
+### Loops
+
+If a route points back to the same node, it creates a loop (up to `max_iterations`):
+
+```yaml
+nodes:
+  fix-and-test:
+    project: my-app
+    prompt: "Fix the failing test, then run tests."
+    max_iterations: 5
+    outputs:
+      - name: test_result
+        extract: result
+    routes:
+      - condition: "{{outputs.test_result contains 'PASS'}}"
+        next: done
+      - condition: default
+        next: fix-and-test   # loop back to retry
+  done:
+    depends_on: [fix-and-test]
+    mode: shell
+    project: my-app
+    prompt: "echo 'All tests passing!'"
+```
+
+## Branch Auto-checkout
+
+Nodes can auto-checkout a git branch before execution:
+
+```yaml
+nodes:
+  work:
+    project: my-app
+    branch: "feature/{{input.feature_name}}"
+    prompt: "Implement the feature"
+```
+
+## Parallel Execution
+
+Nodes without dependency relationships run in parallel:
+
+```yaml
+nodes:
+  frontend:
+    project: my-app
+    prompt: "Build frontend component"
+  backend:
+    project: my-app
+    prompt: "Build API endpoint"
+  integration:
+    depends_on: [frontend, backend]  # waits for both
+    project: my-app
+    prompt: "Integration test"
+```
+
+`frontend` and `backend` run simultaneously; `integration` starts when both finish.
 
 ## Built-in Workflows
 
 ### issue-fix-and-review
-Complete issue resolution pipeline: fetch issue → fix code → create PR → review code → notify.
+Complete issue resolution: fetch GitHub issue → fix code on new branch → create PR.
+
+**Input**: `issue_id`, `project`, `base_branch` (optional), `extra_context` (optional)
+
+**Steps**: setup → fetch-issue → fix-code → push-and-pr → notify
+
+**Prerequisites**: `gh` CLI installed and authenticated (`gh auth login`), project has GitHub remote.
+
+### pr-review
+Review a pull request: fetch PR diff → AI review → report.
+
+**Input**: `pr_number`, `project`
+
+**Steps**: setup → fetch-pr → review → post-review
 
-Steps: setup → fetch-issue → fix-code → push-and-pr → review → cleanup
+## Project Pipeline Bindings
 
-Input: `issue_id`, `project`, `base_branch` (optional), `extra_context` (optional)
+Projects can bind workflows for easy access and scheduled execution.
+
+### Binding a Workflow to a Project
+
+1. Go to **Projects → select project → Pipelines tab**
+2. Click **+ Add** to attach a workflow
+3. Configure:
+   - **Enabled**: toggle on/off
+   - **Schedule**: Manual only, or periodic (15min to 24h intervals)
+4. Click **Run** to manually trigger
+
+### Scheduled Execution
+
+When a schedule is set (e.g., "Every 30 min"):
+- The scheduler checks all bindings every 60 seconds
+- If the interval has elapsed since last run, the pipeline triggers automatically
+- Running pipelines are not re-triggered (prevents overlap)
+- `Last run` and `Next run` times are shown in the UI
+
+Schedule options: Manual only, 15min, 30min, 1h, 2h, 6h, 12h, 24h.
+
+### API
+
+```bash
+# List bindings + runs + workflows for a project
+curl "http://localhost:3000/api/project-pipelines?project=/path/to/project"
+
+# Add binding
+curl -X POST http://localhost:3000/api/project-pipelines \
+  -H 'Content-Type: application/json' \
+  -d '{"action":"add","projectPath":"/path","projectName":"my-app","workflowName":"issue-fix-and-review"}'
+
+# Update binding (enable/disable, change config/schedule)
+curl -X POST http://localhost:3000/api/project-pipelines \
+  -H 'Content-Type: application/json' \
+  -d '{"action":"update","projectPath":"/path","workflowName":"issue-fix-and-review","config":{"interval":30}}'
+
+# Trigger pipeline manually
+curl -X POST http://localhost:3000/api/project-pipelines \
+  -H 'Content-Type: application/json' \
+  -d '{"action":"trigger","projectPath":"/path","projectName":"my-app","workflowName":"issue-fix-and-review","input":{"issue_id":"42"}}'
+
+# Remove binding
+curl -X POST http://localhost:3000/api/project-pipelines \
+  -H 'Content-Type: application/json' \
+  -d '{"action":"remove","projectPath":"/path","workflowName":"issue-fix-and-review"}'
+```
 
 ## CLI
 
@@ -66,7 +292,7 @@ forge run my-workflow    # execute a workflow
 
 ## Import a Workflow
 
-1. In Pipelines tab, click **Import**
+1. In **Pipelines** tab, click **Import**
 2. Paste YAML workflow content
 3. Click **Save Workflow**
 
@@ -79,10 +305,25 @@ To create a workflow via Help AI: ask "Create a pipeline that does X" — the AI
 ```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"}'
+  -d '{"action": "save-workflow", "yaml": "<yaml content>"}'
 ```
 
+## Pipeline Model
+
+In **Settings → Pipeline Model**, you can select which Claude model runs pipeline tasks. Set to `default` to use the same model as regular tasks.
+
 ## Storage
 
 - Workflow YAML: `~/.forge/data/flows/`
 - Execution state: `~/.forge/data/pipelines/`
+- Binding config & run history: SQLite database (`~/.forge/data/forge.db`)
+
+## Tips for Writing Workflows
+
+1. **Start with shell nodes** for setup (git checkout, environment checks)
+2. **Use `__SKIP__`** for optional steps with precondition checks
+3. **Extract outputs** to pass data between nodes
+4. **Use routes** for conditional logic (simple/complex paths, retry loops)
+5. **Keep prompts focused** — each node should do one thing well
+6. **Test manually first** before setting up schedules
+7. **Use `depends_on`** to control execution order; nodes without dependencies run in parallel

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

@@ -2,7 +2,7 @@
 
 ## Overview
 
-Automatically scan GitHub Issues, fix code, create PRs, and review — all hands-free.
+Automatically scan GitHub Issues, fix code, create PRs — all hands-free. Uses the built-in `issue-fix-and-review` pipeline workflow with integrated issue scanning.
 
 ## Prerequisites
 
@@ -11,41 +11,45 @@ Automatically scan GitHub Issues, fix code, create PRs, and review — all hands
 
 ## Setup
 
-1. Go to **Projects → select project → Issues tab**
-2. Enable **Issue Auto-fix**
-3. Configure:
-   - **Scan Interval**: minutes between scans (0 = manual only)
-   - **Base Branch**: leave empty for auto-detect (main/master)
-   - **Labels Filter**: comma-separated labels (empty = all issues)
-4. Click **Scan Now** to test
+1. Go to **Projects → select project → Pipelines tab**
+2. Click **+ Add** and select `issue-fix-and-review`
+3. Enable the binding
+4. Check **Auto-scan GitHub Issues** to enable automatic scanning
+5. Configure:
+   - **Schedule**: How often to scan (e.g., Every 30 min)
+   - **Labels**: Filter issues by label (comma-separated, empty = all)
+   - **Base Branch**: Leave empty for auto-detect (main/master)
+6. Click **Scan** to manually trigger a scan
 
 ## Flow
 
 ```
-Scan → Fetch Issue → Fix Code (new branch) → Push → Create PR → Auto Review → Notify
+Scan Issues → For each new issue:
+  Setup → Fetch Issue → Fix Code (new branch) → Push & Create PR → Notify
 ```
 
 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**: AI reviews the code changes in the same pipeline
-5. **Notify**: Results sent via Telegram (if configured)
+2. **Dedup**: Already-processed issues are skipped (tracked in `pipeline_runs`)
+3. **Setup**: Checks for clean working directory, detects repo and base branch
+4. **Fetch Issue**: `gh issue view` fetches issue data
+5. **Fix Code**: Claude analyzes issue and fixes code on `fix/<id>-<description>` branch
+6. **Push & PR**: Pushes branch and creates Pull Request via `gh pr create`
+7. **Notify**: Switches back to original branch, reports PR URL
 
 ## Manual Trigger
 
-Enter an issue number in "Manual Trigger" section and click "Fix Issue".
+- **Run** button: Triggers the workflow with custom input (requires `issue_id`)
+- **Scan** button: Scans for all open issues and triggers fixes for new ones
 
-## Retry
+## Dedup
 
-Failed fixes show a "Retry" button. Click to provide additional context (e.g. "rebase from main first") and re-run.
+Each processed issue is tracked with a `dedup_key` (e.g., `issue:42`) in the pipeline runs table. Once an issue has been processed, it won't be triggered again even if it's still open. To re-process an issue, delete its run from the execution history.
 
 ## Safety
 
 - Checks for uncommitted changes before starting (aborts if dirty)
-- Always works on new branches (never modifies main)
+- Always works on new branches (never modifies main/master)
+- Cleans up old fix branches for the same issue
 - Switches back to original branch after completion
-- Existing PRs are updated, not duplicated
-
-## Processed Issues
-
-History shows all processed issues with status (processing/done/failed), PR number, and pipeline ID. Click pipeline ID to view details.
+- Uses `--force-with-lease` for safe push
+- Running pipelines are not re-triggered (one fix per issue at a time)

package/lib/help-docs/CLAUDE.md

@@ -0,0 +1,41 @@
+You are a help assistant for **Forge** — a self-hosted Vibe Coding platform.
+
+Your job is to answer user questions about Forge features, configuration, and troubleshooting.
+
+## How to answer
+
+1. Read the relevant documentation file(s) from this directory before answering
+2. Base your answers on the documentation content, not assumptions
+3. If the answer isn't in the docs, say so honestly
+4. Give concise, actionable answers with code examples when helpful
+5. When generating files (YAML workflows, configs, scripts, etc.), **always save the file directly** to the appropriate directory rather than printing it. For pipeline workflows, save to `~/.forge/data/flows/<name>.yaml`. Tell the user the file path so they can find it. The terminal does not support copy/paste.
+
+## Available documentation
+
+| File | Topic |
+|------|-------|
+| `00-overview.md` | Installation, startup, data paths, architecture |
+| `01-settings.md` | All settings fields and configuration |
+| `02-telegram.md` | Telegram bot setup and commands |
+| `03-tunnel.md` | Remote access via Cloudflare tunnel |
+| `04-tasks.md` | Background task system |
+| `05-pipelines.md` | Pipeline/workflow engine — YAML format, nodes, templates, routing, scheduling, project bindings |
+| `06-skills.md` | Skills marketplace and installation |
+| `07-projects.md` | Project management |
+| `08-rules.md` | CLAUDE.md templates and rule injection |
+| `09-issue-autofix.md` | GitHub issue auto-fix pipeline |
+| `10-troubleshooting.md` | Common issues and solutions |
+
+## Matching questions to docs
+
+- Pipeline/workflow/DAG/YAML → `05-pipelines.md`
+- Issue/PR/auto-fix → `09-issue-autofix.md` + `05-pipelines.md`
+- Telegram/notification → `02-telegram.md`
+- Tunnel/remote/cloudflare → `03-tunnel.md`
+- Task/background/queue → `04-tasks.md`
+- Settings/config → `01-settings.md`
+- Install/start/update → `00-overview.md`
+- Error/bug/crash → `10-troubleshooting.md`
+- Skill/marketplace → `06-skills.md`
+- Project/favorite → `07-projects.md`
+- Rules/CLAUDE.md/template → `08-rules.md`

package/lib/init.ts

@@ -95,18 +95,12 @@ export function ensureInitialized() {
   // Session watcher is safe (file-based, idempotent)
   startWatcherLoop();
 
-  // Pipeline scheduler — periodic execution for project-bound workflows
+  // Pipeline scheduler — periodic execution + issue scanning 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();
-  } catch {}
-
   // If services are managed externally (forge-server), skip
   if (process.env.FORGE_EXTERNAL_SERVICES === '1') {
     // Password display

package/lib/pipeline-scheduler.ts

@@ -1,27 +1,36 @@
 /**
- * Pipeline Scheduler — manages project-pipeline bindings and scheduled execution.
- * Replaces issue-scanner with a generic approach.
+ * Pipeline Scheduler — manages project-pipeline bindings, scheduled execution,
+ * and issue scanning (replaces issue-scanner.ts).
  *
  * Each project can bind multiple workflows. Each binding has:
- * - config: JSON with workflow-specific settings (e.g. interval, labels for issue pipelines)
+ * - config: JSON with workflow-specific settings (interval, scanType, labels, baseBranch)
  * - enabled: on/off toggle
  * - scheduled execution via config.interval (minutes, 0 = manual only)
+ * - config.scanType: 'github-issues' enables automatic issue scanning + dedup
  */
 
 import { getDb } from '@/src/core/db/database';
 import { getDbPath } from '@/src/config';
 import { startPipeline, getPipeline } from './pipeline';
 import { randomUUID } from 'node:crypto';
+import { execSync } from 'node:child_process';
 
 function db() { return getDb(getDbPath()); }
 
+/** Normalize SQLite datetime('now') → ISO 8601 UTC string. */
+function toIsoUTC(s: string | null): string | null {
+  if (!s) return null;
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(s)) return s.replace(' ', 'T') + 'Z';
+  return s;
+}
+
 export interface ProjectPipelineBinding {
   id: number;
   projectPath: string;
   projectName: string;
   workflowName: string;
   enabled: boolean;
-  config: Record<string, any>; // interval (minutes), labels, baseBranch, etc.
+  config: Record<string, any>; // interval, scanType, labels, baseBranch, etc.
   lastRunAt: string | null;
   createdAt: string;
 }
@@ -33,6 +42,7 @@ export interface PipelineRun {
   pipelineId: string;
   status: string;
   summary: string;
+  dedupKey: string | null;
   createdAt: string;
 }
 
@@ -47,8 +57,8 @@ export function getBindings(projectPath: string): ProjectPipelineBinding[] {
       workflowName: r.workflow_name,
       enabled: !!r.enabled,
       config: JSON.parse(r.config || '{}'),
-      lastRunAt: r.last_run_at || null,
-      createdAt: r.created_at,
+      lastRunAt: toIsoUTC(r.last_run_at),
+      createdAt: toIsoUTC(r.created_at) ?? r.created_at,
     }));
 }
 
@@ -61,8 +71,8 @@ export function getAllScheduledBindings(): ProjectPipelineBinding[] {
       workflowName: r.workflow_name,
       enabled: true,
       config: JSON.parse(r.config || '{}'),
-      lastRunAt: r.last_run_at || null,
-      createdAt: r.created_at,
+      lastRunAt: toIsoUTC(r.last_run_at),
+      createdAt: toIsoUTC(r.created_at) ?? r.created_at,
     })).filter(b => b.config.interval && b.config.interval > 0);
 }
 
@@ -96,12 +106,12 @@ function updateLastRunAt(projectPath: string, workflowName: string): void {
 
 // ─── Runs ────────────────────────────────────────────────
 
-export function recordRun(projectPath: string, workflowName: string, pipelineId: string): string {
+export function recordRun(projectPath: string, workflowName: string, pipelineId: string, dedupKey?: 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);
+    INSERT INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status, dedup_key)
+    VALUES (?, ?, ?, ?, 'running', ?)
+  `).run(id, projectPath, workflowName, pipelineId, dedupKey || null);
   return id;
 }
 
@@ -127,7 +137,8 @@ export function getRuns(projectPath: string, workflowName?: string, limit = 20):
     pipelineId: r.pipeline_id,
     status: r.status,
     summary: r.summary || '',
-    createdAt: r.created_at,
+    dedupKey: r.dedup_key || null,
+    createdAt: toIsoUTC(r.created_at) ?? r.created_at,
   }));
 }
 
@@ -135,18 +146,36 @@ export function deleteRun(id: string): void {
   db().prepare('DELETE FROM pipeline_runs WHERE id = ?').run(id);
 }
 
+// ─── Dedup ──────────────────────────────────────────────
+
+function isDuplicate(projectPath: string, workflowName: string, dedupKey: string): boolean {
+  const row = db().prepare(
+    'SELECT 1 FROM pipeline_runs WHERE project_path = ? AND workflow_name = ? AND dedup_key = ?'
+  ).get(projectPath, workflowName, dedupKey);
+  return !!row;
+}
+
+export function resetDedup(projectPath: string, workflowName: string, dedupKey: string): void {
+  db().prepare(
+    'DELETE FROM pipeline_runs WHERE project_path = ? AND workflow_name = ? AND dedup_key = ?'
+  ).run(projectPath, workflowName, dedupKey);
+}
+
 // ─── Trigger ─────────────────────────────────────────────
 
-export function triggerPipeline(projectPath: string, projectName: string, workflowName: string, extraInput?: Record<string, any>): { pipelineId: string; runId: string } {
+export function triggerPipeline(
+  projectPath: string, projectName: string, workflowName: string,
+  extraInput?: Record<string, any>, dedupKey?: string
+): { pipelineId: string; runId: string } {
   const input: Record<string, string> = {
     project: projectName,
     ...extraInput,
   };
 
   const pipeline = startPipeline(workflowName, input);
-  const runId = recordRun(projectPath, workflowName, pipeline.id);
+  const runId = recordRun(projectPath, workflowName, pipeline.id, dedupKey);
   updateLastRunAt(projectPath, workflowName);
-  console.log(`[pipeline-scheduler] Triggered ${workflowName} for ${projectName} (pipeline: ${pipeline.id})`);
+  console.log(`[pipeline-scheduler] Triggered ${workflowName} for ${projectName} (pipeline: ${pipeline.id}${dedupKey ? ', dedup: ' + dedupKey : ''})`);
   return { pipelineId: pipeline.id, runId };
 }
 
@@ -171,6 +200,94 @@ export function syncRunStatus(pipelineId: string): void {
   updateRun(pipelineId, pipeline.status, summary.trim());
 }
 
+// ─── GitHub Issue Scanning ──────────────────────────────
+
+function getRepoFromProject(projectPath: string): string | null {
+  try {
+    return execSync('gh repo view --json nameWithOwner -q .nameWithOwner', {
+      cwd: projectPath, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim() || null;
+  } catch {
+    try {
+      const url = execSync('git remote get-url origin', {
+        cwd: projectPath, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      return url.replace(/.*github\.com[:/]/, '').replace(/\.git$/, '') || null;
+    } catch { return null; }
+  }
+}
+
+function fetchOpenIssues(projectPath: string, labels: string[]): { number: number; title: string; error?: string }[] {
+  const repo = getRepoFromProject(projectPath);
+  if (!repo) return [{ number: -1, title: '', error: 'Could not detect GitHub repo. Run: gh auth login' }];
+  try {
+    const labelFilter = labels.length > 0 ? ` --label "${labels.join(',')}"` : '';
+    const out = execSync(`gh issue list --state open --json number,title${labelFilter} -R ${repo}`, {
+      cwd: projectPath, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return JSON.parse(out) || [];
+  } catch (e: any) {
+    const msg = e.stderr?.toString() || e.message || 'gh CLI failed';
+    return [{ number: -1, title: '', error: msg.includes('auth') ? 'GitHub CLI not authenticated. Run: gh auth login' : msg }];
+  }
+}
+
+export function scanAndTriggerIssues(binding: ProjectPipelineBinding): { triggered: number; issues: number[]; total: number; pending: number; error?: string } {
+  const labels: string[] = binding.config.labels || [];
+  const issues = fetchOpenIssues(binding.projectPath, labels);
+
+  // Check for errors
+  if (issues.length === 1 && (issues[0] as any).error) {
+    return { triggered: 0, issues: [], total: 0, pending: 0, error: (issues[0] as any).error };
+  }
+
+  // Check if there's already a running pipeline for this project+workflow — only one at a time
+  // to prevent concurrent git operations on the same repo
+  const recentRuns = getRuns(binding.projectPath, binding.workflowName, 5);
+  const hasRunning = recentRuns.some(r => r.status === 'running');
+
+  const newIssues: { number: number; title: string }[] = [];
+  for (const issue of issues) {
+    if (issue.number < 0) continue;
+    const dedupKey = `issue:${issue.number}`;
+    if (!isDuplicate(binding.projectPath, binding.workflowName, dedupKey)) {
+      newIssues.push(issue);
+    }
+  }
+
+  if (newIssues.length === 0) {
+    updateLastRunAt(binding.projectPath, binding.workflowName);
+    return { triggered: 0, issues: [], total: issues.length, pending: 0 };
+  }
+
+  // Only trigger ONE issue at a time to avoid concurrent git conflicts
+  // Next issue will be triggered on the next scan cycle
+  if (hasRunning) {
+    console.log(`[pipeline-scheduler] Issue scan: ${newIssues.length} new issues for ${binding.projectName}, waiting for current pipeline to finish`);
+    return { triggered: 0, issues: [], total: issues.length, pending: newIssues.length };
+  }
+
+  const issue = newIssues[0];
+  const dedupKey = `issue:${issue.number}`;
+  try {
+    triggerPipeline(
+      binding.projectPath, binding.projectName, binding.workflowName,
+      {
+        issue_id: String(issue.number),
+        base_branch: binding.config.baseBranch || 'auto-detect',
+      },
+      dedupKey
+    );
+    console.log(`[pipeline-scheduler] Issue scan: triggered #${issue.number} "${issue.title}" for ${binding.projectName} (${newIssues.length - 1} more pending)`);
+  } catch (e: any) {
+    console.error(`[pipeline-scheduler] Issue scan: failed to trigger #${issue.number}:`, e.message);
+    return { triggered: 0, issues: [], total: issues.length, pending: newIssues.length, error: e.message };
+  }
+
+  updateLastRunAt(binding.projectPath, binding.workflowName);
+  return { triggered: 1, issues: [issue.number], total: issues.length, pending: newIssues.length - 1 };
+}
+
 // ─── Periodic Scheduler ─────────────────────────────────
 
 const schedulerKey = Symbol.for('forge-pipeline-scheduler');
@@ -210,19 +327,24 @@ function tickScheduler(): void {
       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
-        }
+      if (elapsed < intervalMs) continue;
+
+      try {
+        const isIssueWorkflow = binding.workflowName === 'issue-fix-and-review' || binding.workflowName === 'issue-auto-fix' || binding.config.scanType === 'github-issues';
+        if (isIssueWorkflow) {
+          // Issue scan mode: fetch issues → dedup → trigger per issue
+          console.log(`[pipeline-scheduler] Scheduled issue scan: ${binding.workflowName} for ${binding.projectName}`);
+          scanAndTriggerIssues(binding);
+        } else {
+          // Normal mode: single trigger (skip if still running)
+          const recentRuns = getRuns(binding.projectPath, binding.workflowName, 1);
+          if (recentRuns.length > 0 && recentRuns[0].status === 'running') continue;
 
-        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] Scheduled trigger failed for ${binding.workflowName}:`, e.message);
       }
     }
   } catch (e: any) {

package/lib/pipeline.ts

@@ -92,7 +92,7 @@ nodes:
       if [ -n "$(git status --porcelain)" ]; then echo "ERROR: Working directory has uncommitted changes. Please commit or stash first." && exit 1; fi && \
       ORIG_BRANCH=$(git branch --show-current || git rev-parse --short HEAD) && \
       REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || git remote get-url origin | sed 's/.*github.com[:/]//;s/.git$//') && \
-      BASE={{input.base_branch}} && \
+      BASE="{{input.base_branch}}" && \
       if [ -z "$BASE" ] || [ "$BASE" = "auto-detect" ]; then BASE=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo main); fi && \
       git checkout "$BASE" 2>/dev/null || true && \
       git pull origin "$BASE" 2>/dev/null || true && \
@@ -109,7 +109,8 @@ nodes:
     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) && \
+      SETUP_INFO=$'{{nodes.setup.outputs.info}}' && \
+      REPO=$(echo "$SETUP_INFO" | grep REPO= | cut -d= -f2) && \
       gh issue view "$ISSUE_ID" --json title,body,labels,number -R "$REPO"
     outputs:
       - name: issue_json
@@ -140,11 +141,12 @@ nodes:
     project: "{{input.project}}"
     depends_on: [fix-code]
     prompt: |
-      REPO=$(echo '{{nodes.setup.outputs.info}}' | grep REPO= | cut -d= -f2) && \
+      SETUP_INFO=$'{{nodes.setup.outputs.info}}' && \
+      REPO=$(echo "$SETUP_INFO" | grep REPO= | cut -d= -f2) && \
       BRANCH=$(git branch --show-current) && \
       git push -u origin "$BRANCH" --force-with-lease 2>&1 && \
-      PR_URL=$(gh pr create --title 'Fix #{{input.issue_id}}' \
-        --body 'Auto-fix by Forge Pipeline for issue #{{input.issue_id}}.' -R "$REPO" 2>/dev/null || \
+      PR_URL=$(gh pr create --title "Fix #{{input.issue_id}}" \
+        --body "Auto-fix by Forge Pipeline for issue #{{input.issue_id}}." -R "$REPO" 2>/dev/null || \
         gh pr view "$BRANCH" --json url -q .url -R "$REPO" 2>/dev/null) && \
       echo "$PR_URL"
     outputs:
@@ -178,12 +180,14 @@ nodes:
     project: "{{input.project}}"
     depends_on: [review]
     prompt: |
-      ORIG=$(echo '{{nodes.setup.outputs.info}}' | grep ORIG_BRANCH= | cut -d= -f2) && \
+      SETUP_INFO=$'{{nodes.setup.outputs.info}}' && \
+      ORIG=$(echo "$SETUP_INFO" | grep ORIG_BRANCH= | cut -d= -f2) && \
+      PR_URL=$'{{nodes.push-and-pr.outputs.pr_url}}' && \
       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))"
+        echo "Issue #{{input.issue_id}} — PR: $PR_URL (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)"
+        echo "Issue #{{input.issue_id}} — PR: $PR_URL (switched back to $ORIG)"
       fi
     outputs:
       - name: result
@@ -306,12 +310,22 @@ export function listPipelines(): Pipeline[] {
 
 // ─── Template Resolution ──────────────────────────────────
 
-/** Escape a string for safe embedding in shell commands (single-quote wrapping) */
+/** Escape a string for safe embedding in single-quoted shell strings */
 function shellEscape(s: string): string {
   // Replace single quotes with '\'' (end quote, escaped quote, start quote)
   return s.replace(/'/g, "'\\''");
 }
 
+/** Escape a string for safe embedding in $'...' shell strings (ANSI-C quoting) */
+function shellEscapeAnsiC(s: string): string {
+  return s
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+}
+
 function resolveTemplate(template: string, ctx: {
   input: Record<string, string>;
   vars: Record<string, string>;
@@ -336,7 +350,7 @@ function resolveTemplate(template: string, ctx: {
       }
     }
 
-    return shellMode ? shellEscape(value) : value;
+    return shellMode ? shellEscapeAnsiC(value) : value;
   });
 }
 

package/lib/task-manager.ts

@@ -12,6 +12,13 @@ import { loadSettings } from './settings';
 import { notifyTaskComplete, notifyTaskFailed } from './notify';
 import type { Task, TaskLogEntry, TaskStatus, TaskMode, WatchConfig } from '@/src/types';
 
+/** Normalize SQLite datetime('now') → ISO 8601 UTC string. */
+function toIsoUTC(s: string | null | undefined): string | null {
+  if (!s) return null;
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(s)) return s.replace(' ', 'T') + 'Z';
+  return s;
+}
+
 const runnerKey = Symbol.for('mw-task-runner');
 const gRunner = globalThis as any;
 if (!gRunner[runnerKey]) gRunner[runnerKey] = { runner: null, currentTaskId: null };
@@ -601,10 +608,10 @@ function rowToTask(row: any): Task {
     gitBranch: row.git_branch || undefined,
     costUSD: row.cost_usd || undefined,
     error: row.error || undefined,
-    createdAt: row.created_at,
-    startedAt: row.started_at || undefined,
-    completedAt: row.completed_at || undefined,
-    scheduledAt: row.scheduled_at || undefined,
+    createdAt: toIsoUTC(row.created_at) ?? row.created_at,
+    startedAt: toIsoUTC(row.started_at) ?? undefined,
+    completedAt: toIsoUTC(row.completed_at) ?? undefined,
+    scheduledAt: toIsoUTC(row.scheduled_at) ?? undefined,
   };
 }
 

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

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

package/src/core/db/database.ts

@@ -35,6 +35,25 @@ function initSchema(db: Database.Database) {
   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');
+  migrate('ALTER TABLE pipeline_runs ADD COLUMN dedup_key TEXT');
+  // Unique index for dedup (only applies when dedup_key is NOT NULL)
+  try { db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_pipeline_runs_dedup ON pipeline_runs(project_path, workflow_name, dedup_key)'); } catch {}
+  // Migrate old issue_autofix_processed → pipeline_runs
+  try {
+    const old = db.prepare('SELECT * FROM issue_autofix_processed').all() as any[];
+    if (old.length > 0) {
+      const ins = db.prepare('INSERT OR IGNORE INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status, dedup_key, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
+      for (const r of old) {
+        ins.run(
+          r.pipeline_id?.slice(0, 8) || ('mig-' + r.issue_number),
+          r.project_path, 'issue-fix-and-review', r.pipeline_id || '',
+          r.status === 'processing' ? 'running' : (r.status || 'done'),
+          `issue:${r.issue_number}`, r.created_at || new Date().toISOString()
+        );
+      }
+      console.log(`[db] Migrated ${old.length} issue_autofix_processed records to pipeline_runs`);
+    }
+  } catch {}
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS sessions (