@aion0/forge 0.4.6 → 0.4.7

package/RELEASE_NOTES.md

@@ -1,12 +1,16 @@
-# Forge v0.4.6
+# Forge v0.4.7
 
-Released: 2026-03-21
+Released: 2026-03-22
 
-## Changes since v0.4.5
+## Changes since v0.4.6
+
+### Bug Fixes
+- fix: serial issue scanning, shell ANSI-C escaping, pipeline navigation
+- fix: prevent concurrent startTunnel calls from killing each other (#16)
 
 ### Other
-- improve help features
-- imporve help features
+- improve pipeline
+- fix(#17): normalize SQLite datetime strings to ISO 8601 UTC
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.5...v0.4.6
+**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

@@ -217,7 +217,7 @@ nodes:
 
 ## Built-in Workflows
 
-### issue-auto-fix
+### issue-fix-and-review
 Complete issue resolution: fetch GitHub issue → fix code on new branch → create PR.
 
 **Input**: `issue_id`, `project`, `base_branch` (optional), `extra_context` (optional)
@@ -265,22 +265,22 @@ 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-auto-fix"}'
+  -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-auto-fix","config":{"interval":30}}'
+  -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-auto-fix","input":{"issue_id":"42"}}'
+  -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-auto-fix"}'
+  -d '{"action":"remove","projectPath":"/path","workflowName":"issue-fix-and-review"}'
 ```
 
 ## CLI

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

@@ -2,41 +2,48 @@
 
 ## Overview
 
-Automatically scan GitHub Issues, fix code, create PRs — all hands-free. Uses the built-in `issue-auto-fix` pipeline workflow.
+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
 
 - `gh` CLI installed and authenticated: `gh auth login`
 - Project has a GitHub remote
 
-## Setup (via Project Pipeline Binding)
+## Setup
 
 1. Go to **Projects → select project → Pipelines tab**
-2. Click **+ Add** and select `issue-auto-fix`
+2. Click **+ Add** and select `issue-fix-and-review`
 3. Enable the binding
-4. Set a **Schedule** (e.g., Every 30 min) for automatic scanning, or leave as "Manual only"
-5. Click **Run** to manually trigger with an `issue_id`
+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
 
 ```
-Setup → Fetch Issue → Fix Code (new branch) → Push & Create PR → Notify
+Scan Issues → For each new issue:
+  Setup → Fetch Issue → Fix Code (new branch) → Push & Create PR → Notify
 ```
 
-1. **Setup**: Checks for clean working directory, detects repo and base branch
-2. **Fetch Issue**: `gh issue view` fetches issue data (skips if no issue_id)
-3. **Fix Code**: Claude analyzes issue and fixes code on `fix/<id>-<description>` branch
-4. **Push & PR**: Pushes branch and creates Pull Request via `gh pr create`
-5. **Notify**: Switches back to original branch, reports PR URL
+1. **Scan**: `gh issue list` finds open issues matching labels
+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
 
-## Input Fields
+## Manual Trigger
 
-| Input | Description | Required |
-|-------|-------------|----------|
-| `issue_id` | GitHub issue number | Yes (skips if empty) |
-| `project` | Project name | Yes |
-| `base_branch` | Base branch for fix | No (auto-detect) |
-| `extra_context` | Additional instructions | No |
+- **Run** button: Triggers the workflow with custom input (requires `issue_id`)
+- **Scan** button: Scans for all open issues and triggers fixes for new ones
+
+## Dedup
+
+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
 
@@ -45,7 +52,4 @@ Setup → Fetch Issue → Fix Code (new branch) → Push & Create PR → Notify
 - Cleans up old fix branches for the same issue
 - Switches back to original branch after completion
 - Uses `--force-with-lease` for safe push
-
-## Legacy Issue Scanner
-
-The old issue scanner (`Projects → Issues tab`) is still functional for existing configurations. It uses `issue_autofix_config` DB table for per-project scan settings. New projects should use the pipeline binding approach above.
+- Running pipelines are not re-triggered (one fix per issue at a time)

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.4.6",
+  "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 (