@aion0/forge 0.5.5 → 0.5.7

package/RELEASE_NOTES.md

@@ -1,18 +1,11 @@
-# Forge v0.5.5
+# Forge v0.5.7
 
-Released: 2026-03-28
+Released: 2026-03-29
 
-## Changes since v0.5.4
-
-### Features
-- feat: API token auth for Help AI — password-based, 24h validity
-- feat: enhanced agent role presets with detailed prompts + UI Designer
-
-### Bug Fixes
-- fix: whitelist all /api/workspace routes in auth middleware
+## Changes since v0.5.6
 
 ### Other
-- revert: restore auth middleware for /api/workspace security
+- v0.5.6: watch enhancements, skills UI, dev mode fixes
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.4...v0.5.5
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.6...v0.5.7

package/components/SkillsPanel.tsx

@@ -378,6 +378,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
             ))}
           </div>
         </div>
+        <span className="text-[8px] px-1.5 py-0.5 rounded bg-blue-500/15 text-blue-400">Claude Code</span>
         <button
           onClick={sync}
           disabled={syncing}

package/components/WorkspaceView.tsx

@@ -22,7 +22,7 @@ interface AgentConfig {
   outputs: string[];
   steps: { id: string; label: string; prompt: string }[];
   requiresApproval?: boolean;
-  watch?: { enabled: boolean; interval: number; targets: any[]; action?: 'log' | 'analyze' | 'approve'; prompt?: string };
+  watch?: { enabled: boolean; interval: number; targets: any[]; action?: 'log' | 'analyze' | 'approve' | 'send_message'; prompt?: string; sendTo?: string };
 }
 
 interface AgentState {
@@ -322,6 +322,55 @@ function useWorkspaceStream(workspaceId: string | null, onEvent?: (event: any) =
   return { agents, states, logPreview, busLog, setAgents, daemonActive, setDaemonActive };
 }
 
+// ─── Session Target Selector (for Watch) ─────────────────
+
+function SessionTargetSelector({ target, agents, projectPath, onChange }: {
+  target: { type: string; path?: string; pattern?: string; cmd?: string };
+  agents: AgentConfig[];
+  projectPath?: string;
+  onChange: (updated: typeof target) => void;
+}) {
+  const [sessions, setSessions] = useState<{ id: string; modified: string; label: string }[]>([]);
+
+  // Load sessions when agent changes
+  useEffect(() => {
+    if (!projectPath) return;
+    const pName = (projectPath || '').replace(/\/+$/, '').split('/').pop() || '';
+    fetch(`/api/claude-sessions/${encodeURIComponent(pName)}`)
+      .then(r => r.json())
+      .then(data => {
+        if (Array.isArray(data)) {
+          setSessions(data.map((s: any, i: number) => ({
+            id: s.sessionId || s.id || '',
+            modified: s.modified || '',
+            label: i === 0 ? `${(s.sessionId || '').slice(0, 8)} (latest)` : (s.sessionId || '').slice(0, 8),
+          })));
+        }
+      })
+      .catch(() => {});
+  }, [projectPath]);
+
+  return (
+    <>
+      <select value={target.path || ''} onChange={e => onChange({ ...target, path: e.target.value, cmd: '' })}
+        className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white w-24">
+        <option value="">Any agent</option>
+        {agents.map(a => <option key={a.id} value={a.id}>{a.icon} {a.label}</option>)}
+      </select>
+      <select value={target.cmd || ''} onChange={e => onChange({ ...target, cmd: e.target.value })}
+        className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white w-28">
+        <option value="">Latest session</option>
+        {sessions.map(s => (
+          <option key={s.id} value={s.id}>{s.label}{s.modified ? ` · ${new Date(s.modified).toLocaleDateString()}` : ''}</option>
+        ))}
+      </select>
+      <input value={target.pattern || ''} onChange={e => onChange({ ...target, pattern: e.target.value })}
+        placeholder="regex (optional)"
+        className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white w-24" />
+    </>
+  );
+}
+
 // ─── Agent Config Modal ──────────────────────────────────
 
 function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfirm, onCancel }: {
@@ -358,9 +407,11 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
   const [requiresApproval, setRequiresApproval] = useState(initial.requiresApproval || false);
   const [watchEnabled, setWatchEnabled] = useState(initial.watch?.enabled || false);
   const [watchInterval, setWatchInterval] = useState(String(initial.watch?.interval || 60));
-  const [watchAction, setWatchAction] = useState<'log' | 'analyze' | 'approve'>(initial.watch?.action || 'log');
+  const [watchAction, setWatchAction] = useState<'log' | 'analyze' | 'approve' | 'send_message'>(initial.watch?.action || 'log');
   const [watchPrompt, setWatchPrompt] = useState(initial.watch?.prompt || '');
-  const [watchTargets, setWatchTargets] = useState<{ type: string; path?: string; cmd?: string }[]>(
+  const [watchSendTo, setWatchSendTo] = useState(initial.watch?.sendTo || '');
+  const [watchDebounce, setWatchDebounce] = useState(String(initial.watch?.targets?.[0]?.debounce ?? 10));
+  const [watchTargets, setWatchTargets] = useState<{ type: string; path?: string; cmd?: string; pattern?: string }[]>(
     initial.watch?.targets || []
   );
   const [projectDirs, setProjectDirs] = useState<string[]>([]);
@@ -567,10 +618,15 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
             </div>
             {watchEnabled && (<>
               <div className="flex gap-2">
-                <div className="flex flex-col gap-0.5 flex-1">
-                  <label className="text-[8px] text-gray-600">Interval (seconds)</label>
+                <div className="flex flex-col gap-0.5">
+                  <label className="text-[8px] text-gray-600">Interval (s)</label>
                   <input value={watchInterval} onChange={e => setWatchInterval(e.target.value)} type="number" min="10"
-                    className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff] w-20" />
+                    className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff] w-16" />
+                </div>
+                <div className="flex flex-col gap-0.5">
+                  <label className="text-[8px] text-gray-600">Debounce (s)</label>
+                  <input value={watchDebounce} onChange={e => setWatchDebounce(e.target.value)} type="number" min="0"
+                    className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff] w-16" />
                 </div>
                 <div className="flex flex-col gap-0.5 flex-1">
                   <label className="text-[8px] text-gray-600">On Change</label>
@@ -579,8 +635,21 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                     <option value="log">Log only</option>
                     <option value="analyze">Auto analyze</option>
                     <option value="approve">Require approval</option>
+                    <option value="send_message">Send to agent</option>
                   </select>
                 </div>
+                {watchAction === 'send_message' && (
+                  <div className="flex flex-col gap-0.5 flex-1">
+                    <label className="text-[8px] text-gray-600">Send to</label>
+                    <select value={watchSendTo} onChange={e => setWatchSendTo(e.target.value)}
+                      className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff]">
+                      <option value="">Select agent...</option>
+                      {existingAgents.filter(a => a.id !== initial.id).map(a =>
+                        <option key={a.id} value={a.id}>{a.icon} {a.label}</option>
+                      )}
+                    </select>
+                  </div>
+                )}
               </div>
               <div className="flex flex-col gap-1">
                 <label className="text-[8px] text-gray-600">Targets</label>
