@aion0/forge 0.5.14 → 0.5.16

package/.forge/agent-context.json

@@ -0,0 +1,6 @@
+{
+  "workspaceId": "656c9e65-9d73-4cb6-a065-60d966e1fc78",
+  "agentId": "engineer-1774920478256",
+  "agentLabel": "Engineer",
+  "forgePort": 8403
+}

package/RELEASE_NOTES.md

@@ -1,14 +1,12 @@
-# Forge v0.5.14
+# Forge v0.5.16
 
 Released: 2026-03-31
 
-## Changes since v0.5.13
+## Changes since v0.5.15
 
-### Bug Fixes
-- fix: dedup forge failed notifications by sender→target pair
-- fix: TerminalLaunchDialog also uses daemon to create session
-- fix: FloatingTerminal only attaches, daemon creates all sessions
-- fix: write launch script to file to avoid tmux send-keys truncation
+### Features
+- feat: code search in project sidebar
+- feat: git enhancements — branch switch, resizable changes, more log
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.13...v0.5.14
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.15...v0.5.16

package/app/api/code/route.ts

@@ -89,6 +89,28 @@ export async function GET(req: Request) {
     return NextResponse.json({ error: 'Directory not under any project root' }, { status: 403 });
   }
 
+  // Code search (grep)
+  const searchQuery = searchParams.get('search');
+  if (searchQuery) {
+    try {
+      const { execSync } = require('node:child_process');
+      const safeQuery = searchQuery.replace(/['"\\]/g, '\\$&');
+      // Use grep -rn with limits to prevent huge output
+      const result = execSync(
+        `grep -rn --include='*.ts' --include='*.tsx' --include='*.js' --include='*.jsx' --include='*.py' --include='*.java' --include='*.go' --include='*.rs' --include='*.md' --include='*.json' --include='*.yaml' --include='*.yml' --include='*.css' --include='*.html' --include='*.vue' --include='*.svelte' -m 5 '${safeQuery}' . 2>/dev/null | head -100`,
+        { cwd: resolvedDir, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+      const matches = result ? result.split('\n').map((line: string) => {
+        const match = line.match(/^\.\/(.+?):(\d+):(.*)$/);
+        if (!match) return null;
+        return { file: match[1], line: parseInt(match[2]), content: match[3].trim().slice(0, 200) };
+      }).filter(Boolean) : [];
+      return NextResponse.json({ matches });
+    } catch {
+      return NextResponse.json({ matches: [] });
+    }
+  }
+
   // Git diff for a specific file
   const diffFile = searchParams.get('diff');
   if (diffFile) {

package/app/api/git/route.ts

@@ -34,12 +34,13 @@ export async function GET(req: NextRequest) {
 
   try {
     // Run all git commands in parallel
-    const [branchOut, statusOut, remoteOut, lastCommitOut, logOut] = await Promise.all([
+    const [branchOut, statusOut, remoteOut, lastCommitOut, logOut, branchListOut] = await Promise.all([
       gitAsync('rev-parse --abbrev-ref HEAD', dir),
       gitAsync('status --porcelain -u', dir),
       gitAsync('remote get-url origin', dir),
       gitAsync('log -1 --format="%h %s"', dir),
-      gitAsync('log --format="%h||%s||%an||%ar" -10', dir),
+      gitAsync('log --format="%h||%s||%an||%ar" -20', dir),
+      gitAsync('branch --format="%(refname:short)||%(upstream:short)||%(objectname:short)"', dir),
     ]);
 
     const branch = branchOut;
@@ -59,7 +60,12 @@ export async function GET(req: NextRequest) {
       return { hash, message, author, date };
     }) : [];
 
-    return NextResponse.json({ branch, changes, remote: remoteOut, ahead, behind, lastCommit: lastCommitOut, log });
+    const branches = branchListOut ? branchListOut.split('\n').filter(Boolean).map(line => {
+      const [name, upstream, hash] = line.split('||');
+      return { name, upstream: upstream || '', hash: hash || '', current: name === branch };
+    }) : [];
+
+    return NextResponse.json({ branch, branches, changes, remote: remoteOut, ahead, behind, lastCommit: lastCommitOut, log });
   } catch (e: any) {
     return NextResponse.json({ error: e.message }, { status: 500 });
   }
@@ -120,6 +126,13 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ ok: true, output });
     }
 
+    if (action === 'checkout') {
+      const branch = body.branch;
+      if (!branch) return NextResponse.json({ error: 'branch required' }, { status: 400 });
+      const out = gitSync(`checkout ${branch}`, dir);
+      return NextResponse.json({ ok: true, output: out });
+    }
+
     if (action === 'stage') {
       if (files && files.length > 0) {
         for (const f of files) gitSync(`add "${f}"`, dir);

package/components/ProjectDetail.tsx

@@ -49,6 +49,7 @@ function highlightLine(line: string): React.ReactNode {
 
 interface GitInfo {
   branch: string;
+  branches: { name: string; upstream: string; hash: string; current: boolean }[];
   changes: { status: string; path: string }[];
   remote: string;
   ahead: number;
@@ -72,6 +73,12 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
   const [fileLanguage, setFileLanguage] = useState('');
   const [fileLoading, setFileLoading] = useState(false);
   const [showLog, setShowLog] = useState(false);
+  const [changesExpanded, setChangesExpanded] = useState(false);
+  const [codeSearch, setCodeSearch] = useState('');
+  const [codeSearchResults, setCodeSearchResults] = useState<{ file: string; line: number; content: string }[]>([]);
+  const [codeSearching, setCodeSearching] = useState(false);
+  const [changesHeight, setChangesHeight] = useState(120);
+  const changesResizeRef = useRef<{ startY: number; origH: number } | null>(null);
   const [diffContent, setDiffContent] = useState<string | null>(null);
   const [diffFile, setDiffFile] = useState<string | null>(null);
   const [projectSkills, setProjectSkills] = useState<{ name: string; displayName: string; type: string; scope: string; version: string; installedVersion: string; hasUpdate: boolean; source: 'registry' | 'local' }[]>([]);
@@ -448,7 +455,25 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
         <div className="flex items-center gap-2">
           <span className="text-sm font-semibold text-[var(--text-primary)]">{projectName}</span>
           {gitInfo?.branch && (
-            <span className="text-[9px] text-[var(--accent)] bg-[var(--accent)]/10 px-1.5 py-0.5 rounded">{gitInfo.branch}</span>
+            <div className="relative">
+              <select
+                value={gitInfo.branch}
+                onChange={async (e) => {
+                  const branch = e.target.value;
+                  if (branch === gitInfo.branch) return;
+                  try {
+                    await fetch('/api/git', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ action: 'checkout', dir: projectPath, branch }) });
+                    fetchGitInfo(); fetchTree();
+                  } catch {}
+                }}
+                className="text-[9px] text-[var(--accent)] bg-[var(--accent)]/10 px-1.5 py-0.5 rounded border-none cursor-pointer appearance-none pr-4 focus:outline-none"
+                style={{ backgroundImage: 'url("data:image/svg+xml,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'8\' height=\'8\' viewBox=\'0 0 8 8\'%3E%3Cpath d=\'M0 2l4 4 4-4z\' fill=\'%2358a6ff\'/%3E%3C/svg%3E")', backgroundRepeat: 'no-repeat', backgroundPosition: 'right 4px center' }}
+              >
+                {(gitInfo.branches || []).map(b => (
+                  <option key={b.name} value={b.name}>{b.name}{b.current ? ' ●' : ''}</option>
+                ))}
+              </select>
+            </div>
           )}
           {gitInfo?.ahead ? <span className="text-[9px] text-green-400">↑{gitInfo.ahead}</span> : null}
           {gitInfo?.behind ? <span className="text-[9px] text-yellow-400">↓{gitInfo.behind}</span> : null}
@@ -645,11 +670,51 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
 
       {/* Code content area */}
       {projectTab === 'code' && <div className="flex-1 flex min-h-0 overflow-hidden">
-        {/* File tree */}
-        <div style={{ width: sidebarWidth }} className="overflow-y-auto p-1 shrink-0">
-          {fileTree.map((node: any) => (
-            <FileTreeNode key={node.path} node={node} depth={0} selected={selectedFile} onSelect={openFile} />
-          ))}
+        {/* File tree + search */}
+        <div style={{ width: sidebarWidth }} className="flex flex-col shrink-0">
+          {/* Search input */}
+          <div className="p-1 border-b border-[var(--border)]">
+            <input
+              value={codeSearch}
+              onChange={e => setCodeSearch(e.target.value)}
+              onKeyDown={async e => {
+                if (e.key === 'Enter' && codeSearch.trim()) {
+                  setCodeSearching(true);
+                  try {
+                    const res = await fetch(`/api/code?dir=${encodeURIComponent(projectPath)}&search=${encodeURIComponent(codeSearch.trim())}`);
+                    const data = await res.json();
+                    setCodeSearchResults(data.matches || []);
+                  } catch { setCodeSearchResults([]); }
+                  setCodeSearching(false);
+                }
+                if (e.key === 'Escape') { setCodeSearch(''); setCodeSearchResults([]); }
+              }}
+              placeholder="Search code... (Enter)"
+              className="w-full text-[10px] bg-[var(--bg-tertiary)] border border-[var(--border)] rounded px-2 py-1 text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)] placeholder-[var(--text-secondary)]"
+            />
+          </div>
+          {/* Search results */}
+          {codeSearchResults.length > 0 && (
+            <div className="overflow-y-auto border-b border-[var(--border)] max-h-60">
+              <div className="px-2 py-0.5 text-[8px] text-[var(--text-secondary)] bg-[var(--bg-tertiary)] sticky top-0 flex items-center justify-between">
+                <span>{codeSearchResults.length} results for "{codeSearch}"</span>
+                <button onClick={() => { setCodeSearch(''); setCodeSearchResults([]); }} className="text-[var(--text-secondary)] hover:text-[var(--text-primary)]">✕</button>
+              </div>
+              {codeSearchResults.map((r, i) => (
+                <div key={i} onClick={() => openFile(r.file)} className="px-2 py-0.5 cursor-pointer hover:bg-[var(--bg-tertiary)] border-b border-[var(--border)]/30">
+                  <div className="text-[9px] text-[var(--accent)] truncate">{r.file}:{r.line}</div>
+                  <div className="text-[8px] text-[var(--text-secondary)] font-mono truncate">{r.content}</div>
+                </div>
+              ))}
+            </div>
+          )}
+          {codeSearching && <div className="px-2 py-1 text-[9px] text-[var(--text-secondary)]">Searching...</div>}
+          {/* File tree */}
+          <div className="overflow-y-auto flex-1 p-1">
+            {fileTree.map((node: any) => (
+              <FileTreeNode key={node.path} node={node} depth={0} selected={selectedFile} onSelect={openFile} />
+            ))}
+          </div>
         </div>
 
         {/* Sidebar resize handle */}
@@ -1299,36 +1364,58 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
         <div className="border-t border-[var(--border)] shrink-0">
           {/* Changes list */}
           {gitInfo.changes.length > 0 && (
-            <div className="max-h-32 overflow-y-auto border-b border-[var(--border)]">
-              <div className="px-3 py-1 text-[9px] text-[var(--text-secondary)] bg-[var(--bg-tertiary)] sticky top-0">
-                {gitInfo.changes.length} changes
-              </div>
-              {gitInfo.changes.map(g => (
-                <div key={g.path} className="flex items-center px-3 py-0.5 text-xs hover:bg-[var(--bg-tertiary)] group">
-                  <span className={`text-[10px] font-mono w-4 shrink-0 ${
-                    g.status.includes('M') ? 'text-yellow-500' :
-                    g.status.includes('?') ? 'text-green-500' :
-                    g.status.includes('D') ? 'text-red-500' : 'text-[var(--text-secondary)]'
-                  }`}>
-                    {g.status.includes('?') ? '+' : g.status[0]}
-                  </span>
-                  <button
-                    onClick={() => openDiff(g.path)}
-                    className={`truncate flex-1 text-left ml-1 ${diffFile === g.path ? 'text-[var(--accent)]' : 'text-[var(--text-secondary)] hover:text-[var(--text-primary)]'}`}
-                    title="View diff"
-                  >
-                    {g.path}
-                  </button>
-                  <button
-                    onClick={() => openFile(g.path)}
-                    className="text-[8px] text-[var(--text-secondary)] hover:text-[var(--accent)] opacity-0 group-hover:opacity-100 shrink-0 ml-1"
-                    title="Open source file"
-                  >
-                    src
-                  </button>
+            <>
+              <div className="overflow-y-auto border-b border-[var(--border)]" style={{ height: changesHeight }}>
+                <div className="px-3 py-1 text-[9px] text-[var(--text-secondary)] bg-[var(--bg-tertiary)] sticky top-0 flex items-center gap-1 cursor-pointer z-10" onClick={() => {
+                  setChangesExpanded(!changesExpanded);
+                  setChangesHeight(changesExpanded ? 120 : Math.min(400, gitInfo.changes.length * 22 + 24));
+                }}>
+                  <span>{changesExpanded ? '▼' : '▶'}</span>
+                  <span>{gitInfo.changes.length} changes</span>
+                  <button onClick={(e) => { e.stopPropagation(); fetchGitInfo(); }} className="ml-auto text-[8px] hover:text-[var(--accent)]" title="Refresh">↻</button>
                 </div>
-              ))}
-            </div>
+                {gitInfo.changes.map(g => (
+                  <div key={g.path} className="flex items-center px-3 py-0.5 text-xs hover:bg-[var(--bg-tertiary)] group">
+                    <span className={`text-[10px] font-mono w-4 shrink-0 ${
+                      g.status.includes('M') ? 'text-yellow-500' :
+                      g.status.includes('?') ? 'text-green-500' :
+                      g.status.includes('D') ? 'text-red-500' : 'text-[var(--text-secondary)]'
+                    }`}>
+                      {g.status.includes('?') ? '+' : g.status[0]}
+                    </span>
+                    <button
+                      onClick={() => openDiff(g.path)}
+                      className={`truncate flex-1 text-left ml-1 ${diffFile === g.path ? 'text-[var(--accent)]' : 'text-[var(--text-secondary)] hover:text-[var(--text-primary)]'}`}
+                      title="View diff"
+                    >
+                      {g.path}
+                    </button>
+                    <button
+                      onClick={() => openFile(g.path)}
+                      className="text-[8px] text-[var(--text-secondary)] hover:text-[var(--accent)] opacity-0 group-hover:opacity-100 shrink-0 ml-1"
+                      title="Open source file"
+                    >
+                      src
+                    </button>
+                  </div>
+                ))}
+              </div>
+              {/* Drag handle to resize changes list */}
+              <div
+                className="h-1 cursor-ns-resize hover:bg-[var(--accent)]/30 border-b border-[var(--border)]"
+                onMouseDown={(e) => {
+                  e.preventDefault();
+                  changesResizeRef.current = { startY: e.clientY, origH: changesHeight };
+                  const onMove = (ev: MouseEvent) => {
+                    if (!changesResizeRef.current) return;
+                    setChangesHeight(Math.max(60, Math.min(600, changesResizeRef.current.origH + ev.clientY - changesResizeRef.current.startY)));
+                  };
+                  const onUp = () => { changesResizeRef.current = null; window.removeEventListener('mousemove', onMove); window.removeEventListener('mouseup', onUp); };
+                  window.addEventListener('mousemove', onMove);
+                  window.addEventListener('mouseup', onUp);
+                }}
+              />
+            </>
           )}
 
           {/* Git actions */}

package/components/WorkspaceView.tsx

@@ -2212,6 +2212,9 @@ interface AgentNodeData {
   onShowInbox: () => void;
   onOpenTerminal: () => void;
   onSwitchSession: () => void;
+  onMarkIdle?: () => void;
+  onMarkDone?: (notify: boolean) => void;
+  onMarkFailed?: (notify: boolean) => void;
   inboxPending?: number;
   inboxFailed?: number;
   [key: string]: unknown;
@@ -2325,8 +2328,14 @@ function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
       {/* Actions */}
       <div className="flex items-center gap-1 px-2 py-1.5" style={{ borderTop: `1px solid ${c.border}15` }}>
         {taskStatus === 'running' && (
-          <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onStop(); }}
-            className="text-[9px] px-1.5 py-0.5 rounded bg-red-600/20 text-red-400 hover:bg-red-600/30">■ Stop</button>
+          <>
+            <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); data.onMarkIdle?.(); }}
+              className="text-[9px] px-1 py-0.5 rounded bg-gray-600/20 text-gray-400 hover:bg-gray-600/30" title="Silent stop — no notifications">■</button>
+            <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); data.onMarkDone?.(true); }}
+              className="text-[9px] px-1 py-0.5 rounded bg-green-600/20 text-green-400 hover:bg-green-600/30" title="Mark done + notify">✓</button>
+            <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); data.onMarkFailed?.(true); }}
+              className="text-[9px] px-1 py-0.5 rounded bg-red-600/20 text-red-400 hover:bg-red-600/30" title="Mark failed + notify">✕</button>
+          </>
         )}
         {/* Message button — send instructions to agent */}
         {smithStatus === 'active' && taskStatus !== 'running' && (
@@ -2469,6 +2478,9 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
             },
             onPause: () => wsApi(workspaceId!, 'pause', { agentId: agent.id }),
             onStop: () => wsApi(workspaceId!, 'stop', { agentId: agent.id }),
+            onMarkIdle: () => wsApi(workspaceId!, 'mark_done', { agentId: agent.id, notify: false }),
+            onMarkDone: (notify: boolean) => wsApi(workspaceId!, 'mark_done', { agentId: agent.id, notify }),
+            onMarkFailed: (notify: boolean) => wsApi(workspaceId!, 'mark_failed', { agentId: agent.id, notify }),
             onRetry: () => wsApi(workspaceId!, 'retry', { agentId: agent.id }),
             onEdit: () => setModal({ mode: 'edit', initial: agent, editId: agent.id }),
             onRemove: () => {

package/lib/workspace/orchestrator.ts

@@ -1103,6 +1103,31 @@ export class WorkspaceOrchestrator extends EventEmitter {
     console.log('[workspace] Daemon stopped');
   }
 
+  // ─── Hook-based completion ─────────────────────────────
+
+  /** Called by Claude Code Stop hook via HTTP — agent finished a turn */
+  handleHookDone(agentId: string): void {
+    const entry = this.agents.get(agentId);
+    if (!entry) return;
+    if (!this.daemonActive) return;
+
+    // Only transition running → done (ignore if already idle/done)
+    if (entry.state.taskStatus !== 'running') {
+      console.log(`[hook] ${entry.config.label}: Stop hook fired but task=${entry.state.taskStatus}, ignoring`);
+      return;
+    }
+
+    console.log(`[hook] ${entry.config.label}: Stop hook → done`);
+    entry.state.taskStatus = 'done';
+    entry.state.completedAt = Date.now();
+    this.emit('event', { type: 'task_status', agentId, taskStatus: 'done' } as any);
+    this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'hook_done', content: 'Claude Code Stop hook: turn completed', timestamp: new Date().toISOString() } } as any);
+    this.handleAgentDone(agentId, entry, 'Stop hook');
+    this.sessionMonitor?.resetState(agentId);
+    this.saveNow();
+    this.emitAgentsChanged();
+  }
+
   // ─── Session File Monitor ──────────────────────────────
 
   private async startSessionMonitors(): Promise<void> {
@@ -1502,9 +1527,63 @@ export class WorkspaceOrchestrator extends EventEmitter {
   }
 
   /** Stop a running agent */
+  /** Mark agent task as done (user manually confirms completion) */
+  markAgentDone(agentId: string, notify: boolean): void {
+    const entry = this.agents.get(agentId);
+    if (!entry) return;
+
+    // Mark running inbox messages as done
+    const runningMsgs = this.bus.getLog().filter(m => m.to === agentId && m.status === 'running' && m.type !== 'ack');
+    for (const m of runningMsgs) {
+      m.status = 'done' as any;
+      this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'done' } as any);
+    }
+
+    entry.state.taskStatus = notify ? 'done' : 'idle';
+    entry.state.completedAt = Date.now();
+    this.emit('event', { type: 'task_status', agentId, taskStatus: entry.state.taskStatus } as any);
+    if (notify) {
+      this.handleAgentDone(agentId, entry, 'Manually marked done');
+    }
+    this.sessionMonitor?.resetState(agentId);
+    this.saveNow();
+    this.emitAgentsChanged();
+    console.log(`[workspace] ${entry.config.label}: manually marked ${notify ? 'done' : 'idle'} (${runningMsgs.length} messages completed)`);
+  }
+
+  /** Mark agent task as failed (user manually marks failure) */
+  markAgentFailed(agentId: string, notify: boolean): void {
+    const entry = this.agents.get(agentId);
+    if (!entry) return;
+
+    // Mark running inbox messages as failed
+    const runningMsgs = this.bus.getLog().filter(m => m.to === agentId && m.status === 'running' && m.type !== 'ack');
+    for (const m of runningMsgs) {
+      m.status = 'failed' as any;
+      this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'failed' } as any);
+    }
+
+    entry.state.taskStatus = 'failed';
+    entry.state.error = 'Manually marked as failed';
+    this.emit('event', { type: 'task_status', agentId, taskStatus: 'failed' } as any);
+    if (notify) {
+      this.bus.notifyTaskComplete(agentId, [], 'Task failed');
+    }
+    this.sessionMonitor?.resetState(agentId);
+    this.saveNow();
+    this.emitAgentsChanged();
+    console.log(`[workspace] ${entry.config.label}: manually marked failed (${runningMsgs.length} messages failed)`);
+  }
+
+  /** Legacy stop — for headless mode */
   stopAgent(agentId: string): void {
     const entry = this.agents.get(agentId);
-    entry?.worker?.stop();
+    if (!entry) return;
+    if (entry.config.persistentSession) {
+      this.markAgentDone(agentId, false);
+    } else {
+      entry.worker?.stop();
+    }
   }
 
   /** Retry a failed agent from its last checkpoint */
