@aion0/forge 0.5.24 → 0.5.26

package/lib/pipeline.ts

@@ -34,6 +34,7 @@ export interface WorkflowNode {
   mode?: 'claude' | 'shell' | 'plugin';  // default: 'claude', 'shell' runs command, 'plugin' runs plugin action
   agent?: string;              // agent ID (default: from settings)
   branch?: string;             // auto checkout this branch before running (supports templates)
+  worktree?: boolean;          // default: true. Set false to skip worktree isolation (run in project dir directly)
   // Plugin mode fields
   plugin?: string;             // plugin ID (e.g., 'jenkins', 'docker')
   pluginAction?: string;       // action name (e.g., 'trigger', 'build'), defaults to plugin's defaultAction
@@ -259,6 +260,133 @@ agents:
 max_rounds: 3
 stop_condition: "both agents say DONE"
 initial_prompt: "Task: {{input.task}}"
+`,
+  'review-mr': `
+name: review-mr
+description: "Review PR — AI code review with GitHub comment"
+input:
+  project: "Project name"
+  branch: "Branch name or PR number (empty = auto-detect latest open PR)"
+  base_branch: "Target branch (default: main)"
+vars:
+  default_base: main
+nodes:
+  resolve-pr:
+    mode: shell
+    project: "{{input.project}}"
+    worktree: false
+    prompt: |
+      INPUT_BRANCH="{{input.branch}}" && \\
+      BASE="{{input.base_branch}}" && \\
+      if [ -z "$BASE" ] || echo "$BASE" | grep -q '{{'; then BASE="main"; fi && \\
+      if [ -z "$INPUT_BRANCH" ] || echo "$INPUT_BRANCH" | grep -q '{{'; then \\
+        INPUT_BRANCH=$(gh pr list --state open --base "$BASE" --json number -q '.[0].number' 2>/dev/null); \\
+        if [ -z "$INPUT_BRANCH" ]; then echo "ERROR: No open PR found targeting $BASE" && exit 1; fi; \\
+      fi && \\
+      if echo "$INPUT_BRANCH" | grep -qE '^[0-9]+$'; then \\
+        PR_NUM="$INPUT_BRANCH"; \\
+      else \\
+        PR_NUM=$(gh pr list --state open --head "$INPUT_BRANCH" --json number -q '.[0].number' 2>/dev/null); \\
+        if [ -z "$PR_NUM" ]; then echo "ERROR: No open PR for branch $INPUT_BRANCH" && exit 1; fi; \\
+      fi && \\
+      echo "$PR_NUM"
+    outputs:
+      - name: pr_number
+        extract: stdout
+  fetch-diff:
+    mode: shell
+    project: "{{input.project}}"
+    worktree: false
+    depends_on: [resolve-pr]
+    prompt: "gh pr diff {{nodes.resolve-pr.outputs.pr_number}}"
+    outputs:
+      - name: diff
+        extract: stdout
+  fetch-files:
+    mode: shell
+    project: "{{input.project}}"
+    worktree: false
+    depends_on: [resolve-pr]
+    prompt: |
+      PR_NUM="{{nodes.resolve-pr.outputs.pr_number}}" && \\
+      echo "=== PR #$PR_NUM ===" && \\
+      gh pr view "$PR_NUM" --json title,author,additions,deletions,changedFiles,commits,body --jq '"Title: " + .title + "\\nAuthor: " + .author.login + "\\nFiles: " + (.changedFiles|tostring) + " changed, +" + (.additions|tostring) + "/-" + (.deletions|tostring) + "\\nCommits: " + (.commits|length|tostring) + "\\n\\n=== PR Description ===\\n" + (.body // "(no description)")' && \\
+      echo "" && \\
+      echo "=== Changed Files ===" && \\
+      gh pr diff "$PR_NUM" --name-only
+    outputs:
+      - name: stats
+        extract: stdout
+  review:
+    project: "{{input.project}}"
+    worktree: false
+    depends_on: [fetch-diff, fetch-files, resolve-pr]
+    prompt: |
+      You are a senior code reviewer. Perform a thorough code review of this PR.
+
+      ## PR Info & Description
+      {{nodes.fetch-files.outputs.stats}}
+
+      ## Diff
+      {{nodes.fetch-diff.outputs.diff}}
+
+      ## Review Requirements
+
+      **First**: Verify the PR description against actual changes:
+      - Is every claimed change actually implemented?
+      - Any claimed changes that are NOT in the diff?
+      - Any changes in the diff NOT mentioned in the description?
+
+      **Then**: Review code quality:
+      1. Bug risk — logic errors, edge cases, null references
+      2. Security — injection, hardcoded secrets, sensitive data exposure
+      3. Performance — obvious bottlenecks
+      4. Code quality — readability, naming, DRY
+
+      ## Output
+
+      Write the full review report to /tmp/forge-review-pr{{nodes.resolve-pr.outputs.pr_number}}.md in this format:
+
+      ## 🤖 Forge AI Code Review — PR #{{nodes.resolve-pr.outputs.pr_number}}
+
+      ### 📋 Summary
+      - Verdict: ✅ Approve / ⚠️ Request Changes / ❌ Reject
+      - One-line summary
+
+      ### ✅ PR Description Verification
+      List each change claimed in the PR description, mark ✓ implemented / ✗ not implemented / ⚠️ partial
+
+      ### 🔴 Blockers (must fix)
+      (write "None" if none)
+
+      ### 🟡 Suggestions
+
+      ### 🟢 Nice-to-have
+
+      ### 💡 Highlights
+
+      ---
+      _Generated by [Forge](https://github.com/aiwatching/forge) Pipeline_
+
+      **You MUST write the complete report to /tmp/forge-review-pr{{nodes.resolve-pr.outputs.pr_number}}.md. This is the most important step.**
+    outputs:
+      - name: report
+        extract: result
+  post-comment:
+    mode: shell
+    project: "{{input.project}}"
+    worktree: false
+    depends_on: [review, resolve-pr]
+    prompt: |
+      PR_NUM="{{nodes.resolve-pr.outputs.pr_number}}" && \\
+      REPORT="/tmp/forge-review-pr\${PR_NUM}.md" && \\
+      if [ ! -f "$REPORT" ]; then echo "ERROR: Review report not found at $REPORT" && exit 1; fi && \\
+      gh pr comment "$PR_NUM" --body-file "$REPORT" && \\
+      rm -f "$REPORT" && \\
+      echo "Comment posted to PR #$PR_NUM"
+    outputs:
+      - name: result
+        extract: stdout
 `,
 };
 
@@ -310,6 +438,7 @@ function parseWorkflow(raw: string): Workflow {
       mode: n.mode || (n.plugin ? 'plugin' : 'claude'),
       agent: n.agent || undefined,
       branch: n.branch || undefined,
+      worktree: n.worktree !== undefined ? n.worktree : undefined,
       plugin: n.plugin || undefined,
       pluginAction: n.plugin_action || n.pluginAction || undefined,
       pluginParams: n.plugin_params || n.pluginParams || n.params || undefined,
@@ -1077,25 +1206,41 @@ async function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
       continue;
     }
 
-    // Auto checkout branch if specified
-    if (nodeDef.branch) {
-      const branchName = resolveTemplate(nodeDef.branch, ctx);
+    // All pipeline steps use worktree for isolated execution.
+    // Shell steps receive env vars: FORGE_WORKTREE, FORGE_WORKTREE_BRANCH, FORGE_PROJECT_ROOT.
+    // Set worktree: false on a node to skip (e.g. read-only gh commands that don't need isolation).
+    let effectivePath = projectInfo.path;
+    const useWorktree = nodeDef.worktree !== false;
+    const branchName = nodeDef.branch ? resolveTemplate(nodeDef.branch, ctx) : `pipeline/${pipeline.id.slice(0, 8)}`;
+    if (useWorktree) try {
+      const { execSync } = require('node:child_process');
+      const worktreePath = `${projectInfo.path}/.forge/worktrees/${branchName.replace(/\//g, '-')}`;
+      const { mkdirSync } = require('node:fs');
+      mkdirSync(`${projectInfo.path}/.forge/worktrees`, { recursive: true });
+
+      // Create branch if needed
+      try { execSync(`git branch ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' }); } catch {}
+
+      // Create or reuse worktree
       try {
-        const { execSync } = require('node:child_process');
-        // Create branch if not exists, or switch to it
-        try {
-          execSync(`git checkout -b ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
-        } catch {
-          execSync(`git checkout ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
+        execSync(`git worktree add "${worktreePath}" ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
+        console.log(`[pipeline] Created worktree: ${worktreePath} (branch: ${branchName})`);
+      } catch {
+        const { existsSync } = require('node:fs');
+        if (existsSync(worktreePath)) {
+          console.log(`[pipeline] Reusing worktree: ${worktreePath}`);
+        } else {
+          try { execSync(`git worktree remove "${worktreePath}" --force`, { cwd: projectInfo.path, stdio: 'pipe' }); } catch {}
+          execSync(`git worktree add "${worktreePath}" ${branchName}`, { cwd: projectInfo.path, stdio: 'pipe' });
+          console.log(`[pipeline] Recreated worktree: ${worktreePath}`);
         }
-        console.log(`[pipeline] Checked out branch: ${branchName}`);
-      } catch (e: any) {
-        nodeState.status = 'failed';
-        nodeState.error = `Branch checkout failed: ${e.message}`;
-        savePipeline(pipeline);
-        notifyStep(pipeline, nodeId, 'failed', nodeState.error);
-        continue;
       }
+
+      effectivePath = worktreePath;
+      (nodeState as any).worktreePath = worktreePath;
+      (nodeState as any).worktreeBranch = branchName;
+    } catch (e: any) {
+      console.warn(`[pipeline] Worktree creation failed, falling back to project dir: ${e.message}`);
     }
 
     // ── Plugin mode: execute plugin action directly ──
@@ -1147,21 +1292,24 @@ async function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
     }
 
     // ── Shell/Agent mode: create task ──
+    // Inject worktree info into shell prompt so git commands work correctly
     const taskMode = nodeDef.mode === 'shell' ? 'shell' : 'prompt';
+    let effectivePrompt = prompt;
+    if (taskMode === 'shell' && effectivePath !== projectInfo.path) {
+      // Prepend env vars so shell scripts know they're in a worktree
+      const envPrefix = `export FORGE_WORKTREE="${effectivePath}" FORGE_WORKTREE_BRANCH="${(nodeState as any).worktreeBranch || branchName}" FORGE_PROJECT_ROOT="${projectInfo.path}" && `;
+      effectivePrompt = envPrefix + prompt;
+    }
     const task = createTask({
       projectName: projectInfo.name,
-      projectPath: projectInfo.path,
-      prompt,
+      projectPath: effectivePath,
+      prompt: effectivePrompt,
       mode: taskMode as any,
       agent: nodeDef.agent || undefined,
     });
     pipelineTaskIds.add(task.id);
-    if (taskMode !== 'shell') {
-      const pipelineModel = loadSettings().pipelineModel;
-      if (pipelineModel && pipelineModel !== 'default') {
-        taskModelOverrides.set(task.id, pipelineModel);
-      }
-    }
+    // Pipeline tasks use the same model selection as normal tasks:
+    // agent model > global taskModel. No separate pipelineModel override.
 
     nodeState.status = 'running';
     nodeState.taskId = task.id;
@@ -1193,6 +1341,15 @@ function checkPipelineCompletion(pipeline: Pipeline) {
       syncRunStatus(pipeline.id);
     } catch {}
 
+    // Log worktree info for user review
+    for (const [nodeId, state] of Object.entries(pipeline.nodes)) {
+      const wt = (state as any).worktreePath;
+      const branch = (state as any).worktreeBranch;
+      if (wt && branch) {
+        console.log(`[pipeline] Worktree preserved: ${wt} (branch: ${branch}) — review changes, then: git worktree remove "${wt}"`);
+      }
+    }
+
     // Release project lock
     const workflow = getWorkflow(pipeline.workflowName);
     if (workflow) {

package/lib/project-sessions.ts

@@ -5,7 +5,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { getDataDir } from '@/src/config';
+import { getDataDir } from './dirs';
 
 function getFilePath(): string {
   const dir = getDataDir();

package/lib/task-manager.ts

@@ -292,10 +292,12 @@ function executeTask(task: Task): Promise<void> {
     const agentId = (task as any).agent || settings.defaultAgent || 'claude';
     const adapter = getAgent(agentId);
 
-    // Model: per-task override > agent scene model > global fallback
+    // Model priority: per-task override > agent scene model > global taskModel
+    // "default" means "no override" — fall through to next level
     const agentCfg = settings.agents?.[agentId];
-    const isPipeline = (() => { try { const { pipelineTaskIds: p } = require('./pipeline'); return p.has(task.id); } catch { return false; } })();
-    const model = taskModelOverrides.get(task.id) || (isPipeline ? agentCfg?.models?.task : agentCfg?.models?.task) || agentCfg?.models?.task || settings.taskModel;
+    const agentModel = agentCfg?.models?.task;
+    const effectiveAgentModel = agentModel && agentModel !== 'default' ? agentModel : null;
+    const model = taskModelOverrides.get(task.id) || effectiveAgentModel || settings.taskModel;
     const supportsModel = adapter.config.capabilities?.supportsModel;
     const spawnOpts = adapter.buildTaskSpawn({
       projectPath: task.projectPath,

package/lib/terminal-standalone.ts

@@ -271,9 +271,9 @@ wss.on('connection', (ws: WebSocket) => {
       term = null;
     }
 
-    // Ensure mouse and scrollback are enabled (for old sessions too)
+    // Ensure mouse mode is off and scrollback is set (for old sessions too)
     try {
-      execSync(`${TMUX} set-option -t ${name} mouse on 2>/dev/null`);
+      execSync(`${TMUX} set-option -t ${name} mouse off 2>/dev/null`);
       execSync(`${TMUX} set-option -t ${name} history-limit 50000 2>/dev/null`);
     } catch {}
 

package/lib/workspace/index.ts

@@ -41,8 +41,10 @@ export {
 } from './manager';
 
 // Persistence
+// NOTE: saveWorkspace is intentionally NOT exported here.
+// The workspace daemon is the exclusive writer of state.json.
+// All mutations must go through the daemon's HTTP API to prevent race conditions.
 export {
-  saveWorkspace,
   loadWorkspace,
   listWorkspaces,
   findWorkspaceByProject,

package/lib/workspace/manager.ts

@@ -6,7 +6,7 @@
  */
 
 import { WorkspaceOrchestrator, type OrchestratorEvent } from './orchestrator';
-import { loadWorkspace, saveWorkspace } from './persistence';
+import { loadWorkspace } from './persistence';
 import type { WorkspaceState, WorkspaceAgentConfig } from './types';
 
 // Persist across HMR in dev mode

package/lib/workspace/orchestrator.ts

@@ -2997,7 +2997,14 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
           return true;
         }
 
-        // System messages (from _watch, _system, user) bypass causedBy rules
+        // System messages: _forge failure notifications are log-only (don't trigger agent execution)
+        if (m.from === '_forge' && m.payload?.action === 'update_notify') {
+          console.log(`[inbox] ${entry.config.label}: _forge notification logged, not executed`);
+          m.status = 'done' as any;
+          return false;
+        }
+
+        // Other system messages (from _watch, _system, user) bypass causedBy rules
         if (m.from.startsWith('_') || m.from === 'user') return true;
 
         // Notifications: check causedBy for loop prevention
@@ -3035,23 +3042,28 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
         timestamp: new Date(nextMsg.timestamp).toISOString(),
       };
 
-      // Terminal mode → inject; headless → worker (claude -p)
+      // Terminal mode → notify (agent pulls via /forge-inbox); headless → worker (claude -p)
       if (isTerminalMode) {
-        // Check if role reminder needed (combats auto-compaction over long sessions)
-        let messageText = nextMsg.payload.content || nextMsg.payload.action;
+        // "You have mail" approach: inject a short notification, not the message content.
+        // The agent calls /forge-inbox to read the actual message when ready.
+        const pendingCount = pending.length;
+        let notification = pendingCount > 1
+          ? `You have ${pendingCount} new messages in your inbox (latest from ${fromLabel}). Use /forge-inbox to read them.`
+          : `You have a new message from ${fromLabel}. Use /forge-inbox to read it.`;
+        // Prepend role reminder if needed (combats auto-compaction over long sessions)
         if (this.needsRoleReminder(agentId) && entry.config.role?.trim()) {
-          messageText = this.buildRoleReminder(entry.config) + '\n\n' + messageText;
+          notification = this.buildRoleReminder(entry.config) + '\n\n' + notification;
           this.markRoleInjected(agentId);
           console.log(`[inbox] ${entry.config.label}: prepended role reminder`);
         } else {
           this.incrementMsgCount(agentId);
         }
-        const injected = this.injectIntoSession(agentId, messageText);
+        const injected = this.injectIntoSession(agentId, notification);
         if (injected) {
           entry.state.taskStatus = 'running';
           this.emit('event', { type: 'task_status', agentId, taskStatus: 'running' } as any);
-          this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: '📺 Injected into terminal, monitoring for completion...', timestamp: new Date().toISOString() } } as any);
-          console.log(`[inbox] ${entry.config.label}: injected into terminal, starting completion monitor`);
+          this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: `📬 Notified agent: ${notification}`, timestamp: new Date().toISOString() } } as any);
+          console.log(`[inbox] ${entry.config.label}: notified of message from ${fromLabel}, monitoring for completion`);
           entry.state.currentMessageId = nextMsg.id;
           this.monitorTerminalCompletion(agentId, nextMsg.id, entry.state.tmuxSession!);
         } else {
@@ -3066,6 +3078,9 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
           this.emitAgentsChanged();
         }
       } else {
+        // Headless mode: mark running and push content directly
+        nextMsg.status = 'running' as any;
+        this.emit('event', { type: 'bus_message_status', messageId: nextMsg.id, status: 'running' } as any);
         entry.worker!.setProcessingMessage(nextMsg.id);
         entry.worker!.wake({ type: 'bus_message', messages: [logEntry] });
         this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: `⚡ Executed via headless (agent: ${entry.config.agentId || 'claude'})`, timestamp: new Date().toISOString() } } as any);

package/lib/workspace-standalone.ts

@@ -812,6 +812,73 @@ const server = createServer(async (req, res) => {
       });
     }
 
+    // Create workspace (daemon is the exclusive writer of state.json)
+    if (path === '/workspace/create' && method === 'POST') {
+      const bodyStr = await readBody(req);
+      const { id, projectPath, projectName, agents, agentStates, nodePositions, template, createdAt } = JSON.parse(bodyStr);
+
+      if (!projectPath || !projectName) return jsonError(res, 'projectPath and projectName required');
+
+      // Guard against concurrent creates for the same project
+      const existing = findWorkspaceByProject(projectPath);
+      if (existing && !template) return json(res, existing);
+
+      const state: import('./workspace/types').WorkspaceState = {
+        id: id || require('node:crypto').randomUUID(),
+        projectPath,
+        projectName,
+        agents: [],
+        agentStates: {},
+        nodePositions: {},
+        busLog: [],
+        createdAt: createdAt || Date.now(),
+        updatedAt: Date.now(),
+      };
+
+      // Import template: create agents from template with new IDs
+      if (template?.agents) {
+        const idMap = new Map<string, string>();
+        const ts = Date.now();
+        for (const agent of template.agents) {
+          const newId = `${agent.label.toLowerCase().replace(/\s+/g, '-')}-${ts}-${Math.random().toString(36).slice(2, 5)}`;
+          idMap.set(agent.id, newId);
+        }
+        for (const agent of template.agents) {
+          state.agents.push({
+            ...agent,
+            id: idMap.get(agent.id) || agent.id,
+            dependsOn: agent.dependsOn.map((d: string) => idMap.get(d) || d),
+            entries: agent.type === 'input' ? [] : undefined,
+          });
+          state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', taskStatus: 'idle', history: [], artifacts: [] };
+        }
+        if (template.nodePositions) {
+          for (const [oldId, pos] of Object.entries(template.nodePositions)) {
+            const newId = idMap.get(oldId);
+            if (newId) state.nodePositions[newId] = pos as { x: number; y: number };
+          }
+        }
+      }
+
+      // Persist to disk — daemon is the single writer
+      await saveWorkspace(state);
+
+      // Load into memory immediately so SSE/API work without a second round-trip
+      const orch = new WorkspaceOrchestrator(state.id, state.projectPath, state.projectName);
+      if (state.agents.length > 0) {
+        orch.loadSnapshot({
+          agents: state.agents,
+          agentStates: state.agentStates,
+          busLog: state.busLog,
+          busOutbox: state.busOutbox,
+        });
+      }
+      orch.on('event', (event: OrchestratorEvent) => { broadcastSSE(state.id, event); });
+      orchestrators.set(state.id, orch);
+
+      return json(res, state, 201);
+    }
+
     // Route: /workspace/:id/...
     const wsMatch = path.match(/^\/workspace\/([^/]+)(\/.*)?$/);
     if (!wsMatch) {

package/middleware.ts

@@ -2,7 +2,7 @@ import { NextResponse, type NextRequest } from 'next/server';
 
 export function middleware(req: NextRequest) {
   // Skip auth entirely in dev mode
-  const isDev = process.env.NODE_ENV !== 'production';
+  const isDev = process.env.NODE_ENV !== 'production' || process.env.FORGE_DEV === '1';
   if (isDev) {
     return NextResponse.next();
   }
@@ -14,7 +14,7 @@ export function middleware(req: NextRequest) {
     pathname.startsWith('/login') ||
     pathname.startsWith('/api/auth') ||
     pathname.startsWith('/api/telegram') ||
-    (pathname.startsWith('/api/workspace') && (pathname.includes('/smith') || pathname === '/api/workspace')) ||
+    (pathname.startsWith('/api/workspace') && (pathname.endsWith('/smith') || pathname === '/api/workspace')) ||
     pathname.startsWith('/_next') ||
     pathname === '/favicon.ico' ||
     pathname === '/icon.png'

package/package.json

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

package/pnpm-workspace.yaml

@@ -0,0 +1 @@
+approveBuilds: true

package/start.sh

@@ -25,6 +25,7 @@ export TERMINAL_PORT=${TERMINAL_PORT:-8404}
 export WORKSPACE_PORT=${WORKSPACE_PORT:-8405}
 
 if [ "$1" = "dev" ]; then
+  export FORGE_DEV=1
   pnpm dev
 else
   pnpm build && pnpm start