@@ -594,6 +663,8 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                       <option value="directory">Directory</option>
                       <option value="git">Git</option>
                       <option value="agent_output">Agent Output</option>
+                      <option value="agent_log">Agent Log</option>
+                      <option value="session">Session Output</option>
                       <option value="command">Command</option>
                     </select>
                     {t.type === 'directory' && (
@@ -618,6 +689,36 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                         )}
                       </select>
                     )}
+                    {t.type === 'agent_log' && (<>
+                      <select value={t.path || ''} onChange={e => {
+                        const next = [...watchTargets];
+                        next[i] = { ...t, path: e.target.value };
+                        setWatchTargets(next);
+                      }} className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white flex-1">
+                        <option value="">Select agent...</option>
+                        {existingAgents.filter(a => a.id !== initial.id).map(a =>
+                          <option key={a.id} value={a.id}>{a.icon} {a.label}</option>
+                        )}
+                      </select>
+                      <input value={t.pattern || ''} onChange={e => {
+                        const next = [...watchTargets];
+                        next[i] = { ...t, pattern: e.target.value };
+                        setWatchTargets(next);
+                      }} placeholder="keyword (optional)"
+                        className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white w-24" />
+                    </>)}
+                    {t.type === 'session' && (
+                      <SessionTargetSelector
+                        target={t}
+                        agents={existingAgents.filter(a => a.id !== initial.id && (!a.agentId || a.agentId === 'claude'))}
+                        projectPath={projectPath}
+                        onChange={(updated) => {
+                          const next = [...watchTargets];
+                          next[i] = updated;
+                          setWatchTargets(next);
+                        }}
+                      />
+                    )}
                     {t.type === 'command' && (
                       <input value={t.cmd || ''} onChange={e => {
                         const next = [...watchTargets];
@@ -641,6 +742,14 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                     className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff]" />
                 </div>
               )}
+              {watchAction === 'send_message' && (
+                <div className="flex flex-col gap-0.5">
+                  <label className="text-[8px] text-gray-600">Message context (sent with detected changes)</label>
+                  <input value={watchPrompt} onChange={e => setWatchPrompt(e.target.value)}
+                    placeholder="Review the following changes and report issues..."
+                    className="text-xs bg-[#161b22] border border-[#30363d] rounded px-2 py-1 text-white focus:outline-none focus:border-[#58a6ff]" />
+                </div>
+              )}
             </>)}
           </div>
         </div>