@@ -1967,12 +2046,38 @@ export class WorkspaceOrchestrator extends EventEmitter {
       }
     }
 
+    // Write agent context file for hooks to read (workDir/.forge/agent-context.json)
+    try {
+      const forgeDir = join(workDir, '.forge');
+      const { mkdirSync: mkdirS } = require('node:fs');
+      mkdirS(forgeDir, { recursive: true });
+      const ctxPath = join(forgeDir, 'agent-context.json');
+      writeFileSync(ctxPath, JSON.stringify({
+        workspaceId: this.workspaceId,
+        agentId: config.id,
+        agentLabel: config.label,
+        forgePort: Number(process.env.PORT) || 8403,
+      }, null, 2));
+      console.log(`[daemon] ${config.label}: wrote agent-context.json to ${ctxPath}`);
+    } catch (err: any) {
+      console.error(`[daemon] ${config.label}: failed to write agent-context.json: ${err.message}`);
+    }
+
     // Check if tmux session already exists
     let sessionAlreadyExists = false;
     try {
       execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`, { timeout: 3000 });
       sessionAlreadyExists = true;
       console.log(`[daemon] ${config.label}: persistent session already exists (${sessionName})`);
+      // Ensure FORGE env vars are set in the tmux session environment
+      // (for hooks that read them — set-environment makes them available to new processes in this session)
+      try {
+        execSync(`tmux set-environment -t "${sessionName}" FORGE_WORKSPACE_ID "${this.workspaceId}"`, { timeout: 3000 });
+        execSync(`tmux set-environment -t "${sessionName}" FORGE_AGENT_ID "${config.id}"`, { timeout: 3000 });
+        execSync(`tmux set-environment -t "${sessionName}" FORGE_PORT "${Number(process.env.PORT) || 8403}"`, { timeout: 3000 });
+      } catch {}
+      // Note: set-environment affects new processes in this tmux session.
+      // Claude Code hooks run as child processes of the shell, which inherits tmux environment.
     } catch {
       // Create new tmux session and start the CLI agent
       try {

package/lib/workspace/session-monitor.ts

@@ -27,9 +27,9 @@ export interface SessionMonitorEvent {
   detail?: string; // e.g., result summary
 }
 
-const POLL_INTERVAL = 1000;    // check every 1s (need to catch short executions)
-const IDLE_THRESHOLD = 10000;  // 10s of no file change → check for done
-const STABLE_THRESHOLD = 20000; // 20s of no change → force done
+const POLL_INTERVAL = 3000;      // check every 3s
+const IDLE_THRESHOLD = 3540000;  // 59min of no file change → check for result entry
+const STABLE_THRESHOLD = 3600000; // 60min of no change → force done (fallback if hook missed)
 
 export class SessionFileMonitor extends EventEmitter {
   private timers = new Map<string, NodeJS.Timeout>();
@@ -86,6 +86,20 @@ export class SessionFileMonitor extends EventEmitter {
     return this.currentState.get(agentId) || 'idle';
   }
 
+  /**
+   * Reset monitor state to idle and pause detection briefly.
+   * Call when orchestrator manually changes taskStatus (button/hook).
+   * Suppresses detection for 10s to avoid immediately flipping back.
+   */
+  private suppressUntil = new Map<string, number>();
+
+  resetState(agentId: string): void {
+    this.currentState.set(agentId, 'idle');
+    this.lastStableTime.set(agentId, Date.now());
+    // Suppress state changes for 10s after manual reset
+    this.suppressUntil.set(agentId, Date.now() + 10_000);
+  }
+
   /**
    * Resolve session file path for a project + session ID.
    */
@@ -202,6 +216,12 @@ export class SessionFileMonitor extends EventEmitter {
     const prev = this.currentState.get(agentId);
     if (prev === state) return;
 
+    // Suppress state changes if recently reset by orchestrator
+    const suppressed = this.suppressUntil.get(agentId);
+    if (suppressed && Date.now() < suppressed) {
+      return;
+    }
+
     this.currentState.set(agentId, state);
     const event: SessionMonitorEvent = { agentId, state, sessionFile: filePath, detail };
     this.emit('stateChange', event);

package/lib/workspace/skill-installer.ts

@@ -63,6 +63,9 @@ export function installForgeSkills(
     ensureForgePermissions(projectClaudeDir);
   }
 
+  // Install Stop hook in user-level settings (for agent completion detection)
+  installForgeStopHook(forgePort);
+
   return { installed };
 }
 
@@ -162,6 +165,90 @@ export function applyProfileToProject(
   }
 }
 
+const FORGE_HOOK_MARKER = '# forge-stop-hook';
+
+/**
+ * Install a Stop hook in user-level ~/.claude/settings.json.
+ * When Claude Code finishes a turn, the hook notifies Forge via HTTP.
+ * Preserves existing user hooks. Creates backup before modifying.
+ */
+function installForgeStopHook(forgePort: number): void {
+  const settingsFile = join(homedir(), '.claude', 'settings.json');
+  const now = new Date();
+  const dateStr = `${now.getFullYear()}${String(now.getMonth()+1).padStart(2,'0')}${String(now.getDate()).padStart(2,'0')}-${String(now.getHours()).padStart(2,'0')}${String(now.getMinutes()).padStart(2,'0')}`;
+  const backupFile = join(homedir(), '.claude', `settings.json.forge-backup-${dateStr}`);
+  const daemonPort = forgePort + 2; // 8403 → 8405
+
+  // Hook reads agent context from .forge/agent-context.json in the project dir.
+  // This file is written by ensurePersistentSession for each agent's workDir.
+  // Falls back to env vars if file doesn't exist.
+  const hookCommand = `${FORGE_HOOK_MARKER}\nCTX_FILE="$(pwd)/.forge/agent-context.json"; if [ -f "$CTX_FILE" ]; then WS_ID=$(python3 -c "import json;print(json.load(open('$CTX_FILE')).get('workspaceId',''))" 2>/dev/null); AG_ID=$(python3 -c "import json;print(json.load(open('$CTX_FILE')).get('agentId',''))" 2>/dev/null); elif [ -n "$FORGE_WORKSPACE_ID" ]; then WS_ID="$FORGE_WORKSPACE_ID"; AG_ID="$FORGE_AGENT_ID"; fi; if [ -n "$WS_ID" ] && [ -n "$AG_ID" ]; then curl -s -X POST "http://localhost:${daemonPort}/workspace/$WS_ID/agents" -H "Content-Type: application/json" -d "{\\"action\\":\\"agent_done\\",\\"agentId\\":\\"$AG_ID\\"}" > /dev/null 2>&1 & fi`;
+
+  try {
+    let settings: any = {};
+    if (existsSync(settingsFile)) {
+      const raw = readFileSync(settingsFile, 'utf-8');
+      settings = JSON.parse(raw);
+
+      // Check if hook already installed
+      // Remove old forge hook if present (will re-add with latest version)
+      if (settings.hooks?.Stop) {
+        settings.hooks.Stop = settings.hooks.Stop.filter((h: any) => {
+          if (h.command?.includes(FORGE_HOOK_MARKER) || h.command?.includes('agent_done')) return false;
+          if (h.hooks?.some((sub: any) => sub.command?.includes(FORGE_HOOK_MARKER) || sub.command?.includes('agent_done'))) return false;
+          return true;
+        });
+      }
+
+      // Backup before modifying
+      writeFileSync(backupFile, raw, 'utf-8');
+    }
+
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.Stop) settings.hooks.Stop = [];
+
+    // Add forge hook (Claude Code hooks schema: matcher + hooks array)
+    settings.hooks.Stop.push({
+      matcher: '',
+      hooks: [{
+        type: 'command',
+        command: hookCommand,
+        timeout: 5000,
+      }],
+    });
+
+    mkdirSync(join(homedir(), '.claude'), { recursive: true });
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    console.log('[skills] Installed Forge Stop hook in ~/.claude/settings.json');
+  } catch (err: any) {
+    console.error('[skills] Failed to install Stop hook:', err.message);
+  }
+}
+
+/**
+ * Remove Forge Stop hook from user-level settings (cleanup).
+ */
+export function removeForgeStopHook(): void {
+  const settingsFile = join(homedir(), '.claude', 'settings.json');
+  try {
+    if (!existsSync(settingsFile)) return;
+    const settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    if (!settings.hooks?.Stop) return;
+
+    settings.hooks.Stop = settings.hooks.Stop.filter((h: any) => {
+      // Remove entries matching either old flat format or new nested format
+      if (h.command?.includes(FORGE_HOOK_MARKER) || h.command?.includes('agent_done')) return false;
+      if (h.hooks?.some((sub: any) => sub.command?.includes(FORGE_HOOK_MARKER) || sub.command?.includes('agent_done'))) return false;
+      return true;
+    });
+    if (settings.hooks.Stop.length === 0) delete settings.hooks.Stop;
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    console.log('[skills] Removed Forge Stop hook from ~/.claude/settings.json');
+  } catch {}
+}
+
 /**
  * Check if forge skills are already installed for this agent.
  */

package/lib/workspace-standalone.ts

@@ -190,6 +190,12 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
           return jsonError(res, err.message);
         }
       }
+      case 'agent_done': {
+        // Called by Claude Code Stop hook — agent finished a turn
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.handleHookDone(agentId);
+        return json(res, { ok: true });
+      }
       case 'run': {
         if (!agentId) return jsonError(res, 'agentId required');
         if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before running agents');
@@ -226,6 +232,16 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
         orch.stopAgent(agentId);
         return json(res, { ok: true });
       }
+      case 'mark_done': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.markAgentDone(agentId, body.notify !== false);
+        return json(res, { ok: true });
+      }
+      case 'mark_failed': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.markAgentFailed(agentId, body.notify !== false);
+        return json(res, { ok: true });
+      }
       case 'retry': {
         if (!agentId) return jsonError(res, 'agentId required');
         if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before retrying agents');

package/package.json

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