@@ -658,9 +767,10 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
               watch: watchEnabled && watchTargets.length > 0 ? {
                 enabled: true,
                 interval: Math.max(10, parseInt(watchInterval) || 60),
-                targets: watchTargets,
+                targets: watchTargets.map(t => ({ ...t, debounce: parseInt(watchDebounce) || 10 })),
                 action: watchAction,
                 prompt: watchPrompt || undefined,
+                sendTo: watchSendTo || undefined,
               } : undefined,
             } as any);
           }} className="text-xs px-3 py-1.5 rounded bg-[#238636] text-white hover:bg-[#2ea043] disabled:opacity-40">
@@ -730,21 +840,47 @@ function RunPromptDialog({ agentLabel, onRun, onCancel }: {
 
 // ─── Log Panel (overlay) ─────────────────────────────────
 
-/** Format log content: handle \n, truncate long text, detect JSON */
-function LogContent({ content }: { content: string }) {
+/** Format log content: extract readable text from JSON, format nicely */
+function LogContent({ content, subtype }: { content: string; subtype?: string }) {
   if (!content) return null;
-  const MAX_LINES = 30;
-  const MAX_CHARS = 3000;
+  const MAX_LINES = 40;
+  const MAX_CHARS = 4000;
 
   let text = content;
 
-  // Try to parse JSON and extract readable content
+  // Try to parse JSON and extract human-readable content
   if (text.startsWith('{') || text.startsWith('[')) {
     try {
       const parsed = JSON.parse(text);
-      // Tool result with content field
-      if (parsed.content) text = String(parsed.content);
-      else text = JSON.stringify(parsed, null, 2);
+      if (typeof parsed === 'string') {
+        text = parsed;
+      } else if (parsed.content) {
+        text = String(parsed.content);
+      } else if (parsed.text) {
+        text = String(parsed.text);
+      } else if (parsed.result) {
+        text = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result, null, 2);
+      } else if (parsed.message?.content) {
+        // Claude stream-json format
+        const blocks = Array.isArray(parsed.message.content) ? parsed.message.content : [parsed.message.content];
+        text = blocks.map((b: any) => {
+          if (typeof b === 'string') return b;
+          if (b.type === 'text') return b.text;
+          if (b.type === 'tool_use') return `🔧 ${b.name}(${typeof b.input === 'string' ? b.input : JSON.stringify(b.input).slice(0, 100)})`;
+          if (b.type === 'tool_result') return `→ ${typeof b.content === 'string' ? b.content.slice(0, 200) : JSON.stringify(b.content).slice(0, 200)}`;
+          return JSON.stringify(b).slice(0, 100);
+        }).join('\n');
+      } else if (Array.isArray(parsed)) {
+        text = parsed.map((item: any) => typeof item === 'string' ? item : JSON.stringify(item)).join('\n');
+      } else {
+        // Generic object — show key fields only
+        const keys = Object.keys(parsed);
+        if (keys.length <= 5) {
+          text = keys.map(k => `${k}: ${typeof parsed[k] === 'string' ? parsed[k] : JSON.stringify(parsed[k]).slice(0, 80)}`).join('\n');
+        } else {
+          text = JSON.stringify(parsed, null, 2);
+        }
+      }
     } catch {
       // Not valid JSON, keep as-is
     }
@@ -843,8 +979,14 @@ function LogPanel({ agentId, agentLabel, workspaceId, onClose }: {
                 ) : (
                   <>
                     <span className="text-[8px] text-gray-600 shrink-0 w-16">{entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : ''}</span>
-                    {entry.tool && <span className="text-yellow-500 shrink-0">[{entry.tool}]</span>}
-                    <LogContent content={entry.content} />
+                    {entry.subtype === 'tool_use' && <span className="text-yellow-500 shrink-0">🔧 {entry.tool || 'tool'}</span>}
+                    {entry.subtype === 'tool_result' && <span className="text-cyan-500 shrink-0">→</span>}
+                    {entry.subtype === 'init' && <span className="text-blue-400 shrink-0">⚡</span>}
+                    {entry.subtype === 'daemon' && <span className="text-purple-400 shrink-0">👁</span>}
+                    {entry.subtype === 'watch_detected' && <span className="text-orange-400 shrink-0">🔍</span>}
+                    {entry.subtype === 'error' && <span className="text-red-400 shrink-0">❌</span>}
+                    {!entry.tool && entry.subtype === 'text' && <span className="text-gray-500 shrink-0">💬</span>}
+                    <LogContent content={entry.content} subtype={entry.subtype} />
                   </>
                 )}
               </div>

package/lib/workspace/orchestrator.ts

@@ -1090,6 +1090,37 @@ export class WorkspaceOrchestrator extends EventEmitter {
       this.emit('event', { type: 'bus_message_status', messageId: msg.id, status: 'pending_approval' } as any);
       console.log(`[watch] ${entry.config.label}: changes detected, awaiting approval`);
     }
+
+    if (action === 'send_message') {
+      const targetId = entry.config.watch?.sendTo;
+      if (!targetId) {
+        console.log(`[watch] ${entry.config.label}: send_message but no sendTo configured`);
+        return;
+      }
+      const targetEntry = this.agents.get(targetId);
+      if (!targetEntry) {
+        console.log(`[watch] ${entry.config.label}: sendTo agent ${targetId} not found`);
+        return;
+      }
+
+      // Skip if target already has a pending/running message from this watch
+      const hasPendingFromWatch = this.bus.getLog().some(m =>
+        m.from === agentId && m.to === targetId &&
+        (m.status === 'pending' || m.status === 'running' || m.status === 'pending_approval') &&
+        m.type !== 'ack'
+      );
+      if (hasPendingFromWatch) {
+        console.log(`[watch] ${entry.config.label}: skipping send — target ${targetEntry.config.label} still processing previous message`);
+        return;
+      }
+
+      const prompt = entry.config.watch?.prompt || 'Watch detected changes, please review:';
+      this.bus.send(agentId, targetId, 'notify', {
+        action: 'watch_alert',
+        content: `${prompt}\n\n${summary}`,
+      });
+      console.log(`[watch] ${entry.config.label} → ${targetEntry.config.label}: sent watch alert`);
+    }
   }
 
   /** Check if daemon mode is active */

package/lib/workspace/types.ts

@@ -39,20 +39,23 @@ export interface WorkspaceAgentConfig {
 // ─── Watch Config ─────────────────────────────────────────
 
 export interface WatchTarget {
-  type: 'directory' | 'git' | 'agent_output' | 'command';
-  path?: string;           // directory: relative path; agent_output: agent ID
-  pattern?: string;        // glob for directory, stdout pattern for command
+  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command';
+  path?: string;           // directory: relative path; agent_output/agent_log: agent ID
+  pattern?: string;        // glob for directory, regex/keyword for agent_log, stdout pattern for command
   cmd?: string;            // shell command (type='command' only)
+  contextChars?: number;   // agent_log/session: chars to capture around match (default 500)
+  debounce?: number;       // seconds to wait after match before triggering (default 10)
 }
 
-export type WatchAction = 'log' | 'analyze' | 'approve';
+export type WatchAction = 'log' | 'analyze' | 'approve' | 'send_message';
 
 export interface WatchConfig {
   enabled: boolean;
   interval: number;        // check interval in seconds (default 60)
   targets: WatchTarget[];
-  action: WatchAction;     // log=report only, analyze=auto-execute, approve=pending user approval
+  action: WatchAction;     // log=report only, analyze=auto-execute, approve=pending user approval, send_message=send to target agent
   prompt?: string;         // custom prompt for analyze action (default: "Analyze the following changes...")
+  sendTo?: string;         // send_message: target agent ID
 }
 
 export type AgentBackendType = 'api' | 'cli';

package/lib/workspace/watch-manager.ts

@@ -7,8 +7,9 @@
  */
 
 import { EventEmitter } from 'node:events';
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync, readFileSync, openSync, readSync, fstatSync, closeSync } from 'node:fs';
 import { join, relative } from 'node:path';
+import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import type { WorkspaceAgentConfig, WatchTarget, WatchConfig } from './types';
 import { appendAgentLog } from './persistence';
@@ -19,6 +20,8 @@ interface WatchSnapshot {
   lastCheckTime: number;   // timestamp ms — only files modified after this are "changed"
   gitHash?: string;
   commandOutput?: string;
+  logLineCount?: number;   // last known line count in agent's logs.jsonl
+  sessionFileSize?: number; // last known file size of session JSONL (bytes)
 }
 
 interface WatchChange {
@@ -132,11 +135,186 @@ function detectCommandChanges(projectPath: string, target: WatchTarget, prevOutp
   }
 }
 
+function detectAgentLogChanges(workspaceId: string, targetAgentId: string, pattern: string | undefined, prevLineCount: number, contextChars = 500): { changes: WatchChange | null; lineCount: number } {
+  const logFile = join(homedir(), '.forge', 'workspaces', workspaceId, 'agents', targetAgentId, 'logs.jsonl');
+  if (!existsSync(logFile)) return { changes: null, lineCount: 0 };
+
+  try {
+    const lines = readFileSync(logFile, 'utf-8').split('\n').filter(Boolean);
+    const currentCount = lines.length;
+    if (currentCount <= prevLineCount) return { changes: null, lineCount: currentCount };
+
+    // Get new lines since last check
+    const newLines = lines.slice(prevLineCount);
+    const newEntries: string[] = [];
+
+    // Build matcher: try regex first, fallback to case-insensitive includes
+    let matcher: ((text: string) => boolean) | null = null;
+    if (pattern) {
+      try {
+        const re = new RegExp(pattern, 'i');
+        matcher = (text: string) => re.test(text);
+      } catch {
+        const lower = pattern.toLowerCase();
+        matcher = (text: string) => text.toLowerCase().includes(lower);
+      }
+    }
+
+    // Extract content around match (contextChars before + after match point)
+    const extractContext = (text: string): string => {
+      if (!pattern || text.length <= contextChars) return text.slice(0, contextChars);
+      // Find match position for context window
+      let matchIdx = 0;
+      try {
+        const re = new RegExp(pattern, 'i');
+        const m = re.exec(text);
+        if (m) matchIdx = m.index;
+      } catch {
+        matchIdx = text.toLowerCase().indexOf(pattern.toLowerCase());
+        if (matchIdx === -1) matchIdx = 0;
+      }
+      const half = Math.floor(contextChars / 2);
+      const start = Math.max(0, matchIdx - half);
+      const end = Math.min(text.length, start + contextChars);
+      return (start > 0 ? '...' : '') + text.slice(start, end) + (end < text.length ? '...' : '');
+    };
+
+    for (const line of newLines) {
+      try {
+        const entry = JSON.parse(line);
+        const content = entry.content || '';
+        if (matcher && !matcher(content)) continue;
+        newEntries.push(extractContext(content));
+      } catch {
+        if (matcher && !matcher(line)) continue;
+        newEntries.push(extractContext(line));
+      }
+    }
+
+    if (newEntries.length === 0) return { changes: null, lineCount: currentCount };
+
+    return {
+      changes: {
+        targetType: 'agent_log',
+        description: `${newEntries.length} new log entries${pattern ? ` matching "${pattern}"` : ''}`,
+        files: newEntries.slice(0, 10),
+      },
+      lineCount: currentCount,
+    };
+  } catch {
+    return { changes: null, lineCount: prevLineCount };
+  }
+}
+
+function detectSessionChanges(projectPath: string, pattern: string | undefined, prevLineCount: number, contextChars = 500, sessionId?: string): { changes: WatchChange | null; lineCount: number } {
+  // Find session file for this project
+  const claudeHome = join(homedir(), '.claude', 'projects');
+  const encoded = projectPath.replace(/\//g, '-');
+  const sessionDir = join(claudeHome, encoded);
+  if (!existsSync(sessionDir)) return { changes: null, lineCount: prevLineCount };
+
+  try {
+    let latestFile: string;
+
+    if (sessionId) {
+      // Use specific session ID
+      latestFile = join(sessionDir, `${sessionId}.jsonl`);
+      if (!existsSync(latestFile)) return { changes: null, lineCount: prevLineCount };
+    } else {
+      // Find most recently modified .jsonl file
+      const files = readdirSync(sessionDir)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => ({ name: f, mtime: statSync(join(sessionDir, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+      if (files.length === 0) return { changes: null, lineCount: prevLineCount };
+      latestFile = join(sessionDir, files[0].name);
+    }
+    // Only read new bytes since last check (efficient for large 70MB+ files)
+    const fd = openSync(latestFile, 'r');
+    const fileSize = fstatSync(fd).size;
+    if (fileSize <= prevLineCount) { closeSync(fd); return { changes: null, lineCount: fileSize }; }
+
+    const readFrom = Math.max(0, prevLineCount > 0 ? prevLineCount - 1 : 0);
+    const readSize = Math.min(fileSize - readFrom, 500_000); // max 500KB per check
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, readFrom);
+    closeSync(fd);
+
+    const tail = buf.toString('utf-8');
+    const newLines = tail.split('\n').filter(Boolean);
+    if (prevLineCount > 0 && newLines.length > 0) newLines.shift(); // skip partial first line
+
+    // Build matcher
+    let matcher: ((text: string) => boolean) | null = null;
+    if (pattern) {
+      try {
+        const re = new RegExp(pattern, 'i');
+        matcher = (text: string) => re.test(text);
+      } catch {
+        const lower = pattern.toLowerCase();
+        matcher = (text: string) => text.toLowerCase().includes(lower);
+      }
+    }
+
+    const entries: string[] = [];
+    for (const line of newLines) {
+      try {
+        const parsed = JSON.parse(line);
+        // Extract text content from various session JSONL formats
+        let text = '';
+        if (parsed.type === 'assistant' && parsed.message?.content) {
+          for (const block of (Array.isArray(parsed.message.content) ? parsed.message.content : [parsed.message.content])) {
+            if (typeof block === 'string') text += block;
+            else if (block.type === 'text' && block.text) text += block.text;
+            else if (block.type === 'tool_use') text += `[tool: ${block.name}] `;
+          }
+        } else if (parsed.type === 'result' && parsed.result) {
+          text = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
+        } else if (parsed.type === 'human' || parsed.type === 'user') {
+          const content = parsed.content || parsed.message?.content;
+          text = typeof content === 'string' ? content : '';
+        }
+
+        if (!text) continue;
+        if (matcher && !matcher(text)) continue;
+
+        // Context extraction around match
+        if (text.length > contextChars && pattern) {
+          let matchIdx = 0;
+          try { matchIdx = new RegExp(pattern, 'i').exec(text)?.index || 0; } catch {}
+          const half = Math.floor(contextChars / 2);
+          const start = Math.max(0, matchIdx - half);
+          const end = Math.min(text.length, start + contextChars);
+          text = (start > 0 ? '...' : '') + text.slice(start, end) + (end < text.length ? '...' : '');
+        } else {
+          text = text.slice(0, contextChars);
+        }
+        entries.push(text);
+      } catch {}
+    }
+
+    if (entries.length === 0) return { changes: null, lineCount: fileSize };
+
+    return {
+      changes: {
+        targetType: 'session',
+        description: `${entries.length} new session entries${pattern ? ` matching "${pattern}"` : ''}`,
+        files: entries.slice(0, 10),
+      },
+      lineCount: fileSize, // actually bytes, reusing field name
+    };
+  } catch {
+    return { changes: null, lineCount: prevLineCount };
+  }
+}
+
 // ─── WatchManager class ──────────────────────────────────
 
 export class WatchManager extends EventEmitter {
   private timers = new Map<string, NodeJS.Timeout>();
   private snapshots = new Map<string, WatchSnapshot>();
+  private pendingAlert = new Map<string, { changes: WatchChange[]; summary: string; timestamp: number }>();
+  private debounceTimers = new Map<string, NodeJS.Timeout>();
 
   constructor(
     private workspaceId: string,
@@ -229,6 +407,37 @@ export class WatchManager extends EventEmitter {
           }
           break;
         }
+        case 'agent_log': {
+          if (target.path) {
+            const agentLabel = this.getAgents().get(target.path)?.config.label || target.path;
+            const { changes, lineCount } = detectAgentLogChanges(this.workspaceId, target.path, target.pattern, prev.logLineCount || 0, target.contextChars || 500);
+            newSnapshot.logLineCount = lineCount;
+            if (changes) allChanges.push({ ...changes, description: `${agentLabel} log: ${changes.description}` });
+          }
+          break;
+        }
+        case 'session': {
+          // Resolve session ID: explicit (cmd field) > agent's cliSessionId > latest file
+          let sessionId: string | undefined;
+          if (target.cmd) {
+            // Explicit session ID selected by user
+            sessionId = target.cmd;
+          } else if (target.path) {
+            // Agent selected — use its current cliSessionId
+            const agents = this.getAgents();
+            const targetAgent = agents.get(target.path);
+            if (targetAgent) {
+              sessionId = (targetAgent.state as any).cliSessionId;
+              if (!sessionId) {
+                console.log(`[watch] Agent ${targetAgent.config.label} has no cliSessionId — falling back to latest session file`);
+              }
+            }
+          }
+          const { changes, lineCount: newFileSize } = detectSessionChanges(this.projectPath, target.pattern, prev.sessionFileSize || 0, target.contextChars || 500, sessionId);
+          newSnapshot.sessionFileSize = newFileSize;
+          if (changes) allChanges.push(changes);
+          break;
+        }
         case 'command': {
           const { changes, commandOutput } = detectCommandChanges(this.projectPath, target, prev.commandOutput);
           newSnapshot.commandOutput = commandOutput;
@@ -259,10 +468,40 @@ export class WatchManager extends EventEmitter {
 
     console.log(`[watch] ${config.label}: detected ${allChanges.length} change(s)`);
 
+    // Get debounce from first target that has it, or default 10s
+    const debounceMs = (config.watch!.targets.find(t => t.debounce !== undefined)?.debounce ?? 10) * 1000;
+
+    if (debounceMs > 0) {
+      // Accumulate changes, reset timer each time
+      const existing = this.pendingAlert.get(agentId);
+      const merged = existing ? [...existing.changes, ...allChanges] : allChanges;
+      const mergedSummary = merged.map(c =>
+        `[${c.targetType}] ${c.description}${c.files.length ? '\n  ' + c.files.join('\n  ') : ''}`
+      ).join('\n');
+      this.pendingAlert.set(agentId, { changes: merged, summary: mergedSummary, timestamp: Date.now() });
+
+      // Clear previous debounce timer, set new one
+      const prevTimer = this.debounceTimers.get(agentId);
+      if (prevTimer) clearTimeout(prevTimer);
+
+      this.debounceTimers.set(agentId, setTimeout(() => {
+        const pending = this.pendingAlert.get(agentId);
+        if (!pending) return;
+        this.pendingAlert.delete(agentId);
+        this.debounceTimers.delete(agentId);
+        this.emitAlert(agentId, config, pending.changes, pending.summary);
+      }, debounceMs));
+
+      console.log(`[watch] ${config.label}: debouncing ${debounceMs / 1000}s...`);
+    } else {
+      this.emitAlert(agentId, config, allChanges, summary);
+    }
+  }
+
+  private emitAlert(agentId: string, config: WorkspaceAgentConfig, allChanges: WatchChange[], summary: string): void {
     const entry = { type: 'system' as const, subtype: 'watch_detected', content: `🔍 Watch detected changes:\n${summary}`, timestamp: new Date().toISOString() };
     appendAgentLog(this.workspaceId, agentId, entry).catch(() => {});
 
-    // Emit SSE event for UI
     this.emit('watch_alert', {
       type: 'watch_alert',
       agentId,

package/middleware.ts

@@ -1,6 +1,12 @@
 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';
+  if (isDev) {
+    return NextResponse.next();
+  }
+
   const { pathname } = req.nextUrl;
 
   // Allow auth endpoints and static assets without login

package/next.config.ts

@@ -1,9 +1,17 @@
 import type { NextConfig } from 'next';
+import { networkInterfaces } from 'node:os';
 
 const terminalPort = parseInt(process.env.TERMINAL_PORT || '') || 3001;
 
+// Auto-detect local IPs for dev mode cross-origin access
+const localIPs = Object.values(networkInterfaces())
+  .flat()
+  .filter(i => i && !i.internal && i.family === 'IPv4')
+  .map(i => i!.address);
+
 const nextConfig: NextConfig = {
   serverExternalPackages: ['better-sqlite3'],
+  allowedDevOrigins: localIPs,
   async rewrites() {
     return [
       {

package/package.json